gcc/builtins.c

   1 /* Expand builtin functions.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  20 02110-1301, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "machmode.h"
  27 #include "real.h"
  28 #include "rtl.h"
  29 #include "tree.h"
  30 #include "tree-gimple.h"
  31 #include "flags.h"
  32 #include "regs.h"
  33 #include "hard-reg-set.h"
  34 #include "except.h"
  35 #include "function.h"
  36 #include "insn-config.h"
  37 #include "expr.h"
  38 #include "optabs.h"
  39 #include "libfuncs.h"
  40 #include "recog.h"
  41 #include "output.h"
  42 #include "typeclass.h"
  43 #include "toplev.h"
  44 #include "predict.h"
  45 #include "tm_p.h"
  46 #include "target.h"
  47 #include "langhooks.h"
  48 #include "basic-block.h"
  49 #include "tree-mudflap.h"
  50
  51 #ifndef PAD_VARARGS_DOWN
  52 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
  53 #endif
  54
  55 /* Define the names of the builtin function types and codes.  */
  56 const char *const built_in_class_names[4]
  57   = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
  58
  59 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
  60 const char * built_in_names[(int) END_BUILTINS] =
  61 {
  62 #include "builtins.def"
  63 };
  64 #undef DEF_BUILTIN
  65
  66 /* Setup an array of _DECL trees, make sure each element is
  67    initialized to NULL_TREE.  */
  68 tree built_in_decls[(int) END_BUILTINS];
  69 /* Declarations used when constructing the builtin implicitly in the compiler.
  70    It may be NULL_TREE when this is invalid (for instance runtime is not
  71    required to implement the function call in all cases).  */
  72 tree implicit_built_in_decls[(int) END_BUILTINS];
  73
  74 static int get_pointer_alignment (tree, unsigned int);
  75 static const char *c_getstr (tree);
  76 static rtx c_readstr (const char *, enum machine_mode);
  77 static int target_char_cast (tree, char *);
  78 static rtx get_memory_rtx (tree, tree);
  79 static int apply_args_size (void);
  80 static int apply_result_size (void);
  81 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
  82 static rtx result_vector (int, rtx);
  83 #endif
  84 static rtx expand_builtin_setjmp (tree, rtx);
  85 static void expand_builtin_update_setjmp_buf (rtx);
  86 static void expand_builtin_prefetch (tree);
  87 static rtx expand_builtin_apply_args (void);
  88 static rtx expand_builtin_apply_args_1 (void);
  89 static rtx expand_builtin_apply (rtx, rtx, rtx);
  90 static void expand_builtin_return (rtx);
  91 static enum type_class type_to_class (tree);
  92 static rtx expand_builtin_classify_type (tree);
  93 static void expand_errno_check (tree, rtx);
  94 static rtx expand_builtin_mathfn (tree, rtx, rtx);
  95 static rtx expand_builtin_mathfn_2 (tree, rtx, rtx);
  96 static rtx expand_builtin_mathfn_3 (tree, rtx, rtx);
  97 static rtx expand_builtin_sincos (tree);
  98 static rtx expand_builtin_int_roundingfn (tree, rtx, rtx);
  99 static rtx expand_builtin_args_info (tree);
 100 static rtx expand_builtin_next_arg (void);
 101 static rtx expand_builtin_va_start (tree);
 102 static rtx expand_builtin_va_end (tree);
 103 static rtx expand_builtin_va_copy (tree);
 104 static rtx expand_builtin_memcmp (tree, tree, rtx, enum machine_mode);
 105 static rtx expand_builtin_strcmp (tree, rtx, enum machine_mode);
 106 static rtx expand_builtin_strncmp (tree, rtx, enum machine_mode);
 107 static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
 108 static rtx expand_builtin_strcat (tree, tree, rtx, enum machine_mode);
 109 static rtx expand_builtin_strncat (tree, rtx, enum machine_mode);
 110 static rtx expand_builtin_strspn (tree, rtx, enum machine_mode);
 111 static rtx expand_builtin_strcspn (tree, rtx, enum machine_mode);
 112 static rtx expand_builtin_memcpy (tree, rtx, enum machine_mode);
 113 static rtx expand_builtin_mempcpy (tree, tree, rtx, enum machine_mode, int);
 114 static rtx expand_builtin_memmove (tree, tree, rtx, enum machine_mode, tree);
 115 static rtx expand_builtin_bcopy (tree);
 116 static rtx expand_builtin_strcpy (tree, tree, rtx, enum machine_mode);
 117 static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode);
 118 static rtx builtin_strncpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
 119 static rtx expand_builtin_strncpy (tree, rtx, enum machine_mode);
 120 static rtx builtin_memset_read_str (void *, HOST_WIDE_INT, enum machine_mode);
 121 static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, enum machine_mode);
 122 static rtx expand_builtin_memset (tree, rtx, enum machine_mode, tree);
 123 static rtx expand_builtin_bzero (tree);
 124 static rtx expand_builtin_strlen (tree, rtx, enum machine_mode);
 125 static rtx expand_builtin_strstr (tree, tree, rtx, enum machine_mode);
 126 static rtx expand_builtin_strpbrk (tree, tree, rtx, enum machine_mode);
 127 static rtx expand_builtin_strchr (tree, tree, rtx, enum machine_mode);
 128 static rtx expand_builtin_strrchr (tree, tree, rtx, enum machine_mode);
 129 static rtx expand_builtin_alloca (tree, rtx);
 130 static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);
 131 static rtx expand_builtin_frame_address (tree, tree);
 132 static rtx expand_builtin_fputs (tree, rtx, bool);
 133 static rtx expand_builtin_printf (tree, rtx, enum machine_mode, bool);
 134 static rtx expand_builtin_fprintf (tree, rtx, enum machine_mode, bool);
 135 static rtx expand_builtin_sprintf (tree, rtx, enum machine_mode);
 136 static tree stabilize_va_list (tree, int);
 137 static rtx expand_builtin_expect (tree, rtx);
 138 static tree fold_builtin_constant_p (tree);
 139 static tree fold_builtin_classify_type (tree);
 140 static tree fold_builtin_strlen (tree);
 141 static tree fold_builtin_inf (tree, int);
 142 static tree fold_builtin_nan (tree, tree, int);
 143 static int validate_arglist (tree, ...);
 144 static bool integer_valued_real_p (tree);
 145 static tree fold_trunc_transparent_mathfn (tree, tree);
 146 static bool readonly_data_expr (tree);
 147 static rtx expand_builtin_fabs (tree, rtx, rtx);
 148 static rtx expand_builtin_signbit (tree, rtx);
 149 static tree fold_builtin_cabs (tree, tree);
 150 static tree fold_builtin_sqrt (tree, tree);
 151 static tree fold_builtin_cbrt (tree, tree);
 152 static tree fold_builtin_pow (tree, tree, tree);
 153 static tree fold_builtin_powi (tree, tree, tree);
 154 static tree fold_builtin_sin (tree);
 155 static tree fold_builtin_cos (tree, tree, tree);
 156 static tree fold_builtin_tan (tree);
 157 static tree fold_builtin_atan (tree, tree);
 158 static tree fold_builtin_trunc (tree, tree);
 159 static tree fold_builtin_floor (tree, tree);
 160 static tree fold_builtin_ceil (tree, tree);
 161 static tree fold_builtin_round (tree, tree);
 162 static tree fold_builtin_int_roundingfn (tree, tree);
 163 static tree fold_builtin_bitop (tree, tree);
 164 static tree fold_builtin_memcpy (tree, tree);
 165 static tree fold_builtin_mempcpy (tree, tree, int);
 166 static tree fold_builtin_memmove (tree, tree);
 167 static tree fold_builtin_strchr (tree, tree);
 168 static tree fold_builtin_memcmp (tree);
 169 static tree fold_builtin_strcmp (tree);
 170 static tree fold_builtin_strncmp (tree);
 171 static tree fold_builtin_signbit (tree, tree);
 172 static tree fold_builtin_copysign (tree, tree, tree);
 173 static tree fold_builtin_isascii (tree);
 174 static tree fold_builtin_toascii (tree);
 175 static tree fold_builtin_isdigit (tree);
 176 static tree fold_builtin_fabs (tree, tree);
 177 static tree fold_builtin_abs (tree, tree);
 178 static tree fold_builtin_unordered_cmp (tree, tree, enum tree_code,
 179                                         enum tree_code);
 180 static tree fold_builtin_1 (tree, tree, bool);
 181
 182 static tree fold_builtin_strpbrk (tree, tree);
 183 static tree fold_builtin_strstr (tree, tree);
 184 static tree fold_builtin_strrchr (tree, tree);
 185 static tree fold_builtin_strcat (tree);
 186 static tree fold_builtin_strncat (tree);
 187 static tree fold_builtin_strspn (tree);
 188 static tree fold_builtin_strcspn (tree);
 189 static tree fold_builtin_sprintf (tree, int);
 190
 191 static rtx expand_builtin_object_size (tree);
 192 static rtx expand_builtin_memory_chk (tree, rtx, enum machine_mode,
 193                                       enum built_in_function);
 194 static void maybe_emit_chk_warning (tree, enum built_in_function);
 195 static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
 196 static tree fold_builtin_object_size (tree);
 197 static tree fold_builtin_strcat_chk (tree, tree);
 198 static tree fold_builtin_strncat_chk (tree, tree);
 199 static tree fold_builtin_sprintf_chk (tree, enum built_in_function);
 200 static tree fold_builtin_printf (tree, tree, bool, enum built_in_function);
 201 static tree fold_builtin_fprintf (tree, tree, bool, enum built_in_function);
 202 static bool init_target_chars (void);
 203
 204 static unsigned HOST_WIDE_INT target_newline;
 205 static unsigned HOST_WIDE_INT target_percent;
 206 static unsigned HOST_WIDE_INT target_c;
 207 static unsigned HOST_WIDE_INT target_s;
 208 static char target_percent_c[3];
 209 static char target_percent_s[3];
 210 static char target_percent_s_newline[4];
 211
 212 /* Return true if NODE should be considered for inline expansion regardless
 213    of the optimization level.  This means whenever a function is invoked with
 214    its "internal" name, which normally contains the prefix "__builtin".  */
 215
 216 static bool called_as_built_in (tree node)
 217 {
 218   const char *name = IDENTIFIER_POINTER (DECL_NAME (node));
 219   if (strncmp (name, "__builtin_", 10) == 0)
 220     return true;
 221   if (strncmp (name, "__sync_", 7) == 0)
 222     return true;
 223   return false;
 224 }
 225
 226 /* Return the alignment in bits of EXP, a pointer valued expression.
 227    But don't return more than MAX_ALIGN no matter what.
 228    The alignment returned is, by default, the alignment of the thing that
 229    EXP points to.  If it is not a POINTER_TYPE, 0 is returned.
 230
 231    Otherwise, look at the expression to see if we can do better, i.e., if the
 232    expression is actually pointing at an object whose alignment is tighter.  */
 233
 234 static int
 235 get_pointer_alignment (tree exp, unsigned int max_align)
 236 {
 237   unsigned int align, inner;
 238
 239   if (! POINTER_TYPE_P (TREE_TYPE (exp)))
 240     return 0;
 241
 242   align = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
 243   align = MIN (align, max_align);
 244
 245   while (1)
 246     {
 247       switch (TREE_CODE (exp))
 248         {
 249         case NOP_EXPR:
 250         case CONVERT_EXPR:
 251         case NON_LVALUE_EXPR:
 252           exp = TREE_OPERAND (exp, 0);
 253           if (! POINTER_TYPE_P (TREE_TYPE (exp)))
 254             return align;
 255
 256           inner = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
 257           align = MIN (inner, max_align);
 258           break;
 259
 260         case PLUS_EXPR:
 261           /* If sum of pointer + int, restrict our maximum alignment to that
 262              imposed by the integer.  If not, we can't do any better than
 263              ALIGN.  */
 264           if (! host_integerp (TREE_OPERAND (exp, 1), 1))
 265             return align;
 266
 267           while (((tree_low_cst (TREE_OPERAND (exp, 1), 1))
 268                   & (max_align / BITS_PER_UNIT - 1))
 269                  != 0)
 270             max_align >>= 1;
 271
 272           exp = TREE_OPERAND (exp, 0);
 273           break;
 274
 275         case ADDR_EXPR:
 276           /* See what we are pointing at and look at its alignment.  */
 277           exp = TREE_OPERAND (exp, 0);
 278           if (TREE_CODE (exp) == FUNCTION_DECL)
 279             align = FUNCTION_BOUNDARY;
 280           else if (DECL_P (exp))
 281             align = DECL_ALIGN (exp);
 282 #ifdef CONSTANT_ALIGNMENT
 283           else if (CONSTANT_CLASS_P (exp))
 284             align = CONSTANT_ALIGNMENT (exp, align);
 285 #endif
 286           return MIN (align, max_align);
 287
 288         default:
 289           return align;
 290         }
 291     }
 292 }
 293
 294 /* Compute the length of a C string.  TREE_STRING_LENGTH is not the right
 295    way, because it could contain a zero byte in the middle.
 296    TREE_STRING_LENGTH is the size of the character array, not the string.
 297
 298    ONLY_VALUE should be nonzero if the result is not going to be emitted
 299    into the instruction stream and zero if it is going to be expanded.
 300    E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
 301    is returned, otherwise NULL, since
 302    len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
 303    evaluate the side-effects.
 304
 305    The value returned is of type `ssizetype'.
 306
 307    Unfortunately, string_constant can't access the values of const char
 308    arrays with initializers, so neither can we do so here.  */
 309
 310 tree
 311 c_strlen (tree src, int only_value)
 312 {
 313   tree offset_node;
 314   HOST_WIDE_INT offset;
 315   int max;
 316   const char *ptr;
 317
 318   STRIP_NOPS (src);
 319   if (TREE_CODE (src) == COND_EXPR
 320       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 321     {
 322       tree len1, len2;
 323
 324       len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
 325       len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
 326       if (tree_int_cst_equal (len1, len2))
 327         return len1;
 328     }
 329
 330   if (TREE_CODE (src) == COMPOUND_EXPR
 331       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 332     return c_strlen (TREE_OPERAND (src, 1), only_value);
 333
 334   src = string_constant (src, &offset_node);
 335   if (src == 0)
 336     return 0;
 337
 338   max = TREE_STRING_LENGTH (src) - 1;
 339   ptr = TREE_STRING_POINTER (src);
 340
 341   if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
 342     {
 343       /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
 344          compute the offset to the following null if we don't know where to
 345          start searching for it.  */
 346       int i;
 347
 348       for (i = 0; i < max; i++)
 349         if (ptr[i] == 0)
 350           return 0;
 351
 352       /* We don't know the starting offset, but we do know that the string
 353          has no internal zero bytes.  We can assume that the offset falls
 354          within the bounds of the string; otherwise, the programmer deserves
 355          what he gets.  Subtract the offset from the length of the string,
 356          and return that.  This would perhaps not be valid if we were dealing
 357          with named arrays in addition to literal string constants.  */
 358
 359       return size_diffop (size_int (max), offset_node);
 360     }
 361
 362   /* We have a known offset into the string.  Start searching there for
 363      a null character if we can represent it as a single HOST_WIDE_INT.  */
 364   if (offset_node == 0)
 365     offset = 0;
 366   else if (! host_integerp (offset_node, 0))
 367     offset = -1;
 368   else
 369     offset = tree_low_cst (offset_node, 0);
 370
 371   /* If the offset is known to be out of bounds, warn, and call strlen at
 372      runtime.  */
 373   if (offset < 0 || offset > max)
 374     {
 375       warning (0, "offset outside bounds of constant string");
 376       return 0;
 377     }
 378
 379   /* Use strlen to search for the first zero byte.  Since any strings
 380      constructed with build_string will have nulls appended, we win even
 381      if we get handed something like (char[4])"abcd".
 382
 383      Since OFFSET is our starting index into the string, no further
 384      calculation is needed.  */
 385   return ssize_int (strlen (ptr + offset));
 386 }
 387
 388 /* Return a char pointer for a C string if it is a string constant
 389    or sum of string constant and integer constant.  */
 390
 391 static const char *
 392 c_getstr (tree src)
 393 {
 394   tree offset_node;
 395
 396   src = string_constant (src, &offset_node);
 397   if (src == 0)
 398     return 0;
 399
 400   if (offset_node == 0)
 401     return TREE_STRING_POINTER (src);
 402   else if (!host_integerp (offset_node, 1)
 403            || compare_tree_int (offset_node, TREE_STRING_LENGTH (src) - 1) > 0)
 404     return 0;
 405
 406   return TREE_STRING_POINTER (src) + tree_low_cst (offset_node, 1);
 407 }
 408
 409 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
 410    GET_MODE_BITSIZE (MODE) bits from string constant STR.  */
 411
 412 static rtx
 413 c_readstr (const char *str, enum machine_mode mode)
 414 {
 415   HOST_WIDE_INT c[2];
 416   HOST_WIDE_INT ch;
 417   unsigned int i, j;
 418
 419   gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
 420
 421   c[0] = 0;
 422   c[1] = 0;
 423   ch = 1;
 424   for (i = 0; i < GET_MODE_SIZE (mode); i++)
 425     {
 426       j = i;
 427       if (WORDS_BIG_ENDIAN)
 428         j = GET_MODE_SIZE (mode) - i - 1;
 429       if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
 430           && GET_MODE_SIZE (mode) > UNITS_PER_WORD)
 431         j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
 432       j *= BITS_PER_UNIT;
 433       gcc_assert (j <= 2 * HOST_BITS_PER_WIDE_INT);
 434
 435       if (ch)
 436         ch = (unsigned char) str[i];
 437       c[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
 438     }
 439   return immed_double_const (c[0], c[1], mode);
 440 }
 441
 442 /* Cast a target constant CST to target CHAR and if that value fits into
 443    host char type, return zero and put that value into variable pointed to by
 444    P.  */
 445
 446 static int
 447 target_char_cast (tree cst, char *p)
 448 {
 449   unsigned HOST_WIDE_INT val, hostval;
 450
 451   if (!host_integerp (cst, 1)
 452       || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
 453     return 1;
 454
 455   val = tree_low_cst (cst, 1);
 456   if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
 457     val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
 458
 459   hostval = val;
 460   if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
 461     hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
 462
 463   if (val != hostval)
 464     return 1;
 465
 466   *p = hostval;
 467   return 0;
 468 }
 469
 470 /* Similar to save_expr, but assumes that arbitrary code is not executed
 471    in between the multiple evaluations.  In particular, we assume that a
 472    non-addressable local variable will not be modified.  */
 473
 474 static tree
 475 builtin_save_expr (tree exp)
 476 {
 477   if (TREE_ADDRESSABLE (exp) == 0
 478       && (TREE_CODE (exp) == PARM_DECL
 479           || (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp))))
 480     return exp;
 481
 482   return save_expr (exp);
 483 }
 484
 485 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
 486    times to get the address of either a higher stack frame, or a return
 487    address located within it (depending on FNDECL_CODE).  */
 488
 489 static rtx
 490 expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
 491 {
 492   int i;
 493
 494 #ifdef INITIAL_FRAME_ADDRESS_RTX
 495   rtx tem = INITIAL_FRAME_ADDRESS_RTX;
 496 #else
 497   rtx tem;
 498
 499   /* For a zero count, we don't care what frame address we return, so frame
 500      pointer elimination is OK, and using the soft frame pointer is OK.
 501      For a non-zero count, we require a stable offset from the current frame
 502      pointer to the previous one, so we must use the hard frame pointer, and
 503      we must disable frame pointer elimination.  */
 504   if (count == 0)
 505     tem = frame_pointer_rtx;
 506   else
 507     {
 508       tem = hard_frame_pointer_rtx;
 509
 510       /* Tell reload not to eliminate the frame pointer.  */
 511       current_function_accesses_prior_frames = 1;
 512     }
 513 #endif
 514
 515   /* Some machines need special handling before we can access
 516      arbitrary frames.  For example, on the sparc, we must first flush
 517      all register windows to the stack.  */
 518 #ifdef SETUP_FRAME_ADDRESSES
 519   if (count > 0)
 520     SETUP_FRAME_ADDRESSES ();
 521 #endif
 522
 523   /* On the sparc, the return address is not in the frame, it is in a
 524      register.  There is no way to access it off of the current frame
 525      pointer, but it can be accessed off the previous frame pointer by
 526      reading the value from the register window save area.  */
 527 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
 528   if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
 529     count--;
 530 #endif
 531
 532   /* Scan back COUNT frames to the specified frame.  */
 533   for (i = 0; i < count; i++)
 534     {
 535       /* Assume the dynamic chain pointer is in the word that the
 536          frame address points to, unless otherwise specified.  */
 537 #ifdef DYNAMIC_CHAIN_ADDRESS
 538       tem = DYNAMIC_CHAIN_ADDRESS (tem);
 539 #endif
 540       tem = memory_address (Pmode, tem);
 541       tem = gen_frame_mem (Pmode, tem);
 542       tem = copy_to_reg (tem);
 543     }
 544
 545   /* For __builtin_frame_address, return what we've got.  */
 546   if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
 547     return tem;
 548
 549   /* For __builtin_return_address, Get the return address from that
 550      frame.  */
 551 #ifdef RETURN_ADDR_RTX
 552   tem = RETURN_ADDR_RTX (count, tem);
 553 #else
 554   tem = memory_address (Pmode,
 555                         plus_constant (tem, GET_MODE_SIZE (Pmode)));
 556   tem = gen_frame_mem (Pmode, tem);
 557 #endif
 558   return tem;
 559 }
 560
 561 /* Alias set used for setjmp buffer.  */
 562 static HOST_WIDE_INT setjmp_alias_set = -1;
 563
 564 /* Construct the leading half of a __builtin_setjmp call.  Control will
 565    return to RECEIVER_LABEL.  This is used directly by sjlj exception
 566    handling code.  */
 567
 568 void
 569 expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
 570 {
 571   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 572   rtx stack_save;
 573   rtx mem;
 574
 575   if (setjmp_alias_set == -1)
 576     setjmp_alias_set = new_alias_set ();
 577
 578   buf_addr = convert_memory_address (Pmode, buf_addr);
 579
 580   buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
 581
 582   /* We store the frame pointer and the address of receiver_label in
 583      the buffer and use the rest of it for the stack save area, which
 584      is machine-dependent.  */
 585
 586   mem = gen_rtx_MEM (Pmode, buf_addr);
 587   set_mem_alias_set (mem, setjmp_alias_set);
 588   emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());
 589
 590   mem = gen_rtx_MEM (Pmode, plus_constant (buf_addr, GET_MODE_SIZE (Pmode))),
 591   set_mem_alias_set (mem, setjmp_alias_set);
 592
 593   emit_move_insn (validize_mem (mem),
 594                   force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
 595
 596   stack_save = gen_rtx_MEM (sa_mode,
 597                             plus_constant (buf_addr,
 598                                            2 * GET_MODE_SIZE (Pmode)));
 599   set_mem_alias_set (stack_save, setjmp_alias_set);
 600   emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
 601
 602   /* If there is further processing to do, do it.  */
 603 #ifdef HAVE_builtin_setjmp_setup
 604   if (HAVE_builtin_setjmp_setup)
 605     emit_insn (gen_builtin_setjmp_setup (buf_addr));
 606 #endif
 607
 608   /* Tell optimize_save_area_alloca that extra work is going to
 609      need to go on during alloca.  */
 610   current_function_calls_setjmp = 1;
 611
 612   /* Set this so all the registers get saved in our frame; we need to be
 613      able to copy the saved values for any registers from frames we unwind.  */
 614   current_function_has_nonlocal_label = 1;
 615 }
 616
 617 /* Construct the trailing part of a __builtin_setjmp call.
 618    This is used directly by sjlj exception handling code.  */
 619
 620 void
 621 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED)
 622 {
 623   /* Clobber the FP when we get here, so we have to make sure it's
 624      marked as used by this function.  */
 625   emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
 626
 627   /* Mark the static chain as clobbered here so life information
 628      doesn't get messed up for it.  */
 629   emit_insn (gen_rtx_CLOBBER (VOIDmode, static_chain_rtx));
 630
 631   /* Now put in the code to restore the frame pointer, and argument
 632      pointer, if needed.  */
 633 #ifdef HAVE_nonlocal_goto
 634   if (! HAVE_nonlocal_goto)
 635 #endif
 636     emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
 637
 638 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
 639   if (fixed_regs[ARG_POINTER_REGNUM])
 640     {
 641 #ifdef ELIMINABLE_REGS
 642       size_t i;
 643       static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
 644
 645       for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
 646         if (elim_regs[i].from == ARG_POINTER_REGNUM
 647             && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
 648           break;
 649
 650       if (i == ARRAY_SIZE (elim_regs))
 651 #endif
 652         {
 653           /* Now restore our arg pointer from the address at which it
 654              was saved in our stack frame.  */
 655           emit_move_insn (virtual_incoming_args_rtx,
 656                           copy_to_reg (get_arg_pointer_save_area (cfun)));
 657         }
 658     }
 659 #endif
 660
 661 #ifdef HAVE_builtin_setjmp_receiver
 662   if (HAVE_builtin_setjmp_receiver)
 663     emit_insn (gen_builtin_setjmp_receiver (receiver_label));
 664   else
 665 #endif
 666 #ifdef HAVE_nonlocal_goto_receiver
 667     if (HAVE_nonlocal_goto_receiver)
 668       emit_insn (gen_nonlocal_goto_receiver ());
 669     else
 670 #endif
 671       { /* Nothing */ }
 672
 673   /* @@@ This is a kludge.  Not all machine descriptions define a blockage
 674      insn, but we must not allow the code we just generated to be reordered
 675      by scheduling.  Specifically, the update of the frame pointer must
 676      happen immediately, not later.  So emit an ASM_INPUT to act as blockage
 677      insn.  */
 678   emit_insn (gen_rtx_ASM_INPUT (VOIDmode, ""));
 679 }
 680
 681 /* __builtin_setjmp is passed a pointer to an array of five words (not
 682    all will be used on all machines).  It operates similarly to the C
 683    library function of the same name, but is more efficient.  Much of
 684    the code below (and for longjmp) is copied from the handling of
 685    non-local gotos.
 686
 687    NOTE: This is intended for use by GNAT and the exception handling
 688    scheme in the compiler and will only work in the method used by
 689    them.  */
 690
 691 static rtx
 692 expand_builtin_setjmp (tree arglist, rtx target)
 693 {
 694   rtx buf_addr, next_lab, cont_lab;
 695
 696   if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
 697     return NULL_RTX;
 698
 699   if (target == 0 || !REG_P (target)
 700       || REGNO (target) < FIRST_PSEUDO_REGISTER)
 701     target = gen_reg_rtx (TYPE_MODE (integer_type_node));
 702
 703   buf_addr = expand_expr (TREE_VALUE (arglist), NULL_RTX, VOIDmode, 0);
 704
 705   next_lab = gen_label_rtx ();
 706   cont_lab = gen_label_rtx ();
 707
 708   expand_builtin_setjmp_setup (buf_addr, next_lab);
 709
 710   /* Set TARGET to zero and branch to the continue label.  Use emit_jump to
 711      ensure that pending stack adjustments are flushed.  */
 712   emit_move_insn (target, const0_rtx);
 713   emit_jump (cont_lab);
 714
 715   emit_label (next_lab);
 716
 717   expand_builtin_setjmp_receiver (next_lab);
 718
 719   /* Set TARGET to one.  */
 720   emit_move_insn (target, const1_rtx);
 721   emit_label (cont_lab);
 722
 723   /* Tell flow about the strange goings on.  Putting `next_lab' on
 724      `nonlocal_goto_handler_labels' to indicates that function
 725      calls may traverse the arc back to this label.  */
 726
 727   current_function_has_nonlocal_label = 1;
 728   nonlocal_goto_handler_labels
 729     = gen_rtx_EXPR_LIST (VOIDmode, next_lab, nonlocal_goto_handler_labels);
 730
 731   return target;
 732 }
 733
 734 /* __builtin_longjmp is passed a pointer to an array of five words (not
 735    all will be used on all machines).  It operates similarly to the C
 736    library function of the same name, but is more efficient.  Much of
 737    the code below is copied from the handling of non-local gotos.
 738
 739    NOTE: This is intended for use by GNAT and the exception handling
 740    scheme in the compiler and will only work in the method used by
 741    them.  */
 742
 743 static void
 744 expand_builtin_longjmp (rtx buf_addr, rtx value)
 745 {
 746   rtx fp, lab, stack, insn, last;
 747   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 748
 749   if (setjmp_alias_set == -1)
 750     setjmp_alias_set = new_alias_set ();
 751
 752   buf_addr = convert_memory_address (Pmode, buf_addr);
 753
 754   buf_addr = force_reg (Pmode, buf_addr);
 755
 756   /* We used to store value in static_chain_rtx, but that fails if pointers
 757      are smaller than integers.  We instead require that the user must pass
 758      a second argument of 1, because that is what builtin_setjmp will
 759      return.  This also makes EH slightly more efficient, since we are no
 760      longer copying around a value that we don't care about.  */
 761   gcc_assert (value == const1_rtx);
 762
 763   last = get_last_insn ();
 764 #ifdef HAVE_builtin_longjmp
 765   if (HAVE_builtin_longjmp)
 766     emit_insn (gen_builtin_longjmp (buf_addr));
 767   else
 768 #endif
 769     {
 770       fp = gen_rtx_MEM (Pmode, buf_addr);
 771       lab = gen_rtx_MEM (Pmode, plus_constant (buf_addr,
 772                                                GET_MODE_SIZE (Pmode)));
 773
 774       stack = gen_rtx_MEM (sa_mode, plus_constant (buf_addr,
 775                                                    2 * GET_MODE_SIZE (Pmode)));
 776       set_mem_alias_set (fp, setjmp_alias_set);
 777       set_mem_alias_set (lab, setjmp_alias_set);
 778       set_mem_alias_set (stack, setjmp_alias_set);
 779
 780       /* Pick up FP, label, and SP from the block and jump.  This code is
 781          from expand_goto in stmt.c; see there for detailed comments.  */
 782 #if HAVE_nonlocal_goto
 783       if (HAVE_nonlocal_goto)
 784         /* We have to pass a value to the nonlocal_goto pattern that will
 785            get copied into the static_chain pointer, but it does not matter
 786            what that value is, because builtin_setjmp does not use it.  */
 787         emit_insn (gen_nonlocal_goto (value, lab, stack, fp));
 788       else
 789 #endif
 790         {
 791           lab = copy_to_reg (lab);
 792
 793           emit_insn (gen_rtx_CLOBBER (VOIDmode,
 794                                       gen_rtx_MEM (BLKmode,
 795                                                    gen_rtx_SCRATCH (VOIDmode))));
 796           emit_insn (gen_rtx_CLOBBER (VOIDmode,
 797                                       gen_rtx_MEM (BLKmode,
 798                                                    hard_frame_pointer_rtx)));
 799
 800           emit_move_insn (hard_frame_pointer_rtx, fp);
 801           emit_stack_restore (SAVE_NONLOCAL, stack, NULL_RTX);
 802
 803           emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
 804           emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
 805           emit_indirect_jump (lab);
 806         }
 807     }
 808
 809   /* Search backwards and mark the jump insn as a non-local goto.
 810      Note that this precludes the use of __builtin_longjmp to a
 811      __builtin_setjmp target in the same function.  However, we've
 812      already cautioned the user that these functions are for
 813      internal exception handling use only.  */
 814   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
 815     {
 816       gcc_assert (insn != last);
 817
 818       if (JUMP_P (insn))
 819         {
 820           REG_NOTES (insn) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO, const0_rtx,
 821                                               REG_NOTES (insn));
 822           break;
 823         }
 824       else if (CALL_P (insn))
 825         break;
 826     }
 827 }
 828
 829 /* Expand a call to __builtin_nonlocal_goto.  We're passed the target label
 830    and the address of the save area.  */
 831
 832 static rtx
 833 expand_builtin_nonlocal_goto (tree arglist)
 834 {
 835   tree t_label, t_save_area;
 836   rtx r_label, r_save_area, r_fp, r_sp, insn;
 837
 838   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
 839     return NULL_RTX;
 840
 841   t_label = TREE_VALUE (arglist);
 842   arglist = TREE_CHAIN (arglist);
 843   t_save_area = TREE_VALUE (arglist);
 844
 845   r_label = expand_expr (t_label, NULL_RTX, VOIDmode, 0);
 846   r_label = convert_memory_address (Pmode, r_label);
 847   r_save_area = expand_expr (t_save_area, NULL_RTX, VOIDmode, 0);
 848   r_save_area = convert_memory_address (Pmode, r_save_area);
 849   r_fp = gen_rtx_MEM (Pmode, r_save_area);
 850   r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL),
 851                       plus_constant (r_save_area, GET_MODE_SIZE (Pmode)));
 852
 853   current_function_has_nonlocal_goto = 1;
 854
 855 #if HAVE_nonlocal_goto
 856   /* ??? We no longer need to pass the static chain value, afaik.  */
 857   if (HAVE_nonlocal_goto)
 858     emit_insn (gen_nonlocal_goto (const0_rtx, r_label, r_sp, r_fp));
 859   else
 860 #endif
 861     {
 862       r_label = copy_to_reg (r_label);
 863
 864       emit_insn (gen_rtx_CLOBBER (VOIDmode,
 865                                   gen_rtx_MEM (BLKmode,
 866                                                gen_rtx_SCRATCH (VOIDmode))));
 867
 868       emit_insn (gen_rtx_CLOBBER (VOIDmode,
 869                                   gen_rtx_MEM (BLKmode,
 870                                                hard_frame_pointer_rtx)));
 871
 872       /* Restore frame pointer for containing function.
 873          This sets the actual hard register used for the frame pointer
 874          to the location of the function's incoming static chain info.
 875          The non-local goto handler will then adjust it to contain the
 876          proper value and reload the argument pointer, if needed.  */
 877       emit_move_insn (hard_frame_pointer_rtx, r_fp);
 878       emit_stack_restore (SAVE_NONLOCAL, r_sp, NULL_RTX);
 879
 880       /* USE of hard_frame_pointer_rtx added for consistency;
 881          not clear if really needed.  */
 882       emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
 883       emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
 884       emit_indirect_jump (r_label);
 885     }
 886
 887   /* Search backwards to the jump insn and mark it as a
 888      non-local goto.  */
 889   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
 890     {
 891       if (JUMP_P (insn))
 892         {
 893           REG_NOTES (insn) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO,
 894                                               const0_rtx, REG_NOTES (insn));
 895           break;
 896         }
 897       else if (CALL_P (insn))
 898         break;
 899     }
 900
 901   return const0_rtx;
 902 }
 903
 904 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
 905    (not all will be used on all machines) that was passed to __builtin_setjmp.
 906    It updates the stack pointer in that block to correspond to the current
 907    stack pointer.  */
 908
 909 static void
 910 expand_builtin_update_setjmp_buf (rtx buf_addr)
 911 {
 912   enum machine_mode sa_mode = Pmode;
 913   rtx stack_save;
 914
 915
 916 #ifdef HAVE_save_stack_nonlocal
 917   if (HAVE_save_stack_nonlocal)
 918     sa_mode = insn_data[(int) CODE_FOR_save_stack_nonlocal].operand[0].mode;
 919 #endif
 920 #ifdef STACK_SAVEAREA_MODE
 921   sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 922 #endif
 923
 924   stack_save
 925     = gen_rtx_MEM (sa_mode,
 926                    memory_address
 927                    (sa_mode,
 928                     plus_constant (buf_addr, 2 * GET_MODE_SIZE (Pmode))));
 929
 930 #ifdef HAVE_setjmp
 931   if (HAVE_setjmp)
 932     emit_insn (gen_setjmp ());
 933 #endif
 934
 935   emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
 936 }
 937
 938 /* Expand a call to __builtin_prefetch.  For a target that does not support
 939    data prefetch, evaluate the memory address argument in case it has side
 940    effects.  */
 941
 942 static void
 943 expand_builtin_prefetch (tree arglist)
 944 {
 945   tree arg0, arg1, arg2;
 946   rtx op0, op1, op2;
 947
 948   if (!validate_arglist (arglist, POINTER_TYPE, 0))
 949     return;
 950
 951   arg0 = TREE_VALUE (arglist);
 952   /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
 953      zero (read) and argument 2 (locality) defaults to 3 (high degree of
 954      locality).  */
 955   if (TREE_CHAIN (arglist))
 956     {
 957       arg1 = TREE_VALUE (TREE_CHAIN (arglist));
 958       if (TREE_CHAIN (TREE_CHAIN (arglist)))
 959         arg2 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
 960       else
 961         arg2 = build_int_cst (NULL_TREE, 3);
 962     }
 963   else
 964     {
 965       arg1 = integer_zero_node;
 966       arg2 = build_int_cst (NULL_TREE, 3);
 967     }
 968
 969   /* Argument 0 is an address.  */
 970   op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
 971
 972   /* Argument 1 (read/write flag) must be a compile-time constant int.  */
 973   if (TREE_CODE (arg1) != INTEGER_CST)
 974     {
 975       error ("second argument to %<__builtin_prefetch%> must be a constant");
 976       arg1 = integer_zero_node;
 977     }
 978   op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
 979   /* Argument 1 must be either zero or one.  */
 980   if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
 981     {
 982       warning (0, "invalid second argument to %<__builtin_prefetch%>;"
 983                " using zero");
 984       op1 = const0_rtx;
 985     }
 986
 987   /* Argument 2 (locality) must be a compile-time constant int.  */
 988   if (TREE_CODE (arg2) != INTEGER_CST)
 989     {
 990       error ("third argument to %<__builtin_prefetch%> must be a constant");
 991       arg2 = integer_zero_node;
 992     }
 993   op2 = expand_expr (arg2, NULL_RTX, VOIDmode, 0);
 994   /* Argument 2 must be 0, 1, 2, or 3.  */
 995   if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
 996     {
 997       warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
 998       op2 = const0_rtx;
 999     }
1000
1001 #ifdef HAVE_prefetch
1002   if (HAVE_prefetch)
1003     {
1004       if ((! (*insn_data[(int) CODE_FOR_prefetch].operand[0].predicate)
1005              (op0,
1006               insn_data[(int) CODE_FOR_prefetch].operand[0].mode))
1007           || (GET_MODE (op0) != Pmode))
1008         {
1009           op0 = convert_memory_address (Pmode, op0);
1010           op0 = force_reg (Pmode, op0);
1011         }
1012       emit_insn (gen_prefetch (op0, op1, op2));
1013     }
1014 #endif
1015
1016   /* Don't do anything with direct references to volatile memory, but
1017      generate code to handle other side effects.  */
1018   if (!MEM_P (op0) && side_effects_p (op0))
1019     emit_insn (op0);
1020 }
1021
1022 /* Get a MEM rtx for expression EXP which is the address of an operand
1023    to be used in a string instruction (cmpstrsi, movmemsi, ..).  LEN is
1024    the maximum length of the block of memory that might be accessed or
1025    NULL if unknown.  */
1026
1027 static rtx
1028 get_memory_rtx (tree exp, tree len)
1029 {
1030   rtx addr = expand_expr (exp, NULL_RTX, ptr_mode, EXPAND_NORMAL);
1031   rtx mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
1032
1033   /* Get an expression we can use to find the attributes to assign to MEM.
1034      If it is an ADDR_EXPR, use the operand.  Otherwise, dereference it if
1035      we can.  First remove any nops.  */
1036   while ((TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
1037           || TREE_CODE (exp) == NON_LVALUE_EXPR)
1038          && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
1039     exp = TREE_OPERAND (exp, 0);
1040
1041   if (TREE_CODE (exp) == ADDR_EXPR)
1042     exp = TREE_OPERAND (exp, 0);
1043   else if (POINTER_TYPE_P (TREE_TYPE (exp)))
1044     exp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (exp)), exp);
1045   else
1046     exp = NULL;
1047
1048   /* Honor attributes derived from exp, except for the alias set
1049      (as builtin stringops may alias with anything) and the size
1050      (as stringops may access multiple array elements).  */
1051   if (exp)
1052     {
1053       set_mem_attributes (mem, exp, 0);
1054
1055       /* Allow the string and memory builtins to overflow from one
1056          field into another, see http://gcc.gnu.org/PR23561.
1057          Thus avoid COMPONENT_REFs in MEM_EXPR unless we know the whole
1058          memory accessed by the string or memory builtin will fit
1059          within the field.  */
1060       if (MEM_EXPR (mem) && TREE_CODE (MEM_EXPR (mem)) == COMPONENT_REF)
1061         {
1062           tree mem_expr = MEM_EXPR (mem);
1063           HOST_WIDE_INT offset = -1, length = -1;
1064           tree inner = exp;
1065
1066           while (TREE_CODE (inner) == ARRAY_REF
1067                  || TREE_CODE (inner) == NOP_EXPR
1068                  || TREE_CODE (inner) == CONVERT_EXPR
1069                  || TREE_CODE (inner) == NON_LVALUE_EXPR
1070                  || TREE_CODE (inner) == VIEW_CONVERT_EXPR
1071                  || TREE_CODE (inner) == SAVE_EXPR)
1072             inner = TREE_OPERAND (inner, 0);
1073
1074           gcc_assert (TREE_CODE (inner) == COMPONENT_REF);
1075
1076           if (MEM_OFFSET (mem)
1077               && GET_CODE (MEM_OFFSET (mem)) == CONST_INT)
1078             offset = INTVAL (MEM_OFFSET (mem));
1079
1080           if (offset >= 0 && len && host_integerp (len, 0))
1081             length = tree_low_cst (len, 0);
1082
1083           while (TREE_CODE (inner) == COMPONENT_REF)
1084             {
1085               tree field = TREE_OPERAND (inner, 1);
1086               gcc_assert (! DECL_BIT_FIELD (field));
1087               gcc_assert (TREE_CODE (mem_expr) == COMPONENT_REF);
1088               gcc_assert (field == TREE_OPERAND (mem_expr, 1));
1089
1090               if (length >= 0
1091                   && TYPE_SIZE_UNIT (TREE_TYPE (inner))
1092                   && host_integerp (TYPE_SIZE_UNIT (TREE_TYPE (inner)), 0))
1093                 {
1094                   HOST_WIDE_INT size
1095                     = tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (inner)), 0);
1096                   /* If we can prove the memory starting at XEXP (mem, 0)
1097                      and ending at XEXP (mem, 0) + LENGTH will fit into
1098                      this field, we can keep that COMPONENT_REF in MEM_EXPR.  */
1099                   if (offset <= size
1100                       && length <= size
1101                       && offset + length <= size)
1102                     break;
1103                 }
1104
1105               if (offset >= 0
1106                   && host_integerp (DECL_FIELD_OFFSET (field), 0))
1107                 offset += tree_low_cst (DECL_FIELD_OFFSET (field), 0)
1108                           + tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1109                             / BITS_PER_UNIT;
1110               else
1111                 {
1112                   offset = -1;
1113                   length = -1;
1114                 }
1115
1116               mem_expr = TREE_OPERAND (mem_expr, 0);
1117               inner = TREE_OPERAND (inner, 0);
1118             }
1119
1120           if (mem_expr == NULL)
1121             offset = -1;
1122           if (mem_expr != MEM_EXPR (mem))
1123             {
1124               set_mem_expr (mem, mem_expr);
1125               set_mem_offset (mem, offset >= 0 ? GEN_INT (offset) : NULL_RTX);
1126             }
1127         }
1128       set_mem_alias_set (mem, 0);
1129       set_mem_size (mem, NULL_RTX);
1130     }
1131
1132   return mem;
1133 }
1134 \f
1135 /* Built-in functions to perform an untyped call and return.  */
1136
1137 /* For each register that may be used for calling a function, this
1138    gives a mode used to copy the register's value.  VOIDmode indicates
1139    the register is not used for calling a function.  If the machine
1140    has register windows, this gives only the outbound registers.
1141    INCOMING_REGNO gives the corresponding inbound register.  */
1142 static enum machine_mode apply_args_mode[FIRST_PSEUDO_REGISTER];
1143
1144 /* For each register that may be used for returning values, this gives
1145    a mode used to copy the register's value.  VOIDmode indicates the
1146    register is not used for returning values.  If the machine has
1147    register windows, this gives only the outbound registers.
1148    INCOMING_REGNO gives the corresponding inbound register.  */
1149 static enum machine_mode apply_result_mode[FIRST_PSEUDO_REGISTER];
1150
1151 /* For each register that may be used for calling a function, this
1152    gives the offset of that register into the block returned by
1153    __builtin_apply_args.  0 indicates that the register is not
1154    used for calling a function.  */
1155 static int apply_args_reg_offset[FIRST_PSEUDO_REGISTER];
1156
1157 /* Return the size required for the block returned by __builtin_apply_args,
1158    and initialize apply_args_mode.  */
1159
1160 static int
1161 apply_args_size (void)
1162 {
1163   static int size = -1;
1164   int align;
1165   unsigned int regno;
1166   enum machine_mode mode;
1167
1168   /* The values computed by this function never change.  */
1169   if (size < 0)
1170     {
1171       /* The first value is the incoming arg-pointer.  */
1172       size = GET_MODE_SIZE (Pmode);
1173
1174       /* The second value is the structure value address unless this is
1175          passed as an "invisible" first argument.  */
1176       if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1177         size += GET_MODE_SIZE (Pmode);
1178
1179       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1180         if (FUNCTION_ARG_REGNO_P (regno))
1181           {
1182             mode = reg_raw_mode[regno];
1183
1184             gcc_assert (mode != VOIDmode);
1185
1186             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1187             if (size % align != 0)
1188               size = CEIL (size, align) * align;
1189             apply_args_reg_offset[regno] = size;
1190             size += GET_MODE_SIZE (mode);
1191             apply_args_mode[regno] = mode;
1192           }
1193         else
1194           {
1195             apply_args_mode[regno] = VOIDmode;
1196             apply_args_reg_offset[regno] = 0;
1197           }
1198     }
1199   return size;
1200 }
1201
1202 /* Return the size required for the block returned by __builtin_apply,
1203    and initialize apply_result_mode.  */
1204
1205 static int
1206 apply_result_size (void)
1207 {
1208   static int size = -1;
1209   int align, regno;
1210   enum machine_mode mode;
1211
1212   /* The values computed by this function never change.  */
1213   if (size < 0)
1214     {
1215       size = 0;
1216
1217       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1218         if (FUNCTION_VALUE_REGNO_P (regno))
1219           {
1220             mode = reg_raw_mode[regno];
1221
1222             gcc_assert (mode != VOIDmode);
1223
1224             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1225             if (size % align != 0)
1226               size = CEIL (size, align) * align;
1227             size += GET_MODE_SIZE (mode);
1228             apply_result_mode[regno] = mode;
1229           }
1230         else
1231           apply_result_mode[regno] = VOIDmode;
1232
1233       /* Allow targets that use untyped_call and untyped_return to override
1234          the size so that machine-specific information can be stored here.  */
1235 #ifdef APPLY_RESULT_SIZE
1236       size = APPLY_RESULT_SIZE;
1237 #endif
1238     }
1239   return size;
1240 }
1241
1242 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1243 /* Create a vector describing the result block RESULT.  If SAVEP is true,
1244    the result block is used to save the values; otherwise it is used to
1245    restore the values.  */
1246
1247 static rtx
1248 result_vector (int savep, rtx result)
1249 {
1250   int regno, size, align, nelts;
1251   enum machine_mode mode;
1252   rtx reg, mem;
1253   rtx *savevec = alloca (FIRST_PSEUDO_REGISTER * sizeof (rtx));
1254
1255   size = nelts = 0;
1256   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1257     if ((mode = apply_result_mode[regno]) != VOIDmode)
1258       {
1259         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1260         if (size % align != 0)
1261           size = CEIL (size, align) * align;
1262         reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1263         mem = adjust_address (result, mode, size);
1264         savevec[nelts++] = (savep
1265                             ? gen_rtx_SET (VOIDmode, mem, reg)
1266                             : gen_rtx_SET (VOIDmode, reg, mem));
1267         size += GET_MODE_SIZE (mode);
1268       }
1269   return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1270 }
1271 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1272
1273 /* Save the state required to perform an untyped call with the same
1274    arguments as were passed to the current function.  */
1275
1276 static rtx
1277 expand_builtin_apply_args_1 (void)
1278 {
1279   rtx registers, tem;
1280   int size, align, regno;
1281   enum machine_mode mode;
1282   rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1283
1284   /* Create a block where the arg-pointer, structure value address,
1285      and argument registers can be saved.  */
1286   registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1287
1288   /* Walk past the arg-pointer and structure value address.  */
1289   size = GET_MODE_SIZE (Pmode);
1290   if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1291     size += GET_MODE_SIZE (Pmode);
1292
1293   /* Save each register used in calling a function to the block.  */
1294   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1295     if ((mode = apply_args_mode[regno]) != VOIDmode)
1296       {
1297         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1298         if (size % align != 0)
1299           size = CEIL (size, align) * align;
1300
1301         tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1302
1303         emit_move_insn (adjust_address (registers, mode, size), tem);
1304         size += GET_MODE_SIZE (mode);
1305       }
1306
1307   /* Save the arg pointer to the block.  */
1308   tem = copy_to_reg (virtual_incoming_args_rtx);
1309 #ifdef STACK_GROWS_DOWNWARD
1310   /* We need the pointer as the caller actually passed them to us, not
1311      as we might have pretended they were passed.  Make sure it's a valid
1312      operand, as emit_move_insn isn't expected to handle a PLUS.  */
1313   tem
1314     = force_operand (plus_constant (tem, current_function_pretend_args_size),
1315                      NULL_RTX);
1316 #endif
1317   emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1318
1319   size = GET_MODE_SIZE (Pmode);
1320
1321   /* Save the structure value address unless this is passed as an
1322      "invisible" first argument.  */
1323   if (struct_incoming_value)
1324     {
1325       emit_move_insn (adjust_address (registers, Pmode, size),
1326                       copy_to_reg (struct_incoming_value));
1327       size += GET_MODE_SIZE (Pmode);
1328     }
1329
1330   /* Return the address of the block.  */
1331   return copy_addr_to_reg (XEXP (registers, 0));
1332 }
1333
1334 /* __builtin_apply_args returns block of memory allocated on
1335    the stack into which is stored the arg pointer, structure
1336    value address, static chain, and all the registers that might
1337    possibly be used in performing a function call.  The code is
1338    moved to the start of the function so the incoming values are
1339    saved.  */
1340
1341 static rtx
1342 expand_builtin_apply_args (void)
1343 {
1344   /* Don't do __builtin_apply_args more than once in a function.
1345      Save the result of the first call and reuse it.  */
1346   if (apply_args_value != 0)
1347     return apply_args_value;
1348   {
1349     /* When this function is called, it means that registers must be
1350        saved on entry to this function.  So we migrate the
1351        call to the first insn of this function.  */
1352     rtx temp;
1353     rtx seq;
1354
1355     start_sequence ();
1356     temp = expand_builtin_apply_args_1 ();
1357     seq = get_insns ();
1358     end_sequence ();
1359
1360     apply_args_value = temp;
1361
1362     /* Put the insns after the NOTE that starts the function.
1363        If this is inside a start_sequence, make the outer-level insn
1364        chain current, so the code is placed at the start of the
1365        function.  */
1366     push_topmost_sequence ();
1367     emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
1368     pop_topmost_sequence ();
1369     return temp;
1370   }
1371 }
1372
1373 /* Perform an untyped call and save the state required to perform an
1374    untyped return of whatever value was returned by the given function.  */
1375
1376 static rtx
1377 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1378 {
1379   int size, align, regno;
1380   enum machine_mode mode;
1381   rtx incoming_args, result, reg, dest, src, call_insn;
1382   rtx old_stack_level = 0;
1383   rtx call_fusage = 0;
1384   rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1385
1386   arguments = convert_memory_address (Pmode, arguments);
1387
1388   /* Create a block where the return registers can be saved.  */
1389   result = assign_stack_local (BLKmode, apply_result_size (), -1);
1390
1391   /* Fetch the arg pointer from the ARGUMENTS block.  */
1392   incoming_args = gen_reg_rtx (Pmode);
1393   emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1394 #ifndef STACK_GROWS_DOWNWARD
1395   incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1396                                        incoming_args, 0, OPTAB_LIB_WIDEN);
1397 #endif
1398
1399   /* Push a new argument block and copy the arguments.  Do not allow
1400      the (potential) memcpy call below to interfere with our stack
1401      manipulations.  */
1402   do_pending_stack_adjust ();
1403   NO_DEFER_POP;
1404
1405   /* Save the stack with nonlocal if available.  */
1406 #ifdef HAVE_save_stack_nonlocal
1407   if (HAVE_save_stack_nonlocal)
1408     emit_stack_save (SAVE_NONLOCAL, &old_stack_level, NULL_RTX);
1409   else
1410 #endif
1411     emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1412
1413   /* Allocate a block of memory onto the stack and copy the memory
1414      arguments to the outgoing arguments address.  */
1415   allocate_dynamic_stack_space (argsize, 0, BITS_PER_UNIT);
1416   dest = virtual_outgoing_args_rtx;
1417 #ifndef STACK_GROWS_DOWNWARD
1418   if (GET_CODE (argsize) == CONST_INT)
1419     dest = plus_constant (dest, -INTVAL (argsize));
1420   else
1421     dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1422 #endif
1423   dest = gen_rtx_MEM (BLKmode, dest);
1424   set_mem_align (dest, PARM_BOUNDARY);
1425   src = gen_rtx_MEM (BLKmode, incoming_args);
1426   set_mem_align (src, PARM_BOUNDARY);
1427   emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1428
1429   /* Refer to the argument block.  */
1430   apply_args_size ();
1431   arguments = gen_rtx_MEM (BLKmode, arguments);
1432   set_mem_align (arguments, PARM_BOUNDARY);
1433
1434   /* Walk past the arg-pointer and structure value address.  */
1435   size = GET_MODE_SIZE (Pmode);
1436   if (struct_value)
1437     size += GET_MODE_SIZE (Pmode);
1438
1439   /* Restore each of the registers previously saved.  Make USE insns
1440      for each of these registers for use in making the call.  */
1441   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1442     if ((mode = apply_args_mode[regno]) != VOIDmode)
1443       {
1444         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1445         if (size % align != 0)
1446           size = CEIL (size, align) * align;
1447         reg = gen_rtx_REG (mode, regno);
1448         emit_move_insn (reg, adjust_address (arguments, mode, size));
1449         use_reg (&call_fusage, reg);
1450         size += GET_MODE_SIZE (mode);
1451       }
1452
1453   /* Restore the structure value address unless this is passed as an
1454      "invisible" first argument.  */
1455   size = GET_MODE_SIZE (Pmode);
1456   if (struct_value)
1457     {
1458       rtx value = gen_reg_rtx (Pmode);
1459       emit_move_insn (value, adjust_address (arguments, Pmode, size));
1460       emit_move_insn (struct_value, value);
1461       if (REG_P (struct_value))
1462         use_reg (&call_fusage, struct_value);
1463       size += GET_MODE_SIZE (Pmode);
1464     }
1465
1466   /* All arguments and registers used for the call are set up by now!  */
1467   function = prepare_call_address (function, NULL, &call_fusage, 0, 0);
1468
1469   /* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
1470      and we don't want to load it into a register as an optimization,
1471      because prepare_call_address already did it if it should be done.  */
1472   if (GET_CODE (function) != SYMBOL_REF)
1473     function = memory_address (FUNCTION_MODE, function);
1474
1475   /* Generate the actual call instruction and save the return value.  */
1476 #ifdef HAVE_untyped_call
1477   if (HAVE_untyped_call)
1478     emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
1479                                       result, result_vector (1, result)));
1480   else
1481 #endif
1482 #ifdef HAVE_call_value
1483   if (HAVE_call_value)
1484     {
1485       rtx valreg = 0;
1486
1487       /* Locate the unique return register.  It is not possible to
1488          express a call that sets more than one return register using
1489          call_value; use untyped_call for that.  In fact, untyped_call
1490          only needs to save the return registers in the given block.  */
1491       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1492         if ((mode = apply_result_mode[regno]) != VOIDmode)
1493           {
1494             gcc_assert (!valreg); /* HAVE_untyped_call required.  */
1495
1496             valreg = gen_rtx_REG (mode, regno);
1497           }
1498
1499       emit_call_insn (GEN_CALL_VALUE (valreg,
1500                                       gen_rtx_MEM (FUNCTION_MODE, function),
1501                                       const0_rtx, NULL_RTX, const0_rtx));
1502
1503       emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1504     }
1505   else
1506 #endif
1507     gcc_unreachable ();
1508
1509   /* Find the CALL insn we just emitted, and attach the register usage
1510      information.  */
1511   call_insn = last_call_insn ();
1512   add_function_usage_to (call_insn, call_fusage);
1513
1514   /* Restore the stack.  */
1515 #ifdef HAVE_save_stack_nonlocal
1516   if (HAVE_save_stack_nonlocal)
1517     emit_stack_restore (SAVE_NONLOCAL, old_stack_level, NULL_RTX);
1518   else
1519 #endif
1520     emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1521
1522   OK_DEFER_POP;
1523
1524   /* Return the address of the result block.  */
1525   result = copy_addr_to_reg (XEXP (result, 0));
1526   return convert_memory_address (ptr_mode, result);
1527 }
1528
1529 /* Perform an untyped return.  */
1530
1531 static void
1532 expand_builtin_return (rtx result)
1533 {
1534   int size, align, regno;
1535   enum machine_mode mode;
1536   rtx reg;
1537   rtx call_fusage = 0;
1538
1539   result = convert_memory_address (Pmode, result);
1540
1541   apply_result_size ();
1542   result = gen_rtx_MEM (BLKmode, result);
1543
1544 #ifdef HAVE_untyped_return
1545   if (HAVE_untyped_return)
1546     {
1547       emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1548       emit_barrier ();
1549       return;
1550     }
1551 #endif
1552
1553   /* Restore the return value and note that each value is used.  */
1554   size = 0;
1555   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1556     if ((mode = apply_result_mode[regno]) != VOIDmode)
1557       {
1558         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1559         if (size % align != 0)
1560           size = CEIL (size, align) * align;
1561         reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1562         emit_move_insn (reg, adjust_address (result, mode, size));
1563
1564         push_to_sequence (call_fusage);
1565         emit_insn (gen_rtx_USE (VOIDmode, reg));
1566         call_fusage = get_insns ();
1567         end_sequence ();
1568         size += GET_MODE_SIZE (mode);
1569       }
1570
1571   /* Put the USE insns before the return.  */
1572   emit_insn (call_fusage);
1573
1574   /* Return whatever values was restored by jumping directly to the end
1575      of the function.  */
1576   expand_naked_return ();
1577 }
1578
1579 /* Used by expand_builtin_classify_type and fold_builtin_classify_type.  */
1580
1581 static enum type_class
1582 type_to_class (tree type)
1583 {
1584   switch (TREE_CODE (type))
1585     {
1586     case VOID_TYPE:        return void_type_class;
1587     case INTEGER_TYPE:     return integer_type_class;
1588     case CHAR_TYPE:        return char_type_class;
1589     case ENUMERAL_TYPE:    return enumeral_type_class;
1590     case BOOLEAN_TYPE:     return boolean_type_class;
1591     case POINTER_TYPE:     return pointer_type_class;
1592     case REFERENCE_TYPE:   return reference_type_class;
1593     case OFFSET_TYPE:      return offset_type_class;
1594     case REAL_TYPE:        return real_type_class;
1595     case COMPLEX_TYPE:     return complex_type_class;
1596     case FUNCTION_TYPE:    return function_type_class;
1597     case METHOD_TYPE:      return method_type_class;
1598     case RECORD_TYPE:      return record_type_class;
1599     case UNION_TYPE:
1600     case QUAL_UNION_TYPE:  return union_type_class;
1601     case ARRAY_TYPE:       return (TYPE_STRING_FLAG (type)
1602                                    ? string_type_class : array_type_class);
1603     case LANG_TYPE:        return lang_type_class;
1604     default:               return no_type_class;
1605     }
1606 }
1607
1608 /* Expand a call to __builtin_classify_type with arguments found in
1609    ARGLIST.  */
1610
1611 static rtx
1612 expand_builtin_classify_type (tree arglist)
1613 {
1614   if (arglist != 0)
1615     return GEN_INT (type_to_class (TREE_TYPE (TREE_VALUE (arglist))));
1616   return GEN_INT (no_type_class);
1617 }
1618
1619 /* This helper macro, meant to be used in mathfn_built_in below,
1620    determines which among a set of three builtin math functions is
1621    appropriate for a given type mode.  The `F' and `L' cases are
1622    automatically generated from the `double' case.  */
1623 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1624   case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1625   fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1626   fcodel = BUILT_IN_MATHFN##L ; break;
1627
1628 /* Return mathematic function equivalent to FN but operating directly
1629    on TYPE, if available.  If we can't do the conversion, return zero.  */
1630 tree
1631 mathfn_built_in (tree type, enum built_in_function fn)
1632 {
1633   enum built_in_function fcode, fcodef, fcodel;
1634
1635   switch (fn)
1636     {
1637       CASE_MATHFN (BUILT_IN_ACOS)
1638       CASE_MATHFN (BUILT_IN_ACOSH)
1639       CASE_MATHFN (BUILT_IN_ASIN)
1640       CASE_MATHFN (BUILT_IN_ASINH)
1641       CASE_MATHFN (BUILT_IN_ATAN)
1642       CASE_MATHFN (BUILT_IN_ATAN2)
1643       CASE_MATHFN (BUILT_IN_ATANH)
1644       CASE_MATHFN (BUILT_IN_CBRT)
1645       CASE_MATHFN (BUILT_IN_CEIL)
1646       CASE_MATHFN (BUILT_IN_COPYSIGN)
1647       CASE_MATHFN (BUILT_IN_COS)
1648       CASE_MATHFN (BUILT_IN_COSH)
1649       CASE_MATHFN (BUILT_IN_DREM)
1650       CASE_MATHFN (BUILT_IN_ERF)
1651       CASE_MATHFN (BUILT_IN_ERFC)
1652       CASE_MATHFN (BUILT_IN_EXP)
1653       CASE_MATHFN (BUILT_IN_EXP10)
1654       CASE_MATHFN (BUILT_IN_EXP2)
1655       CASE_MATHFN (BUILT_IN_EXPM1)
1656       CASE_MATHFN (BUILT_IN_FABS)
1657       CASE_MATHFN (BUILT_IN_FDIM)
1658       CASE_MATHFN (BUILT_IN_FLOOR)
1659       CASE_MATHFN (BUILT_IN_FMA)
1660       CASE_MATHFN (BUILT_IN_FMAX)
1661       CASE_MATHFN (BUILT_IN_FMIN)
1662       CASE_MATHFN (BUILT_IN_FMOD)
1663       CASE_MATHFN (BUILT_IN_FREXP)
1664       CASE_MATHFN (BUILT_IN_GAMMA)
1665       CASE_MATHFN (BUILT_IN_HUGE_VAL)
1666       CASE_MATHFN (BUILT_IN_HYPOT)
1667       CASE_MATHFN (BUILT_IN_ILOGB)
1668       CASE_MATHFN (BUILT_IN_INF)
1669       CASE_MATHFN (BUILT_IN_J0)
1670       CASE_MATHFN (BUILT_IN_J1)
1671       CASE_MATHFN (BUILT_IN_JN)
1672       CASE_MATHFN (BUILT_IN_LCEIL)
1673       CASE_MATHFN (BUILT_IN_LDEXP)
1674       CASE_MATHFN (BUILT_IN_LFLOOR)
1675       CASE_MATHFN (BUILT_IN_LGAMMA)
1676       CASE_MATHFN (BUILT_IN_LLCEIL)
1677       CASE_MATHFN (BUILT_IN_LLFLOOR)
1678       CASE_MATHFN (BUILT_IN_LLRINT)
1679       CASE_MATHFN (BUILT_IN_LLROUND)
1680       CASE_MATHFN (BUILT_IN_LOG)
1681       CASE_MATHFN (BUILT_IN_LOG10)
1682       CASE_MATHFN (BUILT_IN_LOG1P)
1683       CASE_MATHFN (BUILT_IN_LOG2)
1684       CASE_MATHFN (BUILT_IN_LOGB)
1685       CASE_MATHFN (BUILT_IN_LRINT)
1686       CASE_MATHFN (BUILT_IN_LROUND)
1687       CASE_MATHFN (BUILT_IN_MODF)
1688       CASE_MATHFN (BUILT_IN_NAN)
1689       CASE_MATHFN (BUILT_IN_NANS)
1690       CASE_MATHFN (BUILT_IN_NEARBYINT)
1691       CASE_MATHFN (BUILT_IN_NEXTAFTER)
1692       CASE_MATHFN (BUILT_IN_NEXTTOWARD)
1693       CASE_MATHFN (BUILT_IN_POW)
1694       CASE_MATHFN (BUILT_IN_POWI)
1695       CASE_MATHFN (BUILT_IN_POW10)
1696       CASE_MATHFN (BUILT_IN_REMAINDER)
1697       CASE_MATHFN (BUILT_IN_REMQUO)
1698       CASE_MATHFN (BUILT_IN_RINT)
1699       CASE_MATHFN (BUILT_IN_ROUND)
1700       CASE_MATHFN (BUILT_IN_SCALB)
1701       CASE_MATHFN (BUILT_IN_SCALBLN)
1702       CASE_MATHFN (BUILT_IN_SCALBN)
1703       CASE_MATHFN (BUILT_IN_SIGNIFICAND)
1704       CASE_MATHFN (BUILT_IN_SIN)
1705       CASE_MATHFN (BUILT_IN_SINCOS)
1706       CASE_MATHFN (BUILT_IN_SINH)
1707       CASE_MATHFN (BUILT_IN_SQRT)
1708       CASE_MATHFN (BUILT_IN_TAN)
1709       CASE_MATHFN (BUILT_IN_TANH)
1710       CASE_MATHFN (BUILT_IN_TGAMMA)
1711       CASE_MATHFN (BUILT_IN_TRUNC)
1712       CASE_MATHFN (BUILT_IN_Y0)
1713       CASE_MATHFN (BUILT_IN_Y1)
1714       CASE_MATHFN (BUILT_IN_YN)
1715
1716       default:
1717         return 0;
1718       }
1719
1720   if (TYPE_MAIN_VARIANT (type) == double_type_node)
1721     return implicit_built_in_decls[fcode];
1722   else if (TYPE_MAIN_VARIANT (type) == float_type_node)
1723     return implicit_built_in_decls[fcodef];
1724   else if (TYPE_MAIN_VARIANT (type) == long_double_type_node)
1725     return implicit_built_in_decls[fcodel];
1726   else
1727     return 0;
1728 }
1729
1730 /* If errno must be maintained, expand the RTL to check if the result,
1731    TARGET, of a built-in function call, EXP, is NaN, and if so set
1732    errno to EDOM.  */
1733
1734 static void
1735 expand_errno_check (tree exp, rtx target)
1736 {
1737   rtx lab = gen_label_rtx ();
1738
1739   /* Test the result; if it is NaN, set errno=EDOM because
1740      the argument was not in the domain.  */
1741   emit_cmp_and_jump_insns (target, target, EQ, 0, GET_MODE (target),
1742                            0, lab);
1743
1744 #ifdef TARGET_EDOM
1745   /* If this built-in doesn't throw an exception, set errno directly.  */
1746   if (TREE_NOTHROW (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
1747     {
1748 #ifdef GEN_ERRNO_RTX
1749       rtx errno_rtx = GEN_ERRNO_RTX;
1750 #else
1751       rtx errno_rtx
1752           = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1753 #endif
1754       emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1755       emit_label (lab);
1756       return;
1757     }
1758 #endif
1759
1760   /* We can't set errno=EDOM directly; let the library call do it.
1761      Pop the arguments right away in case the call gets deleted.  */
1762   NO_DEFER_POP;
1763   expand_call (exp, target, 0);
1764   OK_DEFER_POP;
1765   emit_label (lab);
1766 }
1767
1768
1769 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1770    Return 0 if a normal call should be emitted rather than expanding the
1771    function in-line.  EXP is the expression that is a call to the builtin
1772    function; if convenient, the result should be placed in TARGET.
1773    SUBTARGET may be used as the target for computing one of EXP's operands.  */
1774
1775 static rtx
1776 expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
1777 {
1778   optab builtin_optab;
1779   rtx op0, insns, before_call;
1780   tree fndecl = get_callee_fndecl (exp);
1781   tree arglist = TREE_OPERAND (exp, 1);
1782   enum machine_mode mode;
1783   bool errno_set = false;
1784   tree arg, narg;
1785
1786   if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
1787     return 0;
1788
1789   arg = TREE_VALUE (arglist);
1790
1791   switch (DECL_FUNCTION_CODE (fndecl))
1792     {
1793     CASE_FLT_FN (BUILT_IN_SQRT):
1794       errno_set = ! tree_expr_nonnegative_p (arg);
1795       builtin_optab = sqrt_optab;
1796       break;
1797     CASE_FLT_FN (BUILT_IN_EXP):
1798       errno_set = true; builtin_optab = exp_optab; break;
1799     CASE_FLT_FN (BUILT_IN_EXP10):
1800     CASE_FLT_FN (BUILT_IN_POW10):
1801       errno_set = true; builtin_optab = exp10_optab; break;
1802     CASE_FLT_FN (BUILT_IN_EXP2):
1803       errno_set = true; builtin_optab = exp2_optab; break;
1804     CASE_FLT_FN (BUILT_IN_EXPM1):
1805       errno_set = true; builtin_optab = expm1_optab; break;
1806     CASE_FLT_FN (BUILT_IN_LOGB):
1807       errno_set = true; builtin_optab = logb_optab; break;
1808     CASE_FLT_FN (BUILT_IN_ILOGB):
1809       errno_set = true; builtin_optab = ilogb_optab; break;
1810     CASE_FLT_FN (BUILT_IN_LOG):
1811       errno_set = true; builtin_optab = log_optab; break;
1812     CASE_FLT_FN (BUILT_IN_LOG10):
1813       errno_set = true; builtin_optab = log10_optab; break;
1814     CASE_FLT_FN (BUILT_IN_LOG2):
1815       errno_set = true; builtin_optab = log2_optab; break;
1816     CASE_FLT_FN (BUILT_IN_LOG1P):
1817       errno_set = true; builtin_optab = log1p_optab; break;
1818     CASE_FLT_FN (BUILT_IN_ASIN):
1819       builtin_optab = asin_optab; break;
1820     CASE_FLT_FN (BUILT_IN_ACOS):
1821       builtin_optab = acos_optab; break;
1822     CASE_FLT_FN (BUILT_IN_TAN):
1823       builtin_optab = tan_optab; break;
1824     CASE_FLT_FN (BUILT_IN_ATAN):
1825       builtin_optab = atan_optab; break;
1826     CASE_FLT_FN (BUILT_IN_FLOOR):
1827       builtin_optab = floor_optab; break;
1828     CASE_FLT_FN (BUILT_IN_CEIL):
1829       builtin_optab = ceil_optab; break;
1830     CASE_FLT_FN (BUILT_IN_TRUNC):
1831       builtin_optab = btrunc_optab; break;
1832     CASE_FLT_FN (BUILT_IN_ROUND):
1833       builtin_optab = round_optab; break;
1834     CASE_FLT_FN (BUILT_IN_NEARBYINT):
1835       builtin_optab = nearbyint_optab; break;
1836     CASE_FLT_FN (BUILT_IN_RINT):
1837       builtin_optab = rint_optab; break;
1838     CASE_FLT_FN (BUILT_IN_LRINT):
1839     CASE_FLT_FN (BUILT_IN_LLRINT):
1840       builtin_optab = lrint_optab; break;
1841     default:
1842       gcc_unreachable ();
1843     }
1844
1845   /* Make a suitable register to place result in.  */
1846   mode = TYPE_MODE (TREE_TYPE (exp));
1847
1848   if (! flag_errno_math || ! HONOR_NANS (mode))
1849     errno_set = false;
1850
1851   /* Before working hard, check whether the instruction is available.  */
1852   if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
1853     {
1854       target = gen_reg_rtx (mode);
1855
1856       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
1857          need to expand the argument again.  This way, we will not perform
1858          side-effects more the once.  */
1859       narg = builtin_save_expr (arg);
1860       if (narg != arg)
1861         {
1862           arg = narg;
1863           arglist = build_tree_list (NULL_TREE, arg);
1864           exp = build_function_call_expr (fndecl, arglist);
1865         }
1866
1867       op0 = expand_expr (arg, subtarget, VOIDmode, 0);
1868
1869       start_sequence ();
1870
1871       /* Compute into TARGET.
1872          Set TARGET to wherever the result comes back.  */
1873       target = expand_unop (mode, builtin_optab, op0, target, 0);
1874
1875       if (target != 0)
1876         {
1877           if (errno_set)
1878             expand_errno_check (exp, target);
1879
1880           /* Output the entire sequence.  */
1881           insns = get_insns ();
1882           end_sequence ();
1883           emit_insn (insns);
1884           return target;
1885         }
1886
1887       /* If we were unable to expand via the builtin, stop the sequence
1888          (without outputting the insns) and call to the library function
1889          with the stabilized argument list.  */
1890       end_sequence ();
1891     }
1892
1893   before_call = get_last_insn ();
1894
1895   target = expand_call (exp, target, target == const0_rtx);
1896
1897   /* If this is a sqrt operation and we don't care about errno, try to
1898      attach a REG_EQUAL note with a SQRT rtx to the emitted libcall.
1899      This allows the semantics of the libcall to be visible to the RTL
1900      optimizers.  */
1901   if (builtin_optab == sqrt_optab && !errno_set)
1902     {
1903       /* Search backwards through the insns emitted by expand_call looking
1904          for the instruction with the REG_RETVAL note.  */
1905       rtx last = get_last_insn ();
1906       while (last != before_call)
1907         {
1908           if (find_reg_note (last, REG_RETVAL, NULL))
1909             {
1910               rtx note = find_reg_note (last, REG_EQUAL, NULL);
1911               /* Check that the REQ_EQUAL note is an EXPR_LIST with
1912                  two elements, i.e. symbol_ref(sqrt) and the operand.  */
1913               if (note
1914                   && GET_CODE (note) == EXPR_LIST
1915                   && GET_CODE (XEXP (note, 0)) == EXPR_LIST
1916                   && XEXP (XEXP (note, 0), 1) != NULL_RTX
1917                   && XEXP (XEXP (XEXP (note, 0), 1), 1) == NULL_RTX)
1918                 {
1919                   rtx operand = XEXP (XEXP (XEXP (note, 0), 1), 0);
1920                   /* Check operand is a register with expected mode.  */
1921                   if (operand
1922                       && REG_P (operand)
1923                       && GET_MODE (operand) == mode)
1924                     {
1925                       /* Replace the REG_EQUAL note with a SQRT rtx.  */
1926                       rtx equiv = gen_rtx_SQRT (mode, operand);
1927                       set_unique_reg_note (last, REG_EQUAL, equiv);
1928                     }
1929                 }
1930               break;
1931             }
1932           last = PREV_INSN (last);
1933         }
1934     }
1935
1936   return target;
1937 }
1938
1939 /* Expand a call to the builtin binary math functions (pow and atan2).
1940    Return 0 if a normal call should be emitted rather than expanding the
1941    function in-line.  EXP is the expression that is a call to the builtin
1942    function; if convenient, the result should be placed in TARGET.
1943    SUBTARGET may be used as the target for computing one of EXP's
1944    operands.  */
1945
1946 static rtx
1947 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
1948 {
1949   optab builtin_optab;
1950   rtx op0, op1, insns;
1951   int op1_type = REAL_TYPE;
1952   tree fndecl = get_callee_fndecl (exp);
1953   tree arglist = TREE_OPERAND (exp, 1);
1954   tree arg0, arg1, temp, narg;
1955   enum machine_mode mode;
1956   bool errno_set = true;
1957   bool stable = true;
1958
1959   if ((DECL_FUNCTION_CODE (fndecl) == BUILT_IN_LDEXP)
1960       || (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_LDEXPF)
1961       || (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_LDEXPL))
1962     op1_type = INTEGER_TYPE;
1963
1964   if (!validate_arglist (arglist, REAL_TYPE, op1_type, VOID_TYPE))
1965     return 0;
1966
1967   arg0 = TREE_VALUE (arglist);
1968   arg1 = TREE_VALUE (TREE_CHAIN (arglist));
1969
1970   switch (DECL_FUNCTION_CODE (fndecl))
1971     {
1972     CASE_FLT_FN (BUILT_IN_POW):
1973       builtin_optab = pow_optab; break;
1974     CASE_FLT_FN (BUILT_IN_ATAN2):
1975       builtin_optab = atan2_optab; break;
1976     CASE_FLT_FN (BUILT_IN_LDEXP):
1977       builtin_optab = ldexp_optab; break;
1978     CASE_FLT_FN (BUILT_IN_FMOD):
1979       builtin_optab = fmod_optab; break;
1980     CASE_FLT_FN (BUILT_IN_DREM):
1981       builtin_optab = drem_optab; break;
1982     default:
1983       gcc_unreachable ();
1984     }
1985
1986   /* Make a suitable register to place result in.  */
1987   mode = TYPE_MODE (TREE_TYPE (exp));
1988
1989   /* Before working hard, check whether the instruction is available.  */
1990   if (builtin_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing)
1991     return 0;
1992
1993   target = gen_reg_rtx (mode);
1994
1995   if (! flag_errno_math || ! HONOR_NANS (mode))
1996     errno_set = false;
1997
1998   /* Always stabilize the argument list.  */
1999   narg = builtin_save_expr (arg1);
2000   if (narg != arg1)
2001     {
2002       arg1 = narg;
2003       temp = build_tree_list (NULL_TREE, narg);
2004       stable = false;
2005     }
2006   else
2007     temp = TREE_CHAIN (arglist);
2008
2009   narg = builtin_save_expr (arg0);
2010   if (narg != arg0)
2011     {
2012       arg0 = narg;
2013       arglist = tree_cons (NULL_TREE, narg, temp);
2014       stable = false;
2015     }
2016   else if (! stable)
2017     arglist = tree_cons (NULL_TREE, arg0, temp);
2018
2019   if (! stable)
2020     exp = build_function_call_expr (fndecl, arglist);
2021
2022   op0 = expand_expr (arg0, subtarget, VOIDmode, 0);
2023   op1 = expand_expr (arg1, 0, VOIDmode, 0);
2024
2025   start_sequence ();
2026
2027   /* Compute into TARGET.
2028      Set TARGET to wherever the result comes back.  */
2029   target = expand_binop (mode, builtin_optab, op0, op1,
2030                          target, 0, OPTAB_DIRECT);
2031
2032   /* If we were unable to expand via the builtin, stop the sequence
2033      (without outputting the insns) and call to the library function
2034      with the stabilized argument list.  */
2035   if (target == 0)
2036     {
2037       end_sequence ();
2038       return expand_call (exp, target, target == const0_rtx);
2039     }
2040
2041   if (errno_set)
2042     expand_errno_check (exp, target);
2043
2044   /* Output the entire sequence.  */
2045   insns = get_insns ();
2046   end_sequence ();
2047   emit_insn (insns);
2048
2049   return target;
2050 }
2051
2052 /* Expand a call to the builtin sin and cos math functions.
2053    Return 0 if a normal call should be emitted rather than expanding the
2054    function in-line.  EXP is the expression that is a call to the builtin
2055    function; if convenient, the result should be placed in TARGET.
2056    SUBTARGET may be used as the target for computing one of EXP's
2057    operands.  */
2058
2059 static rtx
2060 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2061 {
2062   optab builtin_optab;
2063   rtx op0, insns;
2064   tree fndecl = get_callee_fndecl (exp);
2065   tree arglist = TREE_OPERAND (exp, 1);
2066   enum machine_mode mode;
2067   tree arg, narg;
2068
2069   if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
2070     return 0;
2071
2072   arg = TREE_VALUE (arglist);
2073
2074   switch (DECL_FUNCTION_CODE (fndecl))
2075     {
2076     CASE_FLT_FN (BUILT_IN_SIN):
2077     CASE_FLT_FN (BUILT_IN_COS):
2078       builtin_optab = sincos_optab; break;
2079     default:
2080       gcc_unreachable ();
2081     }
2082
2083   /* Make a suitable register to place result in.  */
2084   mode = TYPE_MODE (TREE_TYPE (exp));
2085
2086   /* Check if sincos insn is available, otherwise fallback
2087      to sin or cos insn.  */
2088   if (builtin_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing) {
2089     switch (DECL_FUNCTION_CODE (fndecl))
2090       {
2091       CASE_FLT_FN (BUILT_IN_SIN):
2092         builtin_optab = sin_optab; break;
2093       CASE_FLT_FN (BUILT_IN_COS):
2094         builtin_optab = cos_optab; break;
2095       default:
2096         gcc_unreachable ();
2097       }
2098   }
2099
2100   /* Before working hard, check whether the instruction is available.  */
2101   if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
2102     {
2103       target = gen_reg_rtx (mode);
2104
2105       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2106          need to expand the argument again.  This way, we will not perform
2107          side-effects more the once.  */
2108       narg = save_expr (arg);
2109       if (narg != arg)
2110         {
2111           arg = narg;
2112           arglist = build_tree_list (NULL_TREE, arg);
2113           exp = build_function_call_expr (fndecl, arglist);
2114         }
2115
2116       op0 = expand_expr (arg, subtarget, VOIDmode, 0);
2117
2118       start_sequence ();
2119
2120       /* Compute into TARGET.
2121          Set TARGET to wherever the result comes back.  */
2122       if (builtin_optab == sincos_optab)
2123         {
2124           int result;
2125
2126           switch (DECL_FUNCTION_CODE (fndecl))
2127             {
2128             CASE_FLT_FN (BUILT_IN_SIN):
2129               result = expand_twoval_unop (builtin_optab, op0, 0, target, 0);
2130               break;
2131             CASE_FLT_FN (BUILT_IN_COS):
2132               result = expand_twoval_unop (builtin_optab, op0, target, 0, 0);
2133               break;
2134             default:
2135               gcc_unreachable ();
2136             }
2137           gcc_assert (result);
2138         }
2139       else
2140         {
2141           target = expand_unop (mode, builtin_optab, op0, target, 0);
2142         }
2143
2144       if (target != 0)
2145         {
2146           /* Output the entire sequence.  */
2147           insns = get_insns ();
2148           end_sequence ();
2149           emit_insn (insns);
2150           return target;
2151         }
2152
2153       /* If we were unable to expand via the builtin, stop the sequence
2154          (without outputting the insns) and call to the library function
2155          with the stabilized argument list.  */
2156       end_sequence ();
2157     }
2158
2159   target = expand_call (exp, target, target == const0_rtx);
2160
2161   return target;
2162 }
2163
2164 /* Expand a call to the builtin sincos math function.
2165    Return 0 if a normal call should be emitted rather than expanding the
2166    function in-line.  EXP is the expression that is a call to the builtin
2167    function.  */
2168
2169 static rtx
2170 expand_builtin_sincos (tree exp)
2171 {
2172   rtx op0, op1, op2, target1, target2;
2173   tree arglist = TREE_OPERAND (exp, 1);
2174   enum machine_mode mode;
2175   tree arg, sinp, cosp;
2176   int result;
2177
2178   if (!validate_arglist (arglist, REAL_TYPE,
2179                          POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2180     return 0;
2181
2182   arg = TREE_VALUE (arglist);
2183   sinp = TREE_VALUE (TREE_CHAIN (arglist));
2184   cosp = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2185
2186   /* Make a suitable register to place result in.  */
2187   mode = TYPE_MODE (TREE_TYPE (arg));
2188
2189   /* Check if sincos insn is available, otherwise emit the call.  */
2190   if (sincos_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing)
2191     return NULL_RTX;
2192
2193   target1 = gen_reg_rtx (mode);
2194   target2 = gen_reg_rtx (mode);
2195
2196   op0 = expand_expr (arg, NULL_RTX, VOIDmode, 0);
2197   op1 = expand_expr (build_fold_indirect_ref (sinp), NULL_RTX, VOIDmode, 0);
2198   op2 = expand_expr (build_fold_indirect_ref (cosp), NULL_RTX, VOIDmode, 0);
2199
2200   /* Compute into target1 and target2.
2201      Set TARGET to wherever the result comes back.  */
2202   result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2203   gcc_assert (result);
2204
2205   /* Move target1 and target2 to the memory locations indicated
2206      by op1 and op2.  */
2207   emit_move_insn (op1, target1);
2208   emit_move_insn (op2, target2);
2209
2210   return const0_rtx;
2211 }
2212
2213 /* Expand a call to one of the builtin rounding functions (lfloor).
2214    If expanding via optab fails, lower expression to (int)(floor(x)).
2215    EXP is the expression that is a call to the builtin function;
2216    if convenient, the result should be placed in TARGET.  SUBTARGET may
2217    be used as the target for computing one of EXP's operands.  */
2218
2219 static rtx
2220 expand_builtin_int_roundingfn (tree exp, rtx target, rtx subtarget)
2221 {
2222   optab builtin_optab;
2223   rtx op0, insns, tmp;
2224   tree fndecl = get_callee_fndecl (exp);
2225   tree arglist = TREE_OPERAND (exp, 1);
2226   enum built_in_function fallback_fn;
2227   tree fallback_fndecl;
2228   enum machine_mode mode;
2229   tree arg, narg;
2230
2231   if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
2232     gcc_unreachable ();
2233
2234   arg = TREE_VALUE (arglist);
2235
2236   switch (DECL_FUNCTION_CODE (fndecl))
2237     {
2238     CASE_FLT_FN (BUILT_IN_LCEIL):
2239     CASE_FLT_FN (BUILT_IN_LLCEIL):
2240       builtin_optab = lceil_optab;
2241       fallback_fn = BUILT_IN_CEIL;
2242       break;
2243
2244     CASE_FLT_FN (BUILT_IN_LFLOOR):
2245     CASE_FLT_FN (BUILT_IN_LLFLOOR):
2246       builtin_optab = lfloor_optab;
2247       fallback_fn = BUILT_IN_FLOOR;
2248       break;
2249
2250     default:
2251       gcc_unreachable ();
2252     }
2253
2254   /* Make a suitable register to place result in.  */
2255   mode = TYPE_MODE (TREE_TYPE (exp));
2256
2257   /* Before working hard, check whether the instruction is available.  */
2258   if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
2259     {
2260       target = gen_reg_rtx (mode);
2261
2262       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2263          need to expand the argument again.  This way, we will not perform
2264          side-effects more the once.  */
2265       narg = builtin_save_expr (arg);
2266       if (narg != arg)
2267         {
2268           arg = narg;
2269           arglist = build_tree_list (NULL_TREE, arg);
2270           exp = build_function_call_expr (fndecl, arglist);
2271         }
2272
2273       op0 = expand_expr (arg, subtarget, VOIDmode, 0);
2274
2275       start_sequence ();
2276
2277       /* Compute into TARGET.
2278          Set TARGET to wherever the result comes back.  */
2279       target = expand_unop (mode, builtin_optab, op0, target, 0);
2280
2281       if (target != 0)
2282         {
2283           /* Output the entire sequence.  */
2284           insns = get_insns ();
2285           end_sequence ();
2286           emit_insn (insns);
2287           return target;
2288         }
2289
2290       /* If we were unable to expand via the builtin, stop the sequence
2291          (without outputting the insns).  */
2292       end_sequence ();
2293     }
2294
2295   /* Fall back to floating point rounding optab.  */
2296   fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2297   /* We shouldn't get here on targets without TARGET_C99_FUNCTIONS.
2298      ??? Perhaps convert (int)floorf(x) into (int)floor((double)x).  */
2299   gcc_assert (fallback_fndecl != NULL_TREE);
2300   exp = build_function_call_expr (fallback_fndecl, arglist);
2301
2302   tmp = expand_builtin_mathfn (exp, NULL_RTX, NULL_RTX);
2303
2304   /* Truncate the result of floating point optab to integer
2305      via expand_fix ().  */
2306   target = gen_reg_rtx (mode);
2307   expand_fix (target, tmp, 0);
2308
2309   return target;
2310 }
2311
2312 /* To evaluate powi(x,n), the floating point value x raised to the
2313    constant integer exponent n, we use a hybrid algorithm that
2314    combines the "window method" with look-up tables.  For an
2315    introduction to exponentiation algorithms and "addition chains",
2316    see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2317    "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2318    3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2319    Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998.  */
2320
2321 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2322    multiplications to inline before calling the system library's pow
2323    function.  powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2324    so this default never requires calling pow, powf or powl.  */
2325
2326 #ifndef POWI_MAX_MULTS
2327 #define POWI_MAX_MULTS  (2*HOST_BITS_PER_WIDE_INT-2)
2328 #endif
2329
2330 /* The size of the "optimal power tree" lookup table.  All
2331    exponents less than this value are simply looked up in the
2332    powi_table below.  This threshold is also used to size the
2333    cache of pseudo registers that hold intermediate results.  */
2334 #define POWI_TABLE_SIZE 256
2335
2336 /* The size, in bits of the window, used in the "window method"
2337    exponentiation algorithm.  This is equivalent to a radix of
2338    (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method".  */
2339 #define POWI_WINDOW_SIZE 3
2340
2341 /* The following table is an efficient representation of an
2342    "optimal power tree".  For each value, i, the corresponding
2343    value, j, in the table states than an optimal evaluation
2344    sequence for calculating pow(x,i) can be found by evaluating
2345    pow(x,j)*pow(x,i-j).  An optimal power tree for the first
2346    100 integers is given in Knuth's "Seminumerical algorithms".  */
2347
2348 static const unsigned char powi_table[POWI_TABLE_SIZE] =
2349   {
2350       0,   1,   1,   2,   2,   3,   3,   4,  /*   0 -   7 */
2351       4,   6,   5,   6,   6,  10,   7,   9,  /*   8 -  15 */
2352       8,  16,   9,  16,  10,  12,  11,  13,  /*  16 -  23 */
2353      12,  17,  13,  18,  14,  24,  15,  26,  /*  24 -  31 */
2354      16,  17,  17,  19,  18,  33,  19,  26,  /*  32 -  39 */
2355      20,  25,  21,  40,  22,  27,  23,  44,  /*  40 -  47 */
2356      24,  32,  25,  34,  26,  29,  27,  44,  /*  48 -  55 */
2357      28,  31,  29,  34,  30,  60,  31,  36,  /*  56 -  63 */
2358      32,  64,  33,  34,  34,  46,  35,  37,  /*  64 -  71 */
2359      36,  65,  37,  50,  38,  48,  39,  69,  /*  72 -  79 */
2360      40,  49,  41,  43,  42,  51,  43,  58,  /*  80 -  87 */
2361      44,  64,  45,  47,  46,  59,  47,  76,  /*  88 -  95 */
2362      48,  65,  49,  66,  50,  67,  51,  66,  /*  96 - 103 */
2363      52,  70,  53,  74,  54, 104,  55,  74,  /* 104 - 111 */
2364      56,  64,  57,  69,  58,  78,  59,  68,  /* 112 - 119 */
2365      60,  61,  61,  80,  62,  75,  63,  68,  /* 120 - 127 */
2366      64,  65,  65, 128,  66, 129,  67,  90,  /* 128 - 135 */
2367      68,  73,  69, 131,  70,  94,  71,  88,  /* 136 - 143 */
2368      72, 128,  73,  98,  74, 132,  75, 121,  /* 144 - 151 */
2369      76, 102,  77, 124,  78, 132,  79, 106,  /* 152 - 159 */
2370      80,  97,  81, 160,  82,  99,  83, 134,  /* 160 - 167 */
2371      84,  86,  85,  95,  86, 160,  87, 100,  /* 168 - 175 */
2372      88, 113,  89,  98,  90, 107,  91, 122,  /* 176 - 183 */
2373      92, 111,  93, 102,  94, 126,  95, 150,  /* 184 - 191 */
2374      96, 128,  97, 130,  98, 133,  99, 195,  /* 192 - 199 */
2375     100, 128, 101, 123, 102, 164, 103, 138,  /* 200 - 207 */
2376     104, 145, 105, 146, 106, 109, 107, 149,  /* 208 - 215 */
2377     108, 200, 109, 146, 110, 170, 111, 157,  /* 216 - 223 */
2378     112, 128, 113, 130, 114, 182, 115, 132,  /* 224 - 231 */
2379     116, 200, 117, 132, 118, 158, 119, 206,  /* 232 - 239 */
2380     120, 240, 121, 162, 122, 147, 123, 152,  /* 240 - 247 */
2381     124, 166, 125, 214, 126, 138, 127, 153,  /* 248 - 255 */
2382   };
2383
2384
2385 /* Return the number of multiplications required to calculate
2386    powi(x,n) where n is less than POWI_TABLE_SIZE.  This is a
2387    subroutine of powi_cost.  CACHE is an array indicating
2388    which exponents have already been calculated.  */
2389
2390 static int
2391 powi_lookup_cost (unsigned HOST_WIDE_INT n, bool *cache)
2392 {
2393   /* If we've already calculated this exponent, then this evaluation
2394      doesn't require any additional multiplications.  */
2395   if (cache[n])
2396     return 0;
2397
2398   cache[n] = true;
2399   return powi_lookup_cost (n - powi_table[n], cache)
2400          + powi_lookup_cost (powi_table[n], cache) + 1;
2401 }
2402
2403 /* Return the number of multiplications required to calculate
2404    powi(x,n) for an arbitrary x, given the exponent N.  This
2405    function needs to be kept in sync with expand_powi below.  */
2406
2407 static int
2408 powi_cost (HOST_WIDE_INT n)
2409 {
2410   bool cache[POWI_TABLE_SIZE];
2411   unsigned HOST_WIDE_INT digit;
2412   unsigned HOST_WIDE_INT val;
2413   int result;
2414
2415   if (n == 0)
2416     return 0;
2417
2418   /* Ignore the reciprocal when calculating the cost.  */
2419   val = (n < 0) ? -n : n;
2420
2421   /* Initialize the exponent cache.  */
2422   memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool));
2423   cache[1] = true;
2424
2425   result = 0;
2426
2427   while (val >= POWI_TABLE_SIZE)
2428     {
2429       if (val & 1)
2430         {
2431           digit = val & ((1 << POWI_WINDOW_SIZE) - 1);
2432           result += powi_lookup_cost (digit, cache)
2433                     + POWI_WINDOW_SIZE + 1;
2434           val >>= POWI_WINDOW_SIZE;
2435         }
2436       else
2437         {
2438           val >>= 1;
2439           result++;
2440         }
2441     }
2442
2443   return result + powi_lookup_cost (val, cache);
2444 }
2445
2446 /* Recursive subroutine of expand_powi.  This function takes the array,
2447    CACHE, of already calculated exponents and an exponent N and returns
2448    an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE.  */
2449
2450 static rtx
2451 expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
2452 {
2453   unsigned HOST_WIDE_INT digit;
2454   rtx target, result;
2455   rtx op0, op1;
2456
2457   if (n < POWI_TABLE_SIZE)
2458     {
2459       if (cache[n])
2460         return cache[n];
2461
2462       target = gen_reg_rtx (mode);
2463       cache[n] = target;
2464
2465       op0 = expand_powi_1 (mode, n - powi_table[n], cache);
2466       op1 = expand_powi_1 (mode, powi_table[n], cache);
2467     }
2468   else if (n & 1)
2469     {
2470       target = gen_reg_rtx (mode);
2471       digit = n & ((1 << POWI_WINDOW_SIZE) - 1);
2472       op0 = expand_powi_1 (mode, n - digit, cache);
2473       op1 = expand_powi_1 (mode, digit, cache);
2474     }
2475   else
2476     {
2477       target = gen_reg_rtx (mode);
2478       op0 = expand_powi_1 (mode, n >> 1, cache);
2479       op1 = op0;
2480     }
2481
2482   result = expand_mult (mode, op0, op1, target, 0);
2483   if (result != target)
2484     emit_move_insn (target, result);
2485   return target;
2486 }
2487
2488 /* Expand the RTL to evaluate powi(x,n) in mode MODE.  X is the
2489    floating point operand in mode MODE, and N is the exponent.  This
2490    function needs to be kept in sync with powi_cost above.  */
2491
2492 static rtx
2493 expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
2494 {
2495   unsigned HOST_WIDE_INT val;
2496   rtx cache[POWI_TABLE_SIZE];
2497   rtx result;
2498
2499   if (n == 0)
2500     return CONST1_RTX (mode);
2501
2502   val = (n < 0) ? -n : n;
2503
2504   memset (cache, 0, sizeof (cache));
2505   cache[1] = x;
2506
2507   result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
2508
2509   /* If the original exponent was negative, reciprocate the result.  */
2510   if (n < 0)
2511     result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2512                            result, NULL_RTX, 0, OPTAB_LIB_WIDEN);
2513
2514   return result;
2515 }
2516
2517 /* Expand a call to the pow built-in mathematical function.  Return 0 if
2518    a normal call should be emitted rather than expanding the function
2519    in-line.  EXP is the expression that is a call to the builtin
2520    function; if convenient, the result should be placed in TARGET.  */
2521
2522 static rtx
2523 expand_builtin_pow (tree exp, rtx target, rtx subtarget)
2524 {
2525   tree arglist = TREE_OPERAND (exp, 1);
2526   tree arg0, arg1;
2527
2528   if (! validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
2529     return 0;
2530
2531   arg0 = TREE_VALUE (arglist);
2532   arg1 = TREE_VALUE (TREE_CHAIN (arglist));
2533
2534   if (TREE_CODE (arg1) == REAL_CST
2535       && ! TREE_CONSTANT_OVERFLOW (arg1))
2536     {
2537       REAL_VALUE_TYPE cint;
2538       REAL_VALUE_TYPE c;
2539       HOST_WIDE_INT n;
2540
2541       c = TREE_REAL_CST (arg1);
2542       n = real_to_integer (&c);
2543       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
2544       if (real_identical (&c, &cint))
2545         {
2546           /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
2547              Otherwise, check the number of multiplications required.
2548              Note that pow never sets errno for an integer exponent.  */
2549           if ((n >= -1 && n <= 2)
2550               || (flag_unsafe_math_optimizations
2551                   && ! optimize_size
2552                   && powi_cost (n) <= POWI_MAX_MULTS))
2553             {
2554               enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2555               rtx op = expand_expr (arg0, subtarget, VOIDmode, 0);
2556               op = force_reg (mode, op);
2557               return expand_powi (op, mode, n);
2558             }
2559         }
2560     }
2561
2562   if (! flag_unsafe_math_optimizations)
2563     return NULL_RTX;
2564   return expand_builtin_mathfn_2 (exp, target, subtarget);
2565 }
2566
2567 /* Expand a call to the powi built-in mathematical function.  Return 0 if
2568    a normal call should be emitted rather than expanding the function
2569    in-line.  EXP is the expression that is a call to the builtin
2570    function; if convenient, the result should be placed in TARGET.  */
2571
2572 static rtx
2573 expand_builtin_powi (tree exp, rtx target, rtx subtarget)
2574 {
2575   tree arglist = TREE_OPERAND (exp, 1);
2576   tree arg0, arg1;
2577   rtx op0, op1;
2578   enum machine_mode mode;
2579   enum machine_mode mode2;
2580
2581   if (! validate_arglist (arglist, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
2582     return 0;
2583
2584   arg0 = TREE_VALUE (arglist);
2585   arg1 = TREE_VALUE (TREE_CHAIN (arglist));
2586   mode = TYPE_MODE (TREE_TYPE (exp));
2587
2588   /* Handle constant power.  */
2589
2590   if (TREE_CODE (arg1) == INTEGER_CST
2591       && ! TREE_CONSTANT_OVERFLOW (arg1))
2592     {
2593       HOST_WIDE_INT n = TREE_INT_CST_LOW (arg1);
2594
2595       /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
2596          Otherwise, check the number of multiplications required.  */
2597       if ((TREE_INT_CST_HIGH (arg1) == 0
2598            || TREE_INT_CST_HIGH (arg1) == -1)
2599           && ((n >= -1 && n <= 2)
2600               || (! optimize_size
2601                   && powi_cost (n) <= POWI_MAX_MULTS)))
2602         {
2603           op0 = expand_expr (arg0, subtarget, VOIDmode, 0);
2604           op0 = force_reg (mode, op0);
2605           return expand_powi (op0, mode, n);
2606         }
2607     }
2608
2609   /* Emit a libcall to libgcc.  */
2610
2611   /* Mode of the 2nd argument must match that of an int. */
2612   mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
2613
2614   if (target == NULL_RTX)
2615     target = gen_reg_rtx (mode);
2616
2617   op0 = expand_expr (arg0, subtarget, mode, 0);
2618   if (GET_MODE (op0) != mode)
2619     op0 = convert_to_mode (mode, op0, 0);
2620   op1 = expand_expr (arg1, 0, mode2, 0);
2621   if (GET_MODE (op1) != mode2)
2622     op1 = convert_to_mode (mode2, op1, 0);
2623
2624   target = emit_library_call_value (powi_optab->handlers[(int) mode].libfunc,
2625                                     target, LCT_CONST_MAKE_BLOCK, mode, 2,
2626                                     op0, mode, op1, mode2);
2627
2628   return target;
2629 }
2630
2631 /* Expand expression EXP which is a call to the strlen builtin.  Return 0
2632    if we failed the caller should emit a normal call, otherwise
2633    try to get the result in TARGET, if convenient.  */
2634
2635 static rtx
2636 expand_builtin_strlen (tree arglist, rtx target,
2637                        enum machine_mode target_mode)
2638 {
2639   if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
2640     return 0;
2641   else
2642     {
2643       rtx pat;
2644       tree len, src = TREE_VALUE (arglist);
2645       rtx result, src_reg, char_rtx, before_strlen;
2646       enum machine_mode insn_mode = target_mode, char_mode;
2647       enum insn_code icode = CODE_FOR_nothing;
2648       int align;
2649
2650       /* If the length can be computed at compile-time, return it.  */
2651       len = c_strlen (src, 0);
2652       if (len)
2653         return expand_expr (len, target, target_mode, EXPAND_NORMAL);
2654
2655       /* If the length can be computed at compile-time and is constant
2656          integer, but there are side-effects in src, evaluate
2657          src for side-effects, then return len.
2658          E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
2659          can be optimized into: i++; x = 3;  */
2660       len = c_strlen (src, 1);
2661       if (len && TREE_CODE (len) == INTEGER_CST)
2662         {
2663           expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
2664           return expand_expr (len, target, target_mode, EXPAND_NORMAL);
2665         }
2666
2667       align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
2668
2669       /* If SRC is not a pointer type, don't do this operation inline.  */
2670       if (align == 0)
2671         return 0;
2672
2673       /* Bail out if we can't compute strlen in the right mode.  */
2674       while (insn_mode != VOIDmode)
2675         {
2676           icode = strlen_optab->handlers[(int) insn_mode].insn_code;
2677           if (icode != CODE_FOR_nothing)
2678             break;
2679
2680           insn_mode = GET_MODE_WIDER_MODE (insn_mode);
2681         }
2682       if (insn_mode == VOIDmode)
2683         return 0;
2684
2685       /* Make a place to write the result of the instruction.  */
2686       result = target;
2687       if (! (result != 0
2688              && REG_P (result)
2689              && GET_MODE (result) == insn_mode
2690              && REGNO (result) >= FIRST_PSEUDO_REGISTER))
2691         result = gen_reg_rtx (insn_mode);
2692
2693       /* Make a place to hold the source address.  We will not expand
2694          the actual source until we are sure that the expansion will
2695          not fail -- there are trees that cannot be expanded twice.  */
2696       src_reg = gen_reg_rtx (Pmode);
2697
2698       /* Mark the beginning of the strlen sequence so we can emit the
2699          source operand later.  */
2700       before_strlen = get_last_insn ();
2701
2702       char_rtx = const0_rtx;
2703       char_mode = insn_data[(int) icode].operand[2].mode;
2704       if (! (*insn_data[(int) icode].operand[2].predicate) (char_rtx,
2705                                                             char_mode))
2706         char_rtx = copy_to_mode_reg (char_mode, char_rtx);
2707
2708       pat = GEN_FCN (icode) (result, gen_rtx_MEM (BLKmode, src_reg),
2709                              char_rtx, GEN_INT (align));
2710       if (! pat)
2711         return 0;
2712       emit_insn (pat);
2713
2714       /* Now that we are assured of success, expand the source.  */
2715       start_sequence ();
2716       pat = expand_expr (src, src_reg, ptr_mode, EXPAND_NORMAL);
2717       if (pat != src_reg)
2718         emit_move_insn (src_reg, pat);
2719       pat = get_insns ();
2720       end_sequence ();
2721
2722       if (before_strlen)
2723         emit_insn_after (pat, before_strlen);
2724       else
2725         emit_insn_before (pat, get_insns ());
2726
2727       /* Return the value in the proper mode for this function.  */
2728       if (GET_MODE (result) == target_mode)
2729         target = result;
2730       else if (target != 0)
2731         convert_move (target, result, 0);
2732       else
2733         target = convert_to_mode (target_mode, result, 0);
2734
2735       return target;
2736     }
2737 }
2738
2739 /* Expand a call to the strstr builtin.  Return 0 if we failed the
2740    caller should emit a normal call, otherwise try to get the result
2741    in TARGET, if convenient (and in mode MODE if that's convenient).  */
2742
2743 static rtx
2744 expand_builtin_strstr (tree arglist, tree type, rtx target, enum machine_mode mode)
2745 {
2746   if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2747     {
2748       tree result = fold_builtin_strstr (arglist, type);
2749       if (result)
2750         return expand_expr (result, target, mode, EXPAND_NORMAL);
2751     }
2752   return 0;
2753 }
2754
2755 /* Expand a call to the strchr builtin.  Return 0 if we failed the
2756    caller should emit a normal call, otherwise try to get the result
2757    in TARGET, if convenient (and in mode MODE if that's convenient).  */
2758
2759 static rtx
2760 expand_builtin_strchr (tree arglist, tree type, rtx target, enum machine_mode mode)
2761 {
2762   if (validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2763     {
2764       tree result = fold_builtin_strchr (arglist, type);
2765       if (result)
2766         return expand_expr (result, target, mode, EXPAND_NORMAL);
2767
2768       /* FIXME: Should use strchrM optab so that ports can optimize this.  */
2769     }
2770   return 0;
2771 }
2772
2773 /* Expand a call to the strrchr builtin.  Return 0 if we failed the
2774    caller should emit a normal call, otherwise try to get the result
2775    in TARGET, if convenient (and in mode MODE if that's convenient).  */
2776
2777 static rtx
2778 expand_builtin_strrchr (tree arglist, tree type, rtx target, enum machine_mode mode)
2779 {
2780   if (validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2781     {
2782       tree result = fold_builtin_strrchr (arglist, type);
2783       if (result)
2784         return expand_expr (result, target, mode, EXPAND_NORMAL);
2785     }
2786   return 0;
2787 }
2788
2789 /* Expand a call to the strpbrk builtin.  Return 0 if we failed the
2790    caller should emit a normal call, otherwise try to get the result
2791    in TARGET, if convenient (and in mode MODE if that's convenient).  */
2792
2793 static rtx
2794 expand_builtin_strpbrk (tree arglist, tree type, rtx target, enum machine_mode mode)
2795 {
2796   if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2797     {
2798       tree result = fold_builtin_strpbrk (arglist, type);
2799       if (result)
2800         return expand_expr (result, target, mode, EXPAND_NORMAL);
2801     }
2802   return 0;
2803 }
2804
2805 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
2806    bytes from constant string DATA + OFFSET and return it as target
2807    constant.  */
2808
2809 static rtx
2810 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
2811                          enum machine_mode mode)
2812 {
2813   const char *str = (const char *) data;
2814
2815   gcc_assert (offset >= 0
2816               && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
2817                   <= strlen (str) + 1));
2818
2819   return c_readstr (str + offset, mode);
2820 }
2821
2822 /* Expand a call to the memcpy builtin, with arguments in ARGLIST.
2823    Return 0 if we failed, the caller should emit a normal call,
2824    otherwise try to get the result in TARGET, if convenient (and in
2825    mode MODE if that's convenient).  */
2826 static rtx
2827 expand_builtin_memcpy (tree exp, rtx target, enum machine_mode mode)
2828 {
2829   tree fndecl = get_callee_fndecl (exp);
2830   tree arglist = TREE_OPERAND (exp, 1);
2831   if (!validate_arglist (arglist,
2832                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2833     return 0;
2834   else
2835     {
2836       tree dest = TREE_VALUE (arglist);
2837       tree src = TREE_VALUE (TREE_CHAIN (arglist));
2838       tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2839       const char *src_str;
2840       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
2841       unsigned int dest_align
2842         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
2843       rtx dest_mem, src_mem, dest_addr, len_rtx;
2844       tree result = fold_builtin_memcpy (fndecl, arglist);
2845
2846       if (result)
2847         return expand_expr (result, target, mode, EXPAND_NORMAL);
2848
2849       /* If DEST is not a pointer type, call the normal function.  */
2850       if (dest_align == 0)
2851         return 0;
2852
2853       /* If either SRC is not a pointer type, don't do this
2854          operation in-line.  */
2855       if (src_align == 0)
2856         return 0;
2857
2858       dest_mem = get_memory_rtx (dest, len);
2859       set_mem_align (dest_mem, dest_align);
2860       len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
2861       src_str = c_getstr (src);
2862
2863       /* If SRC is a string constant and block move would be done
2864          by pieces, we can avoid loading the string from memory
2865          and only stored the computed constants.  */
2866       if (src_str
2867           && GET_CODE (len_rtx) == CONST_INT
2868           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
2869           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
2870                                   (void *) src_str, dest_align))
2871         {
2872           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
2873                                       builtin_memcpy_read_str,
2874                                       (void *) src_str, dest_align, 0);
2875           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2876           dest_mem = convert_memory_address (ptr_mode, dest_mem);
2877           return dest_mem;
2878         }
2879
2880       src_mem = get_memory_rtx (src, len);
2881       set_mem_align (src_mem, src_align);
2882
2883       /* Copy word part most expediently.  */
2884       dest_addr = emit_block_move (dest_mem, src_mem, len_rtx,
2885                                    CALL_EXPR_TAILCALL (exp)
2886                                    ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL);
2887
2888       if (dest_addr == 0)
2889         {
2890           dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2891           dest_addr = convert_memory_address (ptr_mode, dest_addr);
2892         }
2893       return dest_addr;
2894     }
2895 }
2896
2897 /* Expand a call to the mempcpy builtin, with arguments in ARGLIST.
2898    Return 0 if we failed; the caller should emit a normal call,
2899    otherwise try to get the result in TARGET, if convenient (and in
2900    mode MODE if that's convenient).  If ENDP is 0 return the
2901    destination pointer, if ENDP is 1 return the end pointer ala
2902    mempcpy, and if ENDP is 2 return the end pointer minus one ala
2903    stpcpy.  */
2904
2905 static rtx
2906 expand_builtin_mempcpy (tree arglist, tree type, rtx target, enum machine_mode mode,
2907                         int endp)
2908 {
2909   if (!validate_arglist (arglist,
2910                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2911     return 0;
2912   /* If return value is ignored, transform mempcpy into memcpy.  */
2913   else if (target == const0_rtx)
2914     {
2915       tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
2916
2917       if (!fn)
2918         return 0;
2919
2920       return expand_expr (build_function_call_expr (fn, arglist),
2921                           target, mode, EXPAND_NORMAL);
2922     }
2923   else
2924     {
2925       tree dest = TREE_VALUE (arglist);
2926       tree src = TREE_VALUE (TREE_CHAIN (arglist));
2927       tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2928       const char *src_str;
2929       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
2930       unsigned int dest_align
2931         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
2932       rtx dest_mem, src_mem, len_rtx;
2933       tree result = fold_builtin_mempcpy (arglist, type, endp);
2934
2935       if (result)
2936         return expand_expr (result, target, mode, EXPAND_NORMAL);
2937
2938       /* If either SRC or DEST is not a pointer type, don't do this
2939          operation in-line.  */
2940       if (dest_align == 0 || src_align == 0)
2941         return 0;
2942
2943       /* If LEN is not constant, call the normal function.  */
2944       if (! host_integerp (len, 1))
2945         return 0;
2946
2947       len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
2948       src_str = c_getstr (src);
2949
2950       /* If SRC is a string constant and block move would be done
2951          by pieces, we can avoid loading the string from memory
2952          and only stored the computed constants.  */
2953       if (src_str
2954           && GET_CODE (len_rtx) == CONST_INT
2955           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
2956           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
2957                                   (void *) src_str, dest_align))
2958         {
2959           dest_mem = get_memory_rtx (dest, len);
2960           set_mem_align (dest_mem, dest_align);
2961           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
2962                                       builtin_memcpy_read_str,
2963                                       (void *) src_str, dest_align, endp);
2964           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2965           dest_mem = convert_memory_address (ptr_mode, dest_mem);
2966           return dest_mem;
2967         }
2968
2969       if (GET_CODE (len_rtx) == CONST_INT
2970           && can_move_by_pieces (INTVAL (len_rtx),
2971                                  MIN (dest_align, src_align)))
2972         {
2973           dest_mem = get_memory_rtx (dest, len);
2974           set_mem_align (dest_mem, dest_align);
2975           src_mem = get_memory_rtx (src, len);
2976           set_mem_align (src_mem, src_align);
2977           dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
2978                                      MIN (dest_align, src_align), endp);
2979           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2980           dest_mem = convert_memory_address (ptr_mode, dest_mem);
2981           return dest_mem;
2982         }
2983
2984       return 0;
2985     }
2986 }
2987
2988 /* Expand expression EXP, which is a call to the memmove builtin.  Return 0
2989    if we failed; the caller should emit a normal call.  */
2990
2991 static rtx
2992 expand_builtin_memmove (tree arglist, tree type, rtx target,
2993                         enum machine_mode mode, tree orig_exp)
2994 {
2995   if (!validate_arglist (arglist,
2996                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2997     return 0;
2998   else
2999     {
3000       tree dest = TREE_VALUE (arglist);
3001       tree src = TREE_VALUE (TREE_CHAIN (arglist));
3002       tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3003
3004       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3005       unsigned int dest_align
3006         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3007       tree result = fold_builtin_memmove (arglist, type);
3008
3009       if (result)
3010         return expand_expr (result, target, mode, EXPAND_NORMAL);
3011
3012       /* If DEST is not a pointer type, call the normal function.  */
3013       if (dest_align == 0)
3014         return 0;
3015
3016       /* If either SRC is not a pointer type, don't do this
3017          operation in-line.  */
3018       if (src_align == 0)
3019         return 0;
3020
3021       /* If src is categorized for a readonly section we can use
3022          normal memcpy.  */
3023       if (readonly_data_expr (src))
3024         {
3025           tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
3026           if (!fn)
3027             return 0;
3028           fn = build_function_call_expr (fn, arglist);
3029           if (TREE_CODE (fn) == CALL_EXPR)
3030             CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
3031           return expand_expr (fn, target, mode, EXPAND_NORMAL);
3032         }
3033
3034       /* If length is 1 and we can expand memcpy call inline,
3035          it is ok to use memcpy as well.  */
3036       if (integer_onep (len))
3037         {
3038           rtx ret = expand_builtin_mempcpy (arglist, type, target, mode,
3039                                             /*endp=*/0);
3040           if (ret)
3041             return ret;
3042         }
3043
3044       /* Otherwise, call the normal function.  */
3045       return 0;
3046    }
3047 }
3048
3049 /* Expand expression EXP, which is a call to the bcopy builtin.  Return 0
3050    if we failed the caller should emit a normal call.  */
3051
3052 static rtx
3053 expand_builtin_bcopy (tree exp)
3054 {
3055   tree arglist = TREE_OPERAND (exp, 1);
3056   tree type = TREE_TYPE (exp);
3057   tree src, dest, size, newarglist;
3058
3059   if (!validate_arglist (arglist,
3060                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3061     return NULL_RTX;
3062
3063   src = TREE_VALUE (arglist);
3064   dest = TREE_VALUE (TREE_CHAIN (arglist));
3065   size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3066
3067   /* New argument list transforming bcopy(ptr x, ptr y, int z) to
3068      memmove(ptr y, ptr x, size_t z).   This is done this way
3069      so that if it isn't expanded inline, we fallback to
3070      calling bcopy instead of memmove.  */
3071
3072   newarglist = build_tree_list (NULL_TREE, fold_convert (sizetype, size));
3073   newarglist = tree_cons (NULL_TREE, src, newarglist);
3074   newarglist = tree_cons (NULL_TREE, dest, newarglist);
3075
3076   return expand_builtin_memmove (newarglist, type, const0_rtx, VOIDmode, exp);
3077 }
3078
3079 #ifndef HAVE_movstr
3080 # define HAVE_movstr 0
3081 # define CODE_FOR_movstr CODE_FOR_nothing
3082 #endif
3083
3084 /* Expand into a movstr instruction, if one is available.  Return 0 if
3085    we failed, the caller should emit a normal call, otherwise try to
3086    get the result in TARGET, if convenient.  If ENDP is 0 return the
3087    destination pointer, if ENDP is 1 return the end pointer ala
3088    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3089    stpcpy.  */
3090
3091 static rtx
3092 expand_movstr (tree dest, tree src, rtx target, int endp)
3093 {
3094   rtx end;
3095   rtx dest_mem;
3096   rtx src_mem;
3097   rtx insn;
3098   const struct insn_data * data;
3099
3100   if (!HAVE_movstr)
3101     return 0;
3102
3103   dest_mem = get_memory_rtx (dest, NULL);
3104   src_mem = get_memory_rtx (src, NULL);
3105   if (!endp)
3106     {
3107       target = force_reg (Pmode, XEXP (dest_mem, 0));
3108       dest_mem = replace_equiv_address (dest_mem, target);
3109       end = gen_reg_rtx (Pmode);
3110     }
3111   else
3112     {
3113       if (target == 0 || target == const0_rtx)
3114         {
3115           end = gen_reg_rtx (Pmode);
3116           if (target == 0)
3117             target = end;
3118         }
3119       else
3120         end = target;
3121     }
3122
3123   data = insn_data + CODE_FOR_movstr;
3124
3125   if (data->operand[0].mode != VOIDmode)
3126     end = gen_lowpart (data->operand[0].mode, end);
3127
3128   insn = data->genfun (end, dest_mem, src_mem);
3129
3130   gcc_assert (insn);
3131
3132   emit_insn (insn);
3133
3134   /* movstr is supposed to set end to the address of the NUL
3135      terminator.  If the caller requested a mempcpy-like return value,
3136      adjust it.  */
3137   if (endp == 1 && target != const0_rtx)
3138     {
3139       rtx tem = plus_constant (gen_lowpart (GET_MODE (target), end), 1);
3140       emit_move_insn (target, force_operand (tem, NULL_RTX));
3141     }
3142
3143   return target;
3144 }
3145
3146 /* Expand expression EXP, which is a call to the strcpy builtin.  Return 0
3147    if we failed the caller should emit a normal call, otherwise try to get
3148    the result in TARGET, if convenient (and in mode MODE if that's
3149    convenient).  */
3150
3151 static rtx
3152 expand_builtin_strcpy (tree fndecl, tree arglist, rtx target, enum machine_mode mode)
3153 {
3154   if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3155     {
3156       tree result = fold_builtin_strcpy (fndecl, arglist, 0);
3157       if (result)
3158         return expand_expr (result, target, mode, EXPAND_NORMAL);
3159
3160       return expand_movstr (TREE_VALUE (arglist),
3161                             TREE_VALUE (TREE_CHAIN (arglist)),
3162                             target, /*endp=*/0);
3163     }
3164   return 0;
3165 }
3166
3167 /* Expand a call to the stpcpy builtin, with arguments in ARGLIST.
3168    Return 0 if we failed the caller should emit a normal call,
3169    otherwise try to get the result in TARGET, if convenient (and in
3170    mode MODE if that's convenient).  */
3171
3172 static rtx
3173 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
3174 {
3175   tree arglist = TREE_OPERAND (exp, 1);
3176   /* If return value is ignored, transform stpcpy into strcpy.  */
3177   if (target == const0_rtx)
3178     {
3179       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
3180       if (!fn)
3181         return 0;
3182
3183       return expand_expr (build_function_call_expr (fn, arglist),
3184                           target, mode, EXPAND_NORMAL);
3185     }
3186
3187   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3188     return 0;
3189   else
3190     {
3191       tree dst, src, len, lenp1;
3192       tree narglist;
3193       rtx ret;
3194
3195       /* Ensure we get an actual string whose length can be evaluated at
3196          compile-time, not an expression containing a string.  This is
3197          because the latter will potentially produce pessimized code
3198          when used to produce the return value.  */
3199       src = TREE_VALUE (TREE_CHAIN (arglist));
3200       if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3201         return expand_movstr (TREE_VALUE (arglist),
3202                               TREE_VALUE (TREE_CHAIN (arglist)),
3203                               target, /*endp=*/2);
3204
3205       dst = TREE_VALUE (arglist);
3206       lenp1 = size_binop (PLUS_EXPR, len, ssize_int (1));
3207       narglist = build_tree_list (NULL_TREE, lenp1);
3208       narglist = tree_cons (NULL_TREE, src, narglist);
3209       narglist = tree_cons (NULL_TREE, dst, narglist);
3210       ret = expand_builtin_mempcpy (narglist, TREE_TYPE (exp),
3211                                     target, mode, /*endp=*/2);
3212
3213       if (ret)
3214         return ret;
3215
3216       if (TREE_CODE (len) == INTEGER_CST)
3217         {
3218           rtx len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
3219
3220           if (GET_CODE (len_rtx) == CONST_INT)
3221             {
3222               ret = expand_builtin_strcpy (get_callee_fndecl (exp),
3223                                            arglist, target, mode);
3224
3225               if (ret)
3226                 {
3227                   if (! target)
3228                     {
3229                       if (mode != VOIDmode)
3230                         target = gen_reg_rtx (mode);
3231                       else
3232                         target = gen_reg_rtx (GET_MODE (ret));
3233                     }
3234                   if (GET_MODE (target) != GET_MODE (ret))
3235                     ret = gen_lowpart (GET_MODE (target), ret);
3236
3237                   ret = plus_constant (ret, INTVAL (len_rtx));
3238                   ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3239                   gcc_assert (ret);
3240
3241                   return target;
3242                 }
3243             }
3244         }
3245
3246       return expand_movstr (TREE_VALUE (arglist),
3247                             TREE_VALUE (TREE_CHAIN (arglist)),
3248                             target, /*endp=*/2);
3249     }
3250 }
3251
3252 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3253    bytes from constant string DATA + OFFSET and return it as target
3254    constant.  */
3255
3256 static rtx
3257 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3258                           enum machine_mode mode)
3259 {
3260   const char *str = (const char *) data;
3261
3262   if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3263     return const0_rtx;
3264
3265   return c_readstr (str + offset, mode);
3266 }
3267
3268 /* Expand expression EXP, which is a call to the strncpy builtin.  Return 0
3269    if we failed the caller should emit a normal call.  */
3270
3271 static rtx
3272 expand_builtin_strncpy (tree exp, rtx target, enum machine_mode mode)
3273 {
3274   tree fndecl = get_callee_fndecl (exp);
3275   tree arglist = TREE_OPERAND (exp, 1);
3276   if (validate_arglist (arglist,
3277                         POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3278     {
3279       tree slen = c_strlen (TREE_VALUE (TREE_CHAIN (arglist)), 1);
3280       tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3281       tree result = fold_builtin_strncpy (fndecl, arglist, slen);
3282
3283       if (result)
3284         return expand_expr (result, target, mode, EXPAND_NORMAL);
3285
3286       /* We must be passed a constant len and src parameter.  */
3287       if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
3288         return 0;
3289
3290       slen = size_binop (PLUS_EXPR, slen, ssize_int (1));
3291
3292       /* We're required to pad with trailing zeros if the requested
3293          len is greater than strlen(s2)+1.  In that case try to
3294          use store_by_pieces, if it fails, punt.  */
3295       if (tree_int_cst_lt (slen, len))
3296         {
3297           tree dest = TREE_VALUE (arglist);
3298           unsigned int dest_align
3299             = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3300           const char *p = c_getstr (TREE_VALUE (TREE_CHAIN (arglist)));
3301           rtx dest_mem;
3302
3303           if (!p || dest_align == 0 || !host_integerp (len, 1)
3304               || !can_store_by_pieces (tree_low_cst (len, 1),
3305                                        builtin_strncpy_read_str,
3306                                        (void *) p, dest_align))
3307             return 0;
3308
3309           dest_mem = get_memory_rtx (dest, len);
3310           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3311                            builtin_strncpy_read_str,
3312                            (void *) p, dest_align, 0);
3313           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3314           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3315           return dest_mem;
3316         }
3317     }
3318   return 0;
3319 }
3320
3321 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3322    bytes from constant string DATA + OFFSET and return it as target
3323    constant.  */
3324
3325 static rtx
3326 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3327                          enum machine_mode mode)
3328 {
3329   const char *c = (const char *) data;
3330   char *p = alloca (GET_MODE_SIZE (mode));
3331
3332   memset (p, *c, GET_MODE_SIZE (mode));
3333
3334   return c_readstr (p, mode);
3335 }
3336
3337 /* Callback routine for store_by_pieces.  Return the RTL of a register
3338    containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3339    char value given in the RTL register data.  For example, if mode is
3340    4 bytes wide, return the RTL for 0x01010101*data.  */
3341
3342 static rtx
3343 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3344                         enum machine_mode mode)
3345 {
3346   rtx target, coeff;
3347   size_t size;
3348   char *p;
3349
3350   size = GET_MODE_SIZE (mode);
3351   if (size == 1)
3352     return (rtx) data;
3353
3354   p = alloca (size);
3355   memset (p, 1, size);
3356   coeff = c_readstr (p, mode);
3357
3358   target = convert_to_mode (mode, (rtx) data, 1);
3359   target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3360   return force_reg (mode, target);
3361 }
3362
3363 /* Expand expression EXP, which is a call to the memset builtin.  Return 0
3364    if we failed the caller should emit a normal call, otherwise try to get
3365    the result in TARGET, if convenient (and in mode MODE if that's
3366    convenient).  */
3367
3368 static rtx
3369 expand_builtin_memset (tree arglist, rtx target, enum machine_mode mode,
3370                        tree orig_exp)
3371 {
3372   if (!validate_arglist (arglist,
3373                          POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3374     return 0;
3375   else
3376     {
3377       tree dest = TREE_VALUE (arglist);
3378       tree val = TREE_VALUE (TREE_CHAIN (arglist));
3379       tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3380       char c;
3381
3382       unsigned int dest_align
3383         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3384       rtx dest_mem, dest_addr, len_rtx;
3385
3386       /* If DEST is not a pointer type, don't do this
3387          operation in-line.  */
3388       if (dest_align == 0)
3389         return 0;
3390
3391       /* If the LEN parameter is zero, return DEST.  */
3392       if (integer_zerop (len))
3393         {
3394           /* Evaluate and ignore VAL in case it has side-effects.  */
3395           expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3396           return expand_expr (dest, target, mode, EXPAND_NORMAL);
3397         }
3398
3399       len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
3400       dest_mem = get_memory_rtx (dest, len);
3401
3402       if (TREE_CODE (val) != INTEGER_CST)
3403         {
3404           rtx val_rtx;
3405
3406           val = fold_build1 (CONVERT_EXPR, unsigned_char_type_node, val);
3407           val_rtx = expand_expr (val, NULL_RTX, VOIDmode, 0);
3408
3409           /* Assume that we can memset by pieces if we can store the
3410            * the coefficients by pieces (in the required modes).
3411            * We can't pass builtin_memset_gen_str as that emits RTL.  */
3412           c = 1;
3413           if (host_integerp (len, 1)
3414               && !(optimize_size && tree_low_cst (len, 1) > 1)
3415               && can_store_by_pieces (tree_low_cst (len, 1),
3416                                       builtin_memset_read_str, &c, dest_align))
3417             {
3418               val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
3419                                    val_rtx);
3420               store_by_pieces (dest_mem, tree_low_cst (len, 1),
3421                                builtin_memset_gen_str, val_rtx, dest_align, 0);
3422             }
3423           else if (!set_storage_via_setmem(dest_mem, len_rtx, val_rtx,
3424                                            dest_align))
3425             return 0;
3426
3427           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3428           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3429           return dest_mem;
3430         }
3431
3432       if (target_char_cast (val, &c))
3433         return 0;
3434
3435       if (c)
3436         {
3437           if (host_integerp (len, 1)
3438               && !(optimize_size && tree_low_cst (len, 1) > 1)
3439               && can_store_by_pieces (tree_low_cst (len, 1),
3440                                       builtin_memset_read_str, &c, dest_align))
3441             store_by_pieces (dest_mem, tree_low_cst (len, 1),
3442                              builtin_memset_read_str, &c, dest_align, 0);
3443           else if (!set_storage_via_setmem (dest_mem, len_rtx, GEN_INT (c),
3444                                             dest_align))
3445             return 0;
3446
3447           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3448           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3449           return dest_mem;
3450         }
3451
3452       set_mem_align (dest_mem, dest_align);
3453       dest_addr = clear_storage (dest_mem, len_rtx,
3454                                  CALL_EXPR_TAILCALL (orig_exp)
3455                                  ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL);
3456
3457       if (dest_addr == 0)
3458         {
3459           dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3460           dest_addr = convert_memory_address (ptr_mode, dest_addr);
3461         }
3462
3463       return dest_addr;
3464     }
3465 }
3466
3467 /* Expand expression EXP, which is a call to the bzero builtin.  Return 0
3468    if we failed the caller should emit a normal call.  */
3469
3470 static rtx
3471 expand_builtin_bzero (tree exp)
3472 {
3473   tree arglist = TREE_OPERAND (exp, 1);
3474   tree dest, size, newarglist;
3475
3476   if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3477     return NULL_RTX;
3478
3479   dest = TREE_VALUE (arglist);
3480   size = TREE_VALUE (TREE_CHAIN (arglist));
3481
3482   /* New argument list transforming bzero(ptr x, int y) to
3483      memset(ptr x, int 0, size_t y).   This is done this way
3484      so that if it isn't expanded inline, we fallback to
3485      calling bzero instead of memset.  */
3486
3487   newarglist = build_tree_list (NULL_TREE, fold_convert (sizetype, size));
3488   newarglist = tree_cons (NULL_TREE, integer_zero_node, newarglist);
3489   newarglist = tree_cons (NULL_TREE, dest, newarglist);
3490
3491   return expand_builtin_memset (newarglist, const0_rtx, VOIDmode, exp);
3492 }
3493
3494 /* Expand expression EXP, which is a call to the memcmp built-in function.
3495    ARGLIST is the argument list for this call.  Return 0 if we failed and the
3496    caller should emit a normal call, otherwise try to get the result in
3497    TARGET, if convenient (and in mode MODE, if that's convenient).  */
3498
3499 static rtx
3500 expand_builtin_memcmp (tree exp ATTRIBUTE_UNUSED, tree arglist, rtx target,
3501                        enum machine_mode mode)
3502 {
3503   if (!validate_arglist (arglist,
3504                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3505     return 0;
3506   else
3507     {
3508       tree result = fold_builtin_memcmp (arglist);
3509       if (result)
3510         return expand_expr (result, target, mode, EXPAND_NORMAL);
3511     }
3512
3513 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrnsi
3514   {
3515     tree arg1 = TREE_VALUE (arglist);
3516     tree arg2 = TREE_VALUE (TREE_CHAIN (arglist));
3517     tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3518     rtx arg1_rtx, arg2_rtx, arg3_rtx;
3519     rtx result;
3520     rtx insn;
3521
3522     int arg1_align
3523       = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3524     int arg2_align
3525       = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3526     enum machine_mode insn_mode;
3527
3528 #ifdef HAVE_cmpmemsi
3529     if (HAVE_cmpmemsi)
3530       insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
3531     else
3532 #endif
3533 #ifdef HAVE_cmpstrnsi
3534     if (HAVE_cmpstrnsi)
3535       insn_mode = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
3536     else
3537 #endif
3538       return 0;
3539
3540     /* If we don't have POINTER_TYPE, call the function.  */
3541     if (arg1_align == 0 || arg2_align == 0)
3542       return 0;
3543
3544     /* Make a place to write the result of the instruction.  */
3545     result = target;
3546     if (! (result != 0
3547            && REG_P (result) && GET_MODE (result) == insn_mode
3548            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3549       result = gen_reg_rtx (insn_mode);
3550
3551     arg1_rtx = get_memory_rtx (arg1, len);
3552     arg2_rtx = get_memory_rtx (arg2, len);
3553     arg3_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
3554
3555     /* Set MEM_SIZE as appropriate.  */
3556     if (GET_CODE (arg3_rtx) == CONST_INT)
3557       {
3558         set_mem_size (arg1_rtx, arg3_rtx);
3559         set_mem_size (arg2_rtx, arg3_rtx);
3560       }
3561
3562 #ifdef HAVE_cmpmemsi
3563     if (HAVE_cmpmemsi)
3564       insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3565                            GEN_INT (MIN (arg1_align, arg2_align)));
3566     else
3567 #endif
3568 #ifdef HAVE_cmpstrnsi
3569     if (HAVE_cmpstrnsi)
3570       insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3571                             GEN_INT (MIN (arg1_align, arg2_align)));
3572     else
3573 #endif
3574       gcc_unreachable ();
3575
3576     if (insn)
3577       emit_insn (insn);
3578     else
3579       emit_library_call_value (memcmp_libfunc, result, LCT_PURE_MAKE_BLOCK,
3580                                TYPE_MODE (integer_type_node), 3,
3581                                XEXP (arg1_rtx, 0), Pmode,
3582                                XEXP (arg2_rtx, 0), Pmode,
3583                                convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
3584                                                 TYPE_UNSIGNED (sizetype)),
3585                                TYPE_MODE (sizetype));
3586
3587     /* Return the value in the proper mode for this function.  */
3588     mode = TYPE_MODE (TREE_TYPE (exp));
3589     if (GET_MODE (result) == mode)
3590       return result;
3591     else if (target != 0)
3592       {
3593         convert_move (target, result, 0);
3594         return target;
3595       }
3596     else
3597       return convert_to_mode (mode, result, 0);
3598   }
3599 #endif
3600
3601   return 0;
3602 }
3603
3604 /* Expand expression EXP, which is a call to the strcmp builtin.  Return 0
3605    if we failed the caller should emit a normal call, otherwise try to get
3606    the result in TARGET, if convenient.  */
3607
3608 static rtx
3609 expand_builtin_strcmp (tree exp, rtx target, enum machine_mode mode)
3610 {
3611   tree arglist = TREE_OPERAND (exp, 1);
3612
3613   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3614     return 0;
3615   else
3616     {
3617       tree result = fold_builtin_strcmp (arglist);
3618       if (result)
3619         return expand_expr (result, target, mode, EXPAND_NORMAL);
3620     }
3621
3622 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
3623   if (cmpstr_optab[SImode] != CODE_FOR_nothing
3624       || cmpstrn_optab[SImode] != CODE_FOR_nothing)
3625     {
3626       rtx arg1_rtx, arg2_rtx;
3627       rtx result, insn = NULL_RTX;
3628       tree fndecl, fn;
3629
3630       tree arg1 = TREE_VALUE (arglist);
3631       tree arg2 = TREE_VALUE (TREE_CHAIN (arglist));
3632       int arg1_align
3633         = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3634       int arg2_align
3635         = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3636
3637       /* If we don't have POINTER_TYPE, call the function.  */
3638       if (arg1_align == 0 || arg2_align == 0)
3639         return 0;
3640
3641       /* Stabilize the arguments in case gen_cmpstr(n)si fail.  */
3642       arg1 = builtin_save_expr (arg1);
3643       arg2 = builtin_save_expr (arg2);
3644
3645       arg1_rtx = get_memory_rtx (arg1, NULL);
3646       arg2_rtx = get_memory_rtx (arg2, NULL);
3647
3648 #ifdef HAVE_cmpstrsi
3649       /* Try to call cmpstrsi.  */
3650       if (HAVE_cmpstrsi)
3651         {
3652           enum machine_mode insn_mode
3653             = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
3654
3655           /* Make a place to write the result of the instruction.  */
3656           result = target;
3657           if (! (result != 0
3658                  && REG_P (result) && GET_MODE (result) == insn_mode
3659                  && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3660             result = gen_reg_rtx (insn_mode);
3661
3662           insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx,
3663                                GEN_INT (MIN (arg1_align, arg2_align)));
3664         }
3665 #endif
3666 #if HAVE_cmpstrnsi
3667       /* Try to determine at least one length and call cmpstrnsi.  */
3668       if (!insn && HAVE_cmpstrnsi)
3669         {
3670           tree len;
3671           rtx arg3_rtx;
3672
3673           enum machine_mode insn_mode
3674             = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
3675           tree len1 = c_strlen (arg1, 1);
3676           tree len2 = c_strlen (arg2, 1);
3677
3678           if (len1)
3679             len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
3680           if (len2)
3681             len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
3682
3683           /* If we don't have a constant length for the first, use the length
3684              of the second, if we know it.  We don't require a constant for
3685              this case; some cost analysis could be done if both are available
3686              but neither is constant.  For now, assume they're equally cheap,
3687              unless one has side effects.  If both strings have constant lengths,
3688              use the smaller.  */
3689
3690           if (!len1)
3691             len = len2;
3692           else if (!len2)
3693             len = len1;
3694           else if (TREE_SIDE_EFFECTS (len1))
3695             len = len2;
3696           else if (TREE_SIDE_EFFECTS (len2))
3697             len = len1;
3698           else if (TREE_CODE (len1) != INTEGER_CST)
3699             len = len2;
3700           else if (TREE_CODE (len2) != INTEGER_CST)
3701             len = len1;
3702           else if (tree_int_cst_lt (len1, len2))
3703             len = len1;
3704           else
3705             len = len2;
3706
3707           /* If both arguments have side effects, we cannot optimize.  */
3708           if (!len || TREE_SIDE_EFFECTS (len))
3709             return 0;
3710
3711           /* Stabilize the arguments in case gen_cmpstrnsi fails.  */
3712           arg3_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
3713
3714           /* Make a place to write the result of the instruction.  */
3715           result = target;
3716           if (! (result != 0
3717                  && REG_P (result) && GET_MODE (result) == insn_mode
3718                  && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3719             result = gen_reg_rtx (insn_mode);
3720
3721           insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3722                                 GEN_INT (MIN (arg1_align, arg2_align)));
3723         }
3724 #endif
3725
3726       if (insn)
3727         {
3728           emit_insn (insn);
3729
3730           /* Return the value in the proper mode for this function.  */
3731           mode = TYPE_MODE (TREE_TYPE (exp));
3732           if (GET_MODE (result) == mode)
3733             return result;
3734           if (target == 0)
3735             return convert_to_mode (mode, result, 0);
3736           convert_move (target, result, 0);
3737           return target;
3738         }
3739
3740       /* Expand the library call ourselves using a stabilized argument
3741          list to avoid re-evaluating the function's arguments twice.  */
3742       arglist = build_tree_list (NULL_TREE, arg2);
3743       arglist = tree_cons (NULL_TREE, arg1, arglist);
3744       fndecl = get_callee_fndecl (exp);
3745       fn = build_function_call_expr (fndecl, arglist);
3746       if (TREE_CODE (fn) == CALL_EXPR)
3747         CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
3748       return expand_call (fn, target, target == const0_rtx);
3749     }
3750 #endif
3751   return 0;
3752 }
3753
3754 /* Expand expression EXP, which is a call to the strncmp builtin.  Return 0
3755    if we failed the caller should emit a normal call, otherwise try to get
3756    the result in TARGET, if convenient.  */
3757
3758 static rtx
3759 expand_builtin_strncmp (tree exp, rtx target, enum machine_mode mode)
3760 {
3761   tree arglist = TREE_OPERAND (exp, 1);
3762
3763   if (!validate_arglist (arglist,
3764                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3765     return 0;
3766   else
3767     {
3768       tree result = fold_builtin_strncmp (arglist);
3769       if (result)
3770         return expand_expr (result, target, mode, EXPAND_NORMAL);
3771     }
3772
3773   /* If c_strlen can determine an expression for one of the string
3774      lengths, and it doesn't have side effects, then emit cmpstrnsi
3775      using length MIN(strlen(string)+1, arg3).  */
3776 #ifdef HAVE_cmpstrnsi
3777   if (HAVE_cmpstrnsi)
3778   {
3779     tree arg1 = TREE_VALUE (arglist);
3780     tree arg2 = TREE_VALUE (TREE_CHAIN (arglist));
3781     tree arg3 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3782     tree len, len1, len2;
3783     rtx arg1_rtx, arg2_rtx, arg3_rtx;
3784     rtx result, insn;
3785     tree fndecl, fn;
3786
3787     int arg1_align
3788       = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3789     int arg2_align
3790       = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3791     enum machine_mode insn_mode
3792       = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
3793
3794     len1 = c_strlen (arg1, 1);
3795     len2 = c_strlen (arg2, 1);
3796
3797     if (len1)
3798       len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
3799     if (len2)
3800       len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
3801
3802     /* If we don't have a constant length for the first, use the length
3803        of the second, if we know it.  We don't require a constant for
3804        this case; some cost analysis could be done if both are available
3805        but neither is constant.  For now, assume they're equally cheap,
3806        unless one has side effects.  If both strings have constant lengths,
3807        use the smaller.  */
3808
3809     if (!len1)
3810       len = len2;
3811     else if (!len2)
3812       len = len1;
3813     else if (TREE_SIDE_EFFECTS (len1))
3814       len = len2;
3815     else if (TREE_SIDE_EFFECTS (len2))
3816       len = len1;
3817     else if (TREE_CODE (len1) != INTEGER_CST)
3818       len = len2;
3819     else if (TREE_CODE (len2) != INTEGER_CST)
3820       len = len1;
3821     else if (tree_int_cst_lt (len1, len2))
3822       len = len1;
3823     else
3824       len = len2;
3825
3826     /* If both arguments have side effects, we cannot optimize.  */
3827     if (!len || TREE_SIDE_EFFECTS (len))
3828       return 0;
3829
3830     /* The actual new length parameter is MIN(len,arg3).  */
3831     len = fold_build2 (MIN_EXPR, TREE_TYPE (len), len,
3832                        fold_convert (TREE_TYPE (len), arg3));
3833
3834     /* If we don't have POINTER_TYPE, call the function.  */
3835     if (arg1_align == 0 || arg2_align == 0)
3836       return 0;
3837
3838     /* Make a place to write the result of the instruction.  */
3839     result = target;
3840     if (! (result != 0
3841            && REG_P (result) && GET_MODE (result) == insn_mode
3842            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3843       result = gen_reg_rtx (insn_mode);
3844
3845     /* Stabilize the arguments in case gen_cmpstrnsi fails.  */
3846     arg1 = builtin_save_expr (arg1);
3847     arg2 = builtin_save_expr (arg2);
3848     len = builtin_save_expr (len);
3849
3850     arg1_rtx = get_memory_rtx (arg1, len);
3851     arg2_rtx = get_memory_rtx (arg2, len);
3852     arg3_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
3853     insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3854                           GEN_INT (MIN (arg1_align, arg2_align)));
3855     if (insn)
3856       {
3857         emit_insn (insn);
3858
3859         /* Return the value in the proper mode for this function.  */
3860         mode = TYPE_MODE (TREE_TYPE (exp));
3861         if (GET_MODE (result) == mode)
3862           return result;
3863         if (target == 0)
3864           return convert_to_mode (mode, result, 0);
3865         convert_move (target, result, 0);
3866         return target;
3867       }
3868
3869     /* Expand the library call ourselves using a stabilized argument
3870        list to avoid re-evaluating the function's arguments twice.  */
3871     arglist = build_tree_list (NULL_TREE, len);
3872     arglist = tree_cons (NULL_TREE, arg2, arglist);
3873     arglist = tree_cons (NULL_TREE, arg1, arglist);
3874     fndecl = get_callee_fndecl (exp);
3875     fn = build_function_call_expr (fndecl, arglist);
3876     if (TREE_CODE (fn) == CALL_EXPR)
3877       CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
3878     return expand_call (fn, target, target == const0_rtx);
3879   }
3880 #endif
3881   return 0;
3882 }
3883
3884 /* Expand expression EXP, which is a call to the strcat builtin.
3885    Return 0 if we failed the caller should emit a normal call,
3886    otherwise try to get the result in TARGET, if convenient.  */
3887
3888 static rtx
3889 expand_builtin_strcat (tree fndecl, tree arglist, rtx target, enum machine_mode mode)
3890 {
3891   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3892     return 0;
3893   else
3894     {
3895       tree dst = TREE_VALUE (arglist),
3896       src = TREE_VALUE (TREE_CHAIN (arglist));
3897       const char *p = c_getstr (src);
3898
3899       /* If the string length is zero, return the dst parameter.  */
3900       if (p && *p == '\0')
3901         return expand_expr (dst, target, mode, EXPAND_NORMAL);
3902
3903       if (!optimize_size)
3904         {
3905           /* See if we can store by pieces into (dst + strlen(dst)).  */
3906           tree newsrc, newdst,
3907             strlen_fn = implicit_built_in_decls[BUILT_IN_STRLEN];
3908           rtx insns;
3909
3910           /* Stabilize the argument list.  */
3911           newsrc = builtin_save_expr (src);
3912           if (newsrc != src)
3913             arglist = build_tree_list (NULL_TREE, newsrc);
3914           else
3915             arglist = TREE_CHAIN (arglist); /* Reusing arglist if safe.  */
3916
3917           dst = builtin_save_expr (dst);
3918
3919           start_sequence ();
3920
3921           /* Create strlen (dst).  */
3922           newdst =
3923             build_function_call_expr (strlen_fn,
3924                                       build_tree_list (NULL_TREE, dst));
3925           /* Create (dst + (cast) strlen (dst)).  */
3926           newdst = fold_convert (TREE_TYPE (dst), newdst);
3927           newdst = fold_build2 (PLUS_EXPR, TREE_TYPE (dst), dst, newdst);
3928
3929           newdst = builtin_save_expr (newdst);
3930           arglist = tree_cons (NULL_TREE, newdst, arglist);
3931
3932           if (!expand_builtin_strcpy (fndecl, arglist, target, mode))
3933             {
3934               end_sequence (); /* Stop sequence.  */
3935               return 0;
3936             }
3937
3938           /* Output the entire sequence.  */
3939           insns = get_insns ();
3940           end_sequence ();
3941           emit_insn (insns);
3942
3943           return expand_expr (dst, target, mode, EXPAND_NORMAL);
3944         }
3945
3946       return 0;
3947     }
3948 }
3949
3950 /* Expand expression EXP, which is a call to the strncat builtin.
3951    Return 0 if we failed the caller should emit a normal call,
3952    otherwise try to get the result in TARGET, if convenient.  */
3953
3954 static rtx
3955 expand_builtin_strncat (tree arglist, rtx target, enum machine_mode mode)
3956 {
3957   if (validate_arglist (arglist,
3958                         POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3959     {
3960       tree result = fold_builtin_strncat (arglist);
3961       if (result)
3962         return expand_expr (result, target, mode, EXPAND_NORMAL);
3963     }
3964   return 0;
3965 }
3966
3967 /* Expand expression EXP, which is a call to the strspn builtin.
3968    Return 0 if we failed the caller should emit a normal call,
3969    otherwise try to get the result in TARGET, if convenient.  */
3970
3971 static rtx
3972 expand_builtin_strspn (tree arglist, rtx target, enum machine_mode mode)
3973 {
3974   if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3975     {
3976       tree result = fold_builtin_strspn (arglist);
3977       if (result)
3978         return expand_expr (result, target, mode, EXPAND_NORMAL);
3979     }
3980   return 0;
3981 }
3982
3983 /* Expand expression EXP, which is a call to the strcspn builtin.
3984    Return 0 if we failed the caller should emit a normal call,
3985    otherwise try to get the result in TARGET, if convenient.  */
3986
3987 static rtx
3988 expand_builtin_strcspn (tree arglist, rtx target, enum machine_mode mode)
3989 {
3990   if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3991     {
3992       tree result = fold_builtin_strcspn (arglist);
3993       if (result)
3994         return expand_expr (result, target, mode, EXPAND_NORMAL);
3995     }
3996   return 0;
3997 }
3998
3999 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4000    if that's convenient.  */
4001
4002 rtx
4003 expand_builtin_saveregs (void)
4004 {
4005   rtx val, seq;
4006
4007   /* Don't do __builtin_saveregs more than once in a function.
4008      Save the result of the first call and reuse it.  */
4009   if (saveregs_value != 0)
4010     return saveregs_value;
4011
4012   /* When this function is called, it means that registers must be
4013      saved on entry to this function.  So we migrate the call to the
4014      first insn of this function.  */
4015
4016   start_sequence ();
4017
4018   /* Do whatever the machine needs done in this case.  */
4019   val = targetm.calls.expand_builtin_saveregs ();
4020
4021   seq = get_insns ();
4022   end_sequence ();
4023
4024   saveregs_value = val;
4025
4026   /* Put the insns after the NOTE that starts the function.  If this
4027      is inside a start_sequence, make the outer-level insn chain current, so
4028      the code is placed at the start of the function.  */
4029   push_topmost_sequence ();
4030   emit_insn_after (seq, entry_of_function ());
4031   pop_topmost_sequence ();
4032
4033   return val;
4034 }
4035
4036 /* __builtin_args_info (N) returns word N of the arg space info
4037    for the current function.  The number and meanings of words
4038    is controlled by the definition of CUMULATIVE_ARGS.  */
4039
4040 static rtx
4041 expand_builtin_args_info (tree arglist)
4042 {
4043   int nwords = sizeof (CUMULATIVE_ARGS) / sizeof (int);
4044   int *word_ptr = (int *) &current_function_args_info;
4045
4046   gcc_assert (sizeof (CUMULATIVE_ARGS) % sizeof (int) == 0);
4047
4048   if (arglist != 0)
4049     {
4050       if (!host_integerp (TREE_VALUE (arglist), 0))
4051         error ("argument of %<__builtin_args_info%> must be constant");
4052       else
4053         {
4054           HOST_WIDE_INT wordnum = tree_low_cst (TREE_VALUE (arglist), 0);
4055
4056           if (wordnum < 0 || wordnum >= nwords)
4057             error ("argument of %<__builtin_args_info%> out of range");
4058           else
4059             return GEN_INT (word_ptr[wordnum]);
4060         }
4061     }
4062   else
4063     error ("missing argument in %<__builtin_args_info%>");
4064
4065   return const0_rtx;
4066 }
4067
4068 /* Expand a call to __builtin_next_arg.  */
4069
4070 static rtx
4071 expand_builtin_next_arg (void)
4072 {
4073   /* Checking arguments is already done in fold_builtin_next_arg
4074      that must be called before this function.  */
4075   return expand_binop (Pmode, add_optab,
4076                        current_function_internal_arg_pointer,
4077                        current_function_arg_offset_rtx,
4078                        NULL_RTX, 0, OPTAB_LIB_WIDEN);
4079 }
4080
4081 /* Make it easier for the backends by protecting the valist argument
4082    from multiple evaluations.  */
4083
4084 static tree
4085 stabilize_va_list (tree valist, int needs_lvalue)
4086 {
4087   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
4088     {
4089       if (TREE_SIDE_EFFECTS (valist))
4090         valist = save_expr (valist);
4091
4092       /* For this case, the backends will be expecting a pointer to
4093          TREE_TYPE (va_list_type_node), but it's possible we've
4094          actually been given an array (an actual va_list_type_node).
4095          So fix it.  */
4096       if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4097         {
4098           tree p1 = build_pointer_type (TREE_TYPE (va_list_type_node));
4099           valist = build_fold_addr_expr_with_type (valist, p1);
4100         }
4101     }
4102   else
4103     {
4104       tree pt;
4105
4106       if (! needs_lvalue)
4107         {
4108           if (! TREE_SIDE_EFFECTS (valist))
4109             return valist;
4110
4111           pt = build_pointer_type (va_list_type_node);
4112           valist = fold_build1 (ADDR_EXPR, pt, valist);
4113           TREE_SIDE_EFFECTS (valist) = 1;
4114         }
4115
4116       if (TREE_SIDE_EFFECTS (valist))
4117         valist = save_expr (valist);
4118       valist = build_fold_indirect_ref (valist);
4119     }
4120
4121   return valist;
4122 }
4123
4124 /* The "standard" definition of va_list is void*.  */
4125
4126 tree
4127 std_build_builtin_va_list (void)
4128 {
4129   return ptr_type_node;
4130 }
4131
4132 /* The "standard" implementation of va_start: just assign `nextarg' to
4133    the variable.  */
4134
4135 void
4136 std_expand_builtin_va_start (tree valist, rtx nextarg)
4137 {
4138   tree t;
4139
4140   t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist,
4141               make_tree (ptr_type_node, nextarg));
4142   TREE_SIDE_EFFECTS (t) = 1;
4143
4144   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4145 }
4146
4147 /* Expand ARGLIST, from a call to __builtin_va_start.  */
4148
4149 static rtx
4150 expand_builtin_va_start (tree arglist)
4151 {
4152   rtx nextarg;
4153   tree chain, valist;
4154
4155   chain = TREE_CHAIN (arglist);
4156
4157   if (!chain)
4158     {
4159       error ("too few arguments to function %<va_start%>");
4160       return const0_rtx;
4161     }
4162
4163   if (fold_builtin_next_arg (chain))
4164     return const0_rtx;
4165
4166   nextarg = expand_builtin_next_arg ();
4167   valist = stabilize_va_list (TREE_VALUE (arglist), 1);
4168
4169 #ifdef EXPAND_BUILTIN_VA_START
4170   EXPAND_BUILTIN_VA_START (valist, nextarg);
4171 #else
4172   std_expand_builtin_va_start (valist, nextarg);
4173 #endif
4174
4175   return const0_rtx;
4176 }
4177
4178 /* The "standard" implementation of va_arg: read the value from the
4179    current (padded) address and increment by the (padded) size.  */
4180
4181 tree
4182 std_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p, tree *post_p)
4183 {
4184   tree addr, t, type_size, rounded_size, valist_tmp;
4185   unsigned HOST_WIDE_INT align, boundary;
4186   bool indirect;
4187
4188 #ifdef ARGS_GROW_DOWNWARD
4189   /* All of the alignment and movement below is for args-grow-up machines.
4190      As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4191      implement their own specialized gimplify_va_arg_expr routines.  */
4192   gcc_unreachable ();
4193 #endif
4194
4195   indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
4196   if (indirect)
4197     type = build_pointer_type (type);
4198
4199   align = PARM_BOUNDARY / BITS_PER_UNIT;
4200   boundary = FUNCTION_ARG_BOUNDARY (TYPE_MODE (type), type) / BITS_PER_UNIT;
4201
4202   /* Hoist the valist value into a temporary for the moment.  */
4203   valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
4204
4205   /* va_list pointer is aligned to PARM_BOUNDARY.  If argument actually
4206      requires greater alignment, we must perform dynamic alignment.  */
4207   if (boundary > align
4208       && !integer_zerop (TYPE_SIZE (type)))
4209     {
4210       t = fold_convert (TREE_TYPE (valist), size_int (boundary - 1));
4211       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4212                   build2 (PLUS_EXPR, TREE_TYPE (valist), valist_tmp, t));
4213       gimplify_and_add (t, pre_p);
4214
4215       t = fold_convert (TREE_TYPE (valist), size_int (-boundary));
4216       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4217                   build2 (BIT_AND_EXPR, TREE_TYPE (valist), valist_tmp, t));
4218       gimplify_and_add (t, pre_p);
4219     }
4220   else
4221     boundary = align;
4222
4223   /* If the actual alignment is less than the alignment of the type,
4224      adjust the type accordingly so that we don't assume strict alignment
4225      when deferencing the pointer.  */
4226   boundary *= BITS_PER_UNIT;
4227   if (boundary < TYPE_ALIGN (type))
4228     {
4229       type = build_variant_type_copy (type);
4230       TYPE_ALIGN (type) = boundary;
4231     }
4232
4233   /* Compute the rounded size of the type.  */
4234   type_size = size_in_bytes (type);
4235   rounded_size = round_up (type_size, align);
4236
4237   /* Reduce rounded_size so it's sharable with the postqueue.  */
4238   gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
4239
4240   /* Get AP.  */
4241   addr = valist_tmp;
4242   if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
4243     {
4244       /* Small args are padded downward.  */
4245       t = fold_build2 (GT_EXPR, sizetype, rounded_size, size_int (align));
4246       t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
4247                        size_binop (MINUS_EXPR, rounded_size, type_size));
4248       t = fold_convert (TREE_TYPE (addr), t);
4249       addr = fold_build2 (PLUS_EXPR, TREE_TYPE (addr), addr, t);
4250     }
4251
4252   /* Compute new value for AP.  */
4253   t = fold_convert (TREE_TYPE (valist), rounded_size);
4254   t = build2 (PLUS_EXPR, TREE_TYPE (valist), valist_tmp, t);
4255   t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
4256   gimplify_and_add (t, pre_p);
4257
4258   addr = fold_convert (build_pointer_type (type), addr);
4259
4260   if (indirect)
4261     addr = build_va_arg_indirect_ref (addr);
4262
4263   return build_va_arg_indirect_ref (addr);
4264 }
4265
4266 /* Build an indirect-ref expression over the given TREE, which represents a
4267    piece of a va_arg() expansion.  */
4268 tree
4269 build_va_arg_indirect_ref (tree addr)
4270 {
4271   addr = build_fold_indirect_ref (addr);
4272
4273   if (flag_mudflap) /* Don't instrument va_arg INDIRECT_REF.  */
4274     mf_mark (addr);
4275
4276   return addr;
4277 }
4278
4279 /* Return a dummy expression of type TYPE in order to keep going after an
4280    error.  */
4281
4282 static tree
4283 dummy_object (tree type)
4284 {
4285   tree t = convert (build_pointer_type (type), null_pointer_node);
4286   return build1 (INDIRECT_REF, type, t);
4287 }
4288
4289 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4290    builtin function, but a very special sort of operator.  */
4291
4292 enum gimplify_status
4293 gimplify_va_arg_expr (tree *expr_p, tree *pre_p, tree *post_p)
4294 {
4295   tree promoted_type, want_va_type, have_va_type;
4296   tree valist = TREE_OPERAND (*expr_p, 0);
4297   tree type = TREE_TYPE (*expr_p);
4298   tree t;
4299
4300   /* Verify that valist is of the proper type.  */
4301   want_va_type = va_list_type_node;
4302   have_va_type = TREE_TYPE (valist);
4303
4304   if (have_va_type == error_mark_node)
4305     return GS_ERROR;
4306
4307   if (TREE_CODE (want_va_type) == ARRAY_TYPE)
4308     {
4309       /* If va_list is an array type, the argument may have decayed
4310          to a pointer type, e.g. by being passed to another function.
4311          In that case, unwrap both types so that we can compare the
4312          underlying records.  */
4313       if (TREE_CODE (have_va_type) == ARRAY_TYPE
4314           || POINTER_TYPE_P (have_va_type))
4315         {
4316           want_va_type = TREE_TYPE (want_va_type);
4317           have_va_type = TREE_TYPE (have_va_type);
4318         }
4319     }
4320
4321   if (TYPE_MAIN_VARIANT (want_va_type) != TYPE_MAIN_VARIANT (have_va_type))
4322     {
4323       error ("first argument to %<va_arg%> not of type %<va_list%>");
4324       return GS_ERROR;
4325     }
4326
4327   /* Generate a diagnostic for requesting data of a type that cannot
4328      be passed through `...' due to type promotion at the call site.  */
4329   else if ((promoted_type = lang_hooks.types.type_promotes_to (type))
4330            != type)
4331     {
4332       static bool gave_help;
4333
4334       /* Unfortunately, this is merely undefined, rather than a constraint
4335          violation, so we cannot make this an error.  If this call is never
4336          executed, the program is still strictly conforming.  */
4337       warning (0, "%qT is promoted to %qT when passed through %<...%>",
4338                type, promoted_type);
4339       if (! gave_help)
4340         {
4341           gave_help = true;
4342           warning (0, "(so you should pass %qT not %qT to %<va_arg%>)",
4343                    promoted_type, type);
4344         }
4345
4346       /* We can, however, treat "undefined" any way we please.
4347          Call abort to encourage the user to fix the program.  */
4348       inform ("if this code is reached, the program will abort");
4349       t = build_function_call_expr (implicit_built_in_decls[BUILT_IN_TRAP],
4350                                     NULL);
4351       append_to_statement_list (t, pre_p);
4352
4353       /* This is dead code, but go ahead and finish so that the
4354          mode of the result comes out right.  */
4355       *expr_p = dummy_object (type);
4356       return GS_ALL_DONE;
4357     }
4358   else
4359     {
4360       /* Make it easier for the backends by protecting the valist argument
4361          from multiple evaluations.  */
4362       if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
4363         {
4364           /* For this case, the backends will be expecting a pointer to
4365              TREE_TYPE (va_list_type_node), but it's possible we've
4366              actually been given an array (an actual va_list_type_node).
4367              So fix it.  */
4368           if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4369             {
4370               tree p1 = build_pointer_type (TREE_TYPE (va_list_type_node));
4371               valist = build_fold_addr_expr_with_type (valist, p1);
4372             }
4373           gimplify_expr (&valist, pre_p, post_p, is_gimple_val, fb_rvalue);
4374         }
4375       else
4376         gimplify_expr (&valist, pre_p, post_p, is_gimple_min_lval, fb_lvalue);
4377
4378       if (!targetm.gimplify_va_arg_expr)
4379         /* FIXME:Once most targets are converted we should merely
4380            assert this is non-null.  */
4381         return GS_ALL_DONE;
4382
4383       *expr_p = targetm.gimplify_va_arg_expr (valist, type, pre_p, post_p);
4384       return GS_OK;
4385     }
4386 }
4387
4388 /* Expand ARGLIST, from a call to __builtin_va_end.  */
4389
4390 static rtx
4391 expand_builtin_va_end (tree arglist)
4392 {
4393   tree valist = TREE_VALUE (arglist);
4394
4395   /* Evaluate for side effects, if needed.  I hate macros that don't
4396      do that.  */
4397   if (TREE_SIDE_EFFECTS (valist))
4398     expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
4399
4400   return const0_rtx;
4401 }
4402
4403 /* Expand ARGLIST, from a call to __builtin_va_copy.  We do this as a
4404    builtin rather than just as an assignment in stdarg.h because of the
4405    nastiness of array-type va_list types.  */
4406
4407 static rtx
4408 expand_builtin_va_copy (tree arglist)
4409 {
4410   tree dst, src, t;
4411
4412   dst = TREE_VALUE (arglist);
4413   src = TREE_VALUE (TREE_CHAIN (arglist));
4414
4415   dst = stabilize_va_list (dst, 1);
4416   src = stabilize_va_list (src, 0);
4417
4418   if (TREE_CODE (va_list_type_node) != ARRAY_TYPE)
4419     {
4420       t = build2 (MODIFY_EXPR, va_list_type_node, dst, src);
4421       TREE_SIDE_EFFECTS (t) = 1;
4422       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4423     }
4424   else
4425     {
4426       rtx dstb, srcb, size;
4427
4428       /* Evaluate to pointers.  */
4429       dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
4430       srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
4431       size = expand_expr (TYPE_SIZE_UNIT (va_list_type_node), NULL_RTX,
4432                           VOIDmode, EXPAND_NORMAL);
4433
4434       dstb = convert_memory_address (Pmode, dstb);
4435       srcb = convert_memory_address (Pmode, srcb);
4436
4437       /* "Dereference" to BLKmode memories.  */
4438       dstb = gen_rtx_MEM (BLKmode, dstb);
4439       set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
4440       set_mem_align (dstb, TYPE_ALIGN (va_list_type_node));
4441       srcb = gen_rtx_MEM (BLKmode, srcb);
4442       set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
4443       set_mem_align (srcb, TYPE_ALIGN (va_list_type_node));
4444
4445       /* Copy.  */
4446       emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
4447     }
4448
4449   return const0_rtx;
4450 }
4451
4452 /* Expand a call to one of the builtin functions __builtin_frame_address or
4453    __builtin_return_address.  */
4454
4455 static rtx
4456 expand_builtin_frame_address (tree fndecl, tree arglist)
4457 {
4458   /* The argument must be a nonnegative integer constant.
4459      It counts the number of frames to scan up the stack.
4460      The value is the return address saved in that frame.  */
4461   if (arglist == 0)
4462     /* Warning about missing arg was already issued.  */
4463     return const0_rtx;
4464   else if (! host_integerp (TREE_VALUE (arglist), 1))
4465     {
4466       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4467         error ("invalid argument to %<__builtin_frame_address%>");
4468       else
4469         error ("invalid argument to %<__builtin_return_address%>");
4470       return const0_rtx;
4471     }
4472   else
4473     {
4474       rtx tem
4475         = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
4476                                       tree_low_cst (TREE_VALUE (arglist), 1));
4477
4478       /* Some ports cannot access arbitrary stack frames.  */
4479       if (tem == NULL)
4480         {
4481           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4482             warning (0, "unsupported argument to %<__builtin_frame_address%>");
4483           else
4484             warning (0, "unsupported argument to %<__builtin_return_address%>");
4485           return const0_rtx;
4486         }
4487
4488       /* For __builtin_frame_address, return what we've got.  */
4489       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4490         return tem;
4491
4492       if (!REG_P (tem)
4493           && ! CONSTANT_P (tem))
4494         tem = copy_to_mode_reg (Pmode, tem);
4495       return tem;
4496     }
4497 }
4498
4499 /* Expand a call to the alloca builtin, with arguments ARGLIST.  Return 0 if
4500    we failed and the caller should emit a normal call, otherwise try to get
4501    the result in TARGET, if convenient.  */
4502
4503 static rtx
4504 expand_builtin_alloca (tree arglist, rtx target)
4505 {
4506   rtx op0;
4507   rtx result;
4508
4509   /* In -fmudflap-instrumented code, alloca() and __builtin_alloca()
4510      should always expand to function calls.  These can be intercepted
4511      in libmudflap.  */
4512   if (flag_mudflap)
4513     return 0;
4514
4515   if (!validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
4516     return 0;
4517
4518   /* Compute the argument.  */
4519   op0 = expand_expr (TREE_VALUE (arglist), NULL_RTX, VOIDmode, 0);
4520
4521   /* Allocate the desired space.  */
4522   result = allocate_dynamic_stack_space (op0, target, BITS_PER_UNIT);
4523   result = convert_memory_address (ptr_mode, result);
4524
4525   return result;
4526 }
4527
4528 /* Expand a call to a unary builtin.  The arguments are in ARGLIST.
4529    Return 0 if a normal call should be emitted rather than expanding the
4530    function in-line.  If convenient, the result should be placed in TARGET.
4531    SUBTARGET may be used as the target for computing one of EXP's operands.  */
4532
4533 static rtx
4534 expand_builtin_unop (enum machine_mode target_mode, tree arglist, rtx target,
4535                      rtx subtarget, optab op_optab)
4536 {
4537   rtx op0;
4538   if (!validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
4539     return 0;
4540
4541   /* Compute the argument.  */
4542   op0 = expand_expr (TREE_VALUE (arglist), subtarget, VOIDmode, 0);
4543   /* Compute op, into TARGET if possible.
4544      Set TARGET to wherever the result comes back.  */
4545   target = expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist))),
4546                         op_optab, op0, target, 1);
4547   gcc_assert (target);
4548
4549   return convert_to_mode (target_mode, target, 0);
4550 }
4551
4552 /* If the string passed to fputs is a constant and is one character
4553    long, we attempt to transform this call into __builtin_fputc().  */
4554
4555 static rtx
4556 expand_builtin_fputs (tree arglist, rtx target, bool unlocked)
4557 {
4558   /* Verify the arguments in the original call.  */
4559   if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4560     {
4561       tree result = fold_builtin_fputs (arglist, (target == const0_rtx),
4562                                         unlocked, NULL_TREE);
4563       if (result)
4564         return expand_expr (result, target, VOIDmode, EXPAND_NORMAL);
4565     }
4566   return 0;
4567 }
4568
4569 /* Expand a call to __builtin_expect.  We return our argument and emit a
4570    NOTE_INSN_EXPECTED_VALUE note.  This is the expansion of __builtin_expect in
4571    a non-jump context.  */
4572
4573 static rtx
4574 expand_builtin_expect (tree arglist, rtx target)
4575 {
4576   tree exp, c;
4577   rtx note, rtx_c;
4578
4579   if (arglist == NULL_TREE
4580       || TREE_CHAIN (arglist) == NULL_TREE)
4581     return const0_rtx;
4582   exp = TREE_VALUE (arglist);
4583   c = TREE_VALUE (TREE_CHAIN (arglist));
4584
4585   if (TREE_CODE (c) != INTEGER_CST)
4586     {
4587       error ("second argument to %<__builtin_expect%> must be a constant");
4588       c = integer_zero_node;
4589     }
4590
4591   target = expand_expr (exp, target, VOIDmode, EXPAND_NORMAL);
4592
4593   /* Don't bother with expected value notes for integral constants.  */
4594   if (flag_guess_branch_prob && GET_CODE (target) != CONST_INT)
4595     {
4596       /* We do need to force this into a register so that we can be
4597          moderately sure to be able to correctly interpret the branch
4598          condition later.  */
4599       target = force_reg (GET_MODE (target), target);
4600
4601       rtx_c = expand_expr (c, NULL_RTX, GET_MODE (target), EXPAND_NORMAL);
4602
4603       note = emit_note (NOTE_INSN_EXPECTED_VALUE);
4604       NOTE_EXPECTED_VALUE (note) = gen_rtx_EQ (VOIDmode, target, rtx_c);
4605     }
4606
4607   return target;
4608 }
4609
4610 /* Like expand_builtin_expect, except do this in a jump context.  This is
4611    called from do_jump if the conditional is a __builtin_expect.  Return either
4612    a list of insns to emit the jump or NULL if we cannot optimize
4613    __builtin_expect.  We need to optimize this at jump time so that machines
4614    like the PowerPC don't turn the test into a SCC operation, and then jump
4615    based on the test being 0/1.  */
4616
4617 rtx
4618 expand_builtin_expect_jump (tree exp, rtx if_false_label, rtx if_true_label)
4619 {
4620   tree arglist = TREE_OPERAND (exp, 1);
4621   tree arg0 = TREE_VALUE (arglist);
4622   tree arg1 = TREE_VALUE (TREE_CHAIN (arglist));
4623   rtx ret = NULL_RTX;
4624
4625   /* Only handle __builtin_expect (test, 0) and
4626      __builtin_expect (test, 1).  */
4627   if (TREE_CODE (TREE_TYPE (arg1)) == INTEGER_TYPE
4628       && (integer_zerop (arg1) || integer_onep (arg1)))
4629     {
4630       rtx insn, drop_through_label, temp;
4631
4632       /* Expand the jump insns.  */
4633       start_sequence ();
4634       do_jump (arg0, if_false_label, if_true_label);
4635       ret = get_insns ();
4636
4637       drop_through_label = get_last_insn ();
4638       if (drop_through_label && NOTE_P (drop_through_label))
4639         drop_through_label = prev_nonnote_insn (drop_through_label);
4640       if (drop_through_label && !LABEL_P (drop_through_label))
4641         drop_through_label = NULL_RTX;
4642       end_sequence ();
4643
4644       if (! if_true_label)
4645         if_true_label = drop_through_label;
4646       if (! if_false_label)
4647         if_false_label = drop_through_label;
4648
4649       /* Go through and add the expect's to each of the conditional jumps.  */
4650       insn = ret;
4651       while (insn != NULL_RTX)
4652         {
4653           rtx next = NEXT_INSN (insn);
4654
4655           if (JUMP_P (insn) && any_condjump_p (insn))
4656             {
4657               rtx ifelse = SET_SRC (pc_set (insn));
4658               rtx then_dest = XEXP (ifelse, 1);
4659               rtx else_dest = XEXP (ifelse, 2);
4660               int taken = -1;
4661
4662               /* First check if we recognize any of the labels.  */
4663               if (GET_CODE (then_dest) == LABEL_REF
4664                   && XEXP (then_dest, 0) == if_true_label)
4665                 taken = 1;
4666               else if (GET_CODE (then_dest) == LABEL_REF
4667                        && XEXP (then_dest, 0) == if_false_label)
4668                 taken = 0;
4669               else if (GET_CODE (else_dest) == LABEL_REF
4670                        && XEXP (else_dest, 0) == if_false_label)
4671                 taken = 1;
4672               else if (GET_CODE (else_dest) == LABEL_REF
4673                        && XEXP (else_dest, 0) == if_true_label)
4674                 taken = 0;
4675               /* Otherwise check where we drop through.  */
4676               else if (else_dest == pc_rtx)
4677                 {
4678                   if (next && NOTE_P (next))
4679                     next = next_nonnote_insn (next);
4680
4681                   if (next && JUMP_P (next)
4682                       && any_uncondjump_p (next))
4683                     temp = XEXP (SET_SRC (pc_set (next)), 0);
4684                   else
4685                     temp = next;
4686
4687                   /* TEMP is either a CODE_LABEL, NULL_RTX or something
4688                      else that can't possibly match either target label.  */
4689                   if (temp == if_false_label)
4690                     taken = 1;
4691                   else if (temp == if_true_label)
4692                     taken = 0;
4693                 }
4694               else if (then_dest == pc_rtx)
4695                 {
4696                   if (next && NOTE_P (next))
4697                     next = next_nonnote_insn (next);
4698
4699                   if (next && JUMP_P (next)
4700                       && any_uncondjump_p (next))
4701                     temp = XEXP (SET_SRC (pc_set (next)), 0);
4702                   else
4703                     temp = next;
4704
4705                   if (temp == if_false_label)
4706                     taken = 0;
4707                   else if (temp == if_true_label)
4708                     taken = 1;
4709                 }
4710
4711               if (taken != -1)
4712                 {
4713                   /* If the test is expected to fail, reverse the
4714                      probabilities.  */
4715                   if (integer_zerop (arg1))
4716                     taken = 1 - taken;
4717                   predict_insn_def (insn, PRED_BUILTIN_EXPECT, taken);
4718                 }
4719             }
4720
4721           insn = next;
4722         }
4723     }
4724
4725   return ret;
4726 }
4727
4728 void
4729 expand_builtin_trap (void)
4730 {
4731 #ifdef HAVE_trap
4732   if (HAVE_trap)
4733     emit_insn (gen_trap ());
4734   else
4735 #endif
4736     emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
4737   emit_barrier ();
4738 }
4739
4740 /* Expand a call to fabs, fabsf or fabsl with arguments ARGLIST.
4741    Return 0 if a normal call should be emitted rather than expanding
4742    the function inline.  If convenient, the result should be placed
4743    in TARGET.  SUBTARGET may be used as the target for computing
4744    the operand.  */
4745
4746 static rtx
4747 expand_builtin_fabs (tree arglist, rtx target, rtx subtarget)
4748 {
4749   enum machine_mode mode;
4750   tree arg;
4751   rtx op0;
4752
4753   if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
4754     return 0;
4755
4756   arg = TREE_VALUE (arglist);
4757   mode = TYPE_MODE (TREE_TYPE (arg));
4758   op0 = expand_expr (arg, subtarget, VOIDmode, 0);
4759   return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
4760 }
4761
4762 /* Expand a call to copysign, copysignf, or copysignl with arguments ARGLIST.
4763    Return NULL is a normal call should be emitted rather than expanding the
4764    function inline.  If convenient, the result should be placed in TARGET.
4765    SUBTARGET may be used as the target for computing the operand.  */
4766
4767 static rtx
4768 expand_builtin_copysign (tree arglist, rtx target, rtx subtarget)
4769 {
4770   rtx op0, op1;
4771   tree arg;
4772
4773   if (!validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
4774     return 0;
4775
4776   arg = TREE_VALUE (arglist);
4777   op0 = expand_expr (arg, subtarget, VOIDmode, 0);
4778
4779   arg = TREE_VALUE (TREE_CHAIN (arglist));
4780   op1 = expand_expr (arg, NULL, VOIDmode, 0);
4781
4782   return expand_copysign (op0, op1, target);
4783 }
4784
4785 /* Create a new constant string literal and return a char* pointer to it.
4786    The STRING_CST value is the LEN characters at STR.  */
4787 tree
4788 build_string_literal (int len, const char *str)
4789 {
4790   tree t, elem, index, type;
4791
4792   t = build_string (len, str);
4793   elem = build_type_variant (char_type_node, 1, 0);
4794   index = build_index_type (build_int_cst (NULL_TREE, len - 1));
4795   type = build_array_type (elem, index);
4796   TREE_TYPE (t) = type;
4797   TREE_CONSTANT (t) = 1;
4798   TREE_INVARIANT (t) = 1;
4799   TREE_READONLY (t) = 1;
4800   TREE_STATIC (t) = 1;
4801
4802   type = build_pointer_type (type);
4803   t = build1 (ADDR_EXPR, type, t);
4804
4805   type = build_pointer_type (elem);
4806   t = build1 (NOP_EXPR, type, t);
4807   return t;
4808 }
4809
4810 /* Expand EXP, a call to printf or printf_unlocked.
4811    Return 0 if a normal call should be emitted rather than transforming
4812    the function inline.  If convenient, the result should be placed in
4813    TARGET with mode MODE.  UNLOCKED indicates this is a printf_unlocked
4814    call.  */
4815 static rtx
4816 expand_builtin_printf (tree exp, rtx target, enum machine_mode mode,
4817                        bool unlocked)
4818 {
4819   tree arglist = TREE_OPERAND (exp, 1);
4820   /* If we're using an unlocked function, assume the other unlocked
4821      functions exist explicitly.  */
4822   tree const fn_putchar = unlocked ? built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED]
4823     : implicit_built_in_decls[BUILT_IN_PUTCHAR];
4824   tree const fn_puts = unlocked ? built_in_decls[BUILT_IN_PUTS_UNLOCKED]
4825     : implicit_built_in_decls[BUILT_IN_PUTS];
4826   const char *fmt_str;
4827   tree fn, fmt, arg;
4828
4829   /* If the return value is used, don't do the transformation.  */
4830   if (target != const0_rtx)
4831     return 0;
4832
4833   /* Verify the required arguments in the original call.  */
4834   if (! arglist)
4835     return 0;
4836   fmt = TREE_VALUE (arglist);
4837   if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
4838     return 0;
4839   arglist = TREE_CHAIN (arglist);
4840
4841   /* Check whether the format is a literal string constant.  */
4842   fmt_str = c_getstr (fmt);
4843   if (fmt_str == NULL)
4844     return 0;
4845
4846   if (!init_target_chars())
4847     return 0;
4848
4849   /* If the format specifier was "%s\n", call __builtin_puts(arg).  */
4850   if (strcmp (fmt_str, target_percent_s_newline) == 0)
4851     {
4852       if (! arglist
4853           || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist)))
4854           || TREE_CHAIN (arglist))
4855         return 0;
4856       fn = fn_puts;
4857     }
4858   /* If the format specifier was "%c", call __builtin_putchar(arg).  */
4859   else if (strcmp (fmt_str, target_percent_c) == 0)
4860     {
4861       if (! arglist
4862           || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE
4863           || TREE_CHAIN (arglist))
4864         return 0;
4865       fn = fn_putchar;
4866     }
4867   else
4868     {
4869       /* We can't handle anything else with % args or %% ... yet.  */
4870       if (strchr (fmt_str, target_percent))
4871         return 0;
4872
4873       if (arglist)
4874         return 0;
4875
4876       /* If the format specifier was "", printf does nothing.  */
4877       if (fmt_str[0] == '\0')
4878         return const0_rtx;
4879       /* If the format specifier has length of 1, call putchar.  */
4880       if (fmt_str[1] == '\0')
4881         {
4882           /* Given printf("c"), (where c is any one character,)
4883              convert "c"[0] to an int and pass that to the replacement
4884              function.  */
4885           arg = build_int_cst (NULL_TREE, fmt_str[0]);
4886           arglist = build_tree_list (NULL_TREE, arg);
4887           fn = fn_putchar;
4888         }
4889       else
4890         {
4891           /* If the format specifier was "string\n", call puts("string").  */
4892           size_t len = strlen (fmt_str);
4893           if ((unsigned char)fmt_str[len - 1] == target_newline)
4894             {
4895               /* Create a NUL-terminated string that's one char shorter
4896                  than the original, stripping off the trailing '\n'.  */
4897               char *newstr = alloca (len);
4898               memcpy (newstr, fmt_str, len - 1);
4899               newstr[len - 1] = 0;
4900
4901               arg = build_string_literal (len, newstr);
4902               arglist = build_tree_list (NULL_TREE, arg);
4903               fn = fn_puts;
4904             }
4905           else
4906             /* We'd like to arrange to call fputs(string,stdout) here,
4907                but we need stdout and don't have a way to get it yet.  */
4908             return 0;
4909         }
4910     }
4911
4912   if (!fn)
4913     return 0;
4914   fn = build_function_call_expr (fn, arglist);
4915   if (TREE_CODE (fn) == CALL_EXPR)
4916     CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4917   return expand_expr (fn, target, mode, EXPAND_NORMAL);
4918 }
4919
4920 /* Expand EXP, a call to fprintf or fprintf_unlocked.
4921    Return 0 if a normal call should be emitted rather than transforming
4922    the function inline.  If convenient, the result should be placed in
4923    TARGET with mode MODE.  UNLOCKED indicates this is a fprintf_unlocked
4924    call.  */
4925 static rtx
4926 expand_builtin_fprintf (tree exp, rtx target, enum machine_mode mode,
4927                         bool unlocked)
4928 {
4929   tree arglist = TREE_OPERAND (exp, 1);
4930   /* If we're using an unlocked function, assume the other unlocked
4931      functions exist explicitly.  */
4932   tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
4933     : implicit_built_in_decls[BUILT_IN_FPUTC];
4934   tree const fn_fputs = unlocked ? built_in_decls[BUILT_IN_FPUTS_UNLOCKED]
4935     : implicit_built_in_decls[BUILT_IN_FPUTS];
4936   const char *fmt_str;
4937   tree fn, fmt, fp, arg;
4938
4939   /* If the return value is used, don't do the transformation.  */
4940   if (target != const0_rtx)
4941     return 0;
4942
4943   /* Verify the required arguments in the original call.  */
4944   if (! arglist)
4945     return 0;
4946   fp = TREE_VALUE (arglist);
4947   if (! POINTER_TYPE_P (TREE_TYPE (fp)))
4948     return 0;
4949   arglist = TREE_CHAIN (arglist);
4950   if (! arglist)
4951     return 0;
4952   fmt = TREE_VALUE (arglist);
4953   if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
4954     return 0;
4955   arglist = TREE_CHAIN (arglist);
4956
4957   /* Check whether the format is a literal string constant.  */
4958   fmt_str = c_getstr (fmt);
4959   if (fmt_str == NULL)
4960     return 0;
4961
4962   if (!init_target_chars())
4963     return 0;
4964
4965   /* If the format specifier was "%s", call __builtin_fputs(arg,fp).  */
4966   if (strcmp (fmt_str, target_percent_s) == 0)
4967     {
4968       if (! arglist
4969           || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist)))
4970           || TREE_CHAIN (arglist))
4971         return 0;
4972       arg = TREE_VALUE (arglist);
4973       arglist = build_tree_list (NULL_TREE, fp);
4974       arglist = tree_cons (NULL_TREE, arg, arglist);
4975       fn = fn_fputs;
4976     }
4977   /* If the format specifier was "%c", call __builtin_fputc(arg,fp).  */
4978   else if (strcmp (fmt_str, target_percent_c) == 0)
4979     {
4980       if (! arglist
4981           || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE
4982           || TREE_CHAIN (arglist))
4983         return 0;
4984       arg = TREE_VALUE (arglist);
4985       arglist = build_tree_list (NULL_TREE, fp);
4986       arglist = tree_cons (NULL_TREE, arg, arglist);
4987       fn = fn_fputc;
4988     }
4989   else
4990     {
4991       /* We can't handle anything else with % args or %% ... yet.  */
4992       if (strchr (fmt_str, target_percent))
4993         return 0;
4994
4995       if (arglist)
4996         return 0;
4997
4998       /* If the format specifier was "", fprintf does nothing.  */
4999       if (fmt_str[0] == '\0')
5000         {
5001           /* Evaluate and ignore FILE* argument for side-effects.  */
5002           expand_expr (fp, const0_rtx, VOIDmode, EXPAND_NORMAL);
5003           return const0_rtx;
5004         }
5005
5006       /* When "string" doesn't contain %, replace all cases of
5007          fprintf(stream,string) with fputs(string,stream).  The fputs
5008          builtin will take care of special cases like length == 1.  */
5009       arglist = build_tree_list (NULL_TREE, fp);
5010       arglist = tree_cons (NULL_TREE, fmt, arglist);
5011       fn = fn_fputs;
5012     }
5013
5014   if (!fn)
5015     return 0;
5016   fn = build_function_call_expr (fn, arglist);
5017   if (TREE_CODE (fn) == CALL_EXPR)
5018     CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
5019   return expand_expr (fn, target, mode, EXPAND_NORMAL);
5020 }
5021
5022 /* Expand a call to sprintf with argument list ARGLIST.  Return 0 if
5023    a normal call should be emitted rather than expanding the function
5024    inline.  If convenient, the result should be placed in TARGET with
5025    mode MODE.  */
5026
5027 static rtx
5028 expand_builtin_sprintf (tree arglist, rtx target, enum machine_mode mode)
5029 {
5030   tree orig_arglist, dest, fmt;
5031   const char *fmt_str;
5032
5033   orig_arglist = arglist;
5034
5035   /* Verify the required arguments in the original call.  */
5036   if (! arglist)
5037     return 0;
5038   dest = TREE_VALUE (arglist);
5039   if (! POINTER_TYPE_P (TREE_TYPE (dest)))
5040     return 0;
5041   arglist = TREE_CHAIN (arglist);
5042   if (! arglist)
5043     return 0;
5044   fmt = TREE_VALUE (arglist);
5045   if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
5046     return 0;
5047   arglist = TREE_CHAIN (arglist);
5048
5049   /* Check whether the format is a literal string constant.  */
5050   fmt_str = c_getstr (fmt);
5051   if (fmt_str == NULL)
5052     return 0;
5053
5054   if (!init_target_chars())
5055     return 0;
5056
5057   /* If the format doesn't contain % args or %%, use strcpy.  */
5058   if (strchr (fmt_str, target_percent) == 0)
5059     {
5060       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
5061       tree exp;
5062
5063       if (arglist || ! fn)
5064         return 0;
5065       expand_expr (build_function_call_expr (fn, orig_arglist),
5066                    const0_rtx, VOIDmode, EXPAND_NORMAL);
5067       if (target == const0_rtx)
5068         return const0_rtx;
5069       exp = build_int_cst (NULL_TREE, strlen (fmt_str));
5070       return expand_expr (exp, target, mode, EXPAND_NORMAL);
5071     }
5072   /* If the format is "%s", use strcpy if the result isn't used.  */
5073   else if (strcmp (fmt_str, target_percent_s) == 0)
5074     {
5075       tree fn, arg, len;
5076       fn = implicit_built_in_decls[BUILT_IN_STRCPY];
5077
5078       if (! fn)
5079         return 0;
5080
5081       if (! arglist || TREE_CHAIN (arglist))
5082         return 0;
5083       arg = TREE_VALUE (arglist);
5084       if (! POINTER_TYPE_P (TREE_TYPE (arg)))
5085         return 0;
5086
5087       if (target != const0_rtx)
5088         {
5089           len = c_strlen (arg, 1);
5090           if (! len || TREE_CODE (len) != INTEGER_CST)
5091             return 0;
5092         }
5093       else
5094         len = NULL_TREE;
5095
5096       arglist = build_tree_list (NULL_TREE, arg);
5097       arglist = tree_cons (NULL_TREE, dest, arglist);
5098       expand_expr (build_function_call_expr (fn, arglist),
5099                    const0_rtx, VOIDmode, EXPAND_NORMAL);
5100
5101       if (target == const0_rtx)
5102         return const0_rtx;
5103       return expand_expr (len, target, mode, EXPAND_NORMAL);
5104     }
5105
5106   return 0;
5107 }
5108
5109 /* Expand a call to either the entry or exit function profiler.  */
5110
5111 static rtx
5112 expand_builtin_profile_func (bool exitp)
5113 {
5114   rtx this, which;
5115
5116   this = DECL_RTL (current_function_decl);
5117   gcc_assert (MEM_P (this));
5118   this = XEXP (this, 0);
5119
5120   if (exitp)
5121     which = profile_function_exit_libfunc;
5122   else
5123     which = profile_function_entry_libfunc;
5124
5125   emit_library_call (which, LCT_NORMAL, VOIDmode, 2, this, Pmode,
5126                      expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
5127                                                  0),
5128                      Pmode);
5129
5130   return const0_rtx;
5131 }
5132
5133 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT.  */
5134
5135 static rtx
5136 round_trampoline_addr (rtx tramp)
5137 {
5138   rtx temp, addend, mask;
5139
5140   /* If we don't need too much alignment, we'll have been guaranteed
5141      proper alignment by get_trampoline_type.  */
5142   if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY)
5143     return tramp;
5144
5145   /* Round address up to desired boundary.  */
5146   temp = gen_reg_rtx (Pmode);
5147   addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
5148   mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
5149
5150   temp  = expand_simple_binop (Pmode, PLUS, tramp, addend,
5151                                temp, 0, OPTAB_LIB_WIDEN);
5152   tramp = expand_simple_binop (Pmode, AND, temp, mask,
5153                                temp, 0, OPTAB_LIB_WIDEN);
5154
5155   return tramp;
5156 }
5157
5158 static rtx
5159 expand_builtin_init_trampoline (tree arglist)
5160 {
5161   tree t_tramp, t_func, t_chain;
5162   rtx r_tramp, r_func, r_chain;
5163 #ifdef TRAMPOLINE_TEMPLATE
5164   rtx blktramp;
5165 #endif
5166
5167   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE,
5168                          POINTER_TYPE, VOID_TYPE))
5169     return NULL_RTX;
5170
5171   t_tramp = TREE_VALUE (arglist);
5172   arglist = TREE_CHAIN (arglist);
5173   t_func = TREE_VALUE (arglist);
5174   arglist = TREE_CHAIN (arglist);
5175   t_chain = TREE_VALUE (arglist);
5176
5177   r_tramp = expand_expr (t_tramp, NULL_RTX, VOIDmode, 0);
5178   r_func = expand_expr (t_func, NULL_RTX, VOIDmode, 0);
5179   r_chain = expand_expr (t_chain, NULL_RTX, VOIDmode, 0);
5180
5181   /* Generate insns to initialize the trampoline.  */
5182   r_tramp = round_trampoline_addr (r_tramp);
5183 #ifdef TRAMPOLINE_TEMPLATE
5184   blktramp = gen_rtx_MEM (BLKmode, r_tramp);
5185   set_mem_align (blktramp, TRAMPOLINE_ALIGNMENT);
5186   emit_block_move (blktramp, assemble_trampoline_template (),
5187                    GEN_INT (TRAMPOLINE_SIZE), BLOCK_OP_NORMAL);
5188 #endif
5189   trampolines_created = 1;
5190   INITIALIZE_TRAMPOLINE (r_tramp, r_func, r_chain);
5191
5192   return const0_rtx;
5193 }
5194
5195 static rtx
5196 expand_builtin_adjust_trampoline (tree arglist)
5197 {
5198   rtx tramp;
5199
5200   if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
5201     return NULL_RTX;
5202
5203   tramp = expand_expr (TREE_VALUE (arglist), NULL_RTX, VOIDmode, 0);
5204   tramp = round_trampoline_addr (tramp);
5205 #ifdef TRAMPOLINE_ADJUST_ADDRESS
5206   TRAMPOLINE_ADJUST_ADDRESS (tramp);
5207 #endif
5208
5209   return tramp;
5210 }
5211
5212 /* Expand a call to the built-in signbit, signbitf or signbitl function.
5213    Return NULL_RTX if a normal call should be emitted rather than expanding
5214    the function in-line.  EXP is the expression that is a call to the builtin
5215    function; if convenient, the result should be placed in TARGET.  */
5216
5217 static rtx
5218 expand_builtin_signbit (tree exp, rtx target)
5219 {
5220   const struct real_format *fmt;
5221   enum machine_mode fmode, imode, rmode;
5222   HOST_WIDE_INT hi, lo;
5223   tree arg, arglist;
5224   int word, bitpos;
5225   rtx temp;
5226
5227   arglist = TREE_OPERAND (exp, 1);
5228   if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
5229     return 0;
5230
5231   arg = TREE_VALUE (arglist);
5232   fmode = TYPE_MODE (TREE_TYPE (arg));
5233   rmode = TYPE_MODE (TREE_TYPE (exp));
5234   fmt = REAL_MODE_FORMAT (fmode);
5235
5236   /* For floating point formats without a sign bit, implement signbit
5237      as "ARG < 0.0".  */
5238   bitpos = fmt->signbit_ro;
5239   if (bitpos < 0)
5240   {
5241     /* But we can't do this if the format supports signed zero.  */
5242     if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
5243       return 0;
5244
5245     arg = fold_build2 (LT_EXPR, TREE_TYPE (exp), arg,
5246                        build_real (TREE_TYPE (arg), dconst0));
5247     return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5248   }
5249
5250   temp = expand_expr (arg, NULL_RTX, VOIDmode, 0);
5251   if (GET_MODE_SIZE (fmode) <= UNITS_PER_WORD)
5252     {
5253       imode = int_mode_for_mode (fmode);
5254       if (imode == BLKmode)
5255         return 0;
5256       temp = gen_lowpart (imode, temp);
5257     }
5258   else
5259     {
5260       imode = word_mode;
5261       /* Handle targets with different FP word orders.  */
5262       if (FLOAT_WORDS_BIG_ENDIAN)
5263         word = (GET_MODE_BITSIZE (fmode) - bitpos) / BITS_PER_WORD;
5264       else
5265         word = bitpos / BITS_PER_WORD;
5266       temp = operand_subword_force (temp, word, fmode);
5267       bitpos = bitpos % BITS_PER_WORD;
5268     }
5269
5270   /* Force the intermediate word_mode (or narrower) result into a
5271      register.  This avoids attempting to create paradoxical SUBREGs
5272      of floating point modes below.  */
5273   temp = force_reg (imode, temp);
5274
5275   /* If the bitpos is within the "result mode" lowpart, the operation
5276      can be implement with a single bitwise AND.  Otherwise, we need
5277      a right shift and an AND.  */
5278
5279   if (bitpos < GET_MODE_BITSIZE (rmode))
5280     {
5281       if (bitpos < HOST_BITS_PER_WIDE_INT)
5282         {
5283           hi = 0;
5284           lo = (HOST_WIDE_INT) 1 << bitpos;
5285         }
5286       else
5287         {
5288           hi = (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT);
5289           lo = 0;
5290         }
5291
5292       if (imode != rmode)
5293         temp = gen_lowpart (rmode, temp);
5294       temp = expand_binop (rmode, and_optab, temp,
5295                            immed_double_const (lo, hi, rmode),
5296                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
5297     }
5298   else
5299     {
5300       /* Perform a logical right shift to place the signbit in the least
5301          significant bit, then truncate the result to the desired mode
5302          and mask just this bit.  */
5303       temp = expand_shift (RSHIFT_EXPR, imode, temp,
5304                            build_int_cst (NULL_TREE, bitpos), NULL_RTX, 1);
5305       temp = gen_lowpart (rmode, temp);
5306       temp = expand_binop (rmode, and_optab, temp, const1_rtx,
5307                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
5308     }
5309
5310   return temp;
5311 }
5312
5313 /* Expand fork or exec calls.  TARGET is the desired target of the
5314    call.  ARGLIST is the list of arguments of the call.  FN is the
5315    identificator of the actual function.  IGNORE is nonzero if the
5316    value is to be ignored.  */
5317
5318 static rtx
5319 expand_builtin_fork_or_exec (tree fn, tree arglist, rtx target, int ignore)
5320 {
5321   tree id, decl;
5322   tree call;
5323
5324   /* If we are not profiling, just call the function.  */
5325   if (!profile_arc_flag)
5326     return NULL_RTX;
5327
5328   /* Otherwise call the wrapper.  This should be equivalent for the rest of
5329      compiler, so the code does not diverge, and the wrapper may run the
5330      code necessary for keeping the profiling sane.  */
5331
5332   switch (DECL_FUNCTION_CODE (fn))
5333     {
5334     case BUILT_IN_FORK:
5335       id = get_identifier ("__gcov_fork");
5336       break;
5337
5338     case BUILT_IN_EXECL:
5339       id = get_identifier ("__gcov_execl");
5340       break;
5341
5342     case BUILT_IN_EXECV:
5343       id = get_identifier ("__gcov_execv");
5344       break;
5345
5346     case BUILT_IN_EXECLP:
5347       id = get_identifier ("__gcov_execlp");
5348       break;
5349
5350     case BUILT_IN_EXECLE:
5351       id = get_identifier ("__gcov_execle");
5352       break;
5353
5354     case BUILT_IN_EXECVP:
5355       id = get_identifier ("__gcov_execvp");
5356       break;
5357
5358     case BUILT_IN_EXECVE:
5359       id = get_identifier ("__gcov_execve");
5360       break;
5361
5362     default:
5363       gcc_unreachable ();
5364     }
5365
5366   decl = build_decl (FUNCTION_DECL, id, TREE_TYPE (fn));
5367   DECL_EXTERNAL (decl) = 1;
5368   TREE_PUBLIC (decl) = 1;
5369   DECL_ARTIFICIAL (decl) = 1;
5370   TREE_NOTHROW (decl) = 1;
5371   call = build_function_call_expr (decl, arglist);
5372
5373   return expand_call (call, target, ignore);
5374 }
5375
5376 \f
5377 /* Reconstitute a mode for a __sync intrinsic operation.  Since the type of
5378    the pointer in these functions is void*, the tree optimizers may remove
5379    casts.  The mode computed in expand_builtin isn't reliable either, due
5380    to __sync_bool_compare_and_swap.
5381
5382    FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5383    group of builtins.  This gives us log2 of the mode size.  */
5384
5385 static inline enum machine_mode
5386 get_builtin_sync_mode (int fcode_diff)
5387 {
5388   /* The size is not negotiable, so ask not to get BLKmode in return
5389      if the target indicates that a smaller size would be better.  */
5390   return mode_for_size (BITS_PER_UNIT << fcode_diff, MODE_INT, 0);
5391 }
5392
5393 /* Expand the memory expression LOC and return the appropriate memory operand
5394    for the builtin_sync operations.  */
5395
5396 static rtx
5397 get_builtin_sync_mem (tree loc, enum machine_mode mode)
5398 {
5399   rtx addr, mem;
5400
5401   addr = expand_expr (loc, NULL, Pmode, EXPAND_SUM);
5402
5403   /* Note that we explicitly do not want any alias information for this
5404      memory, so that we kill all other live memories.  Otherwise we don't
5405      satisfy the full barrier semantics of the intrinsic.  */
5406   mem = validize_mem (gen_rtx_MEM (mode, addr));
5407
5408   set_mem_align (mem, get_pointer_alignment (loc, BIGGEST_ALIGNMENT));
5409   MEM_VOLATILE_P (mem) = 1;
5410
5411   return mem;
5412 }
5413
5414 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5415    ARGLIST is the operands list to the function.  CODE is the rtx code
5416    that corresponds to the arithmetic or logical operation from the name;
5417    an exception here is that NOT actually means NAND.  TARGET is an optional
5418    place for us to store the results; AFTER is true if this is the
5419    fetch_and_xxx form.  IGNORE is true if we don't actually care about
5420    the result of the operation at all.  */
5421
5422 static rtx
5423 expand_builtin_sync_operation (enum machine_mode mode, tree arglist,
5424                                enum rtx_code code, bool after,
5425                                rtx target, bool ignore)
5426 {
5427   rtx val, mem;
5428
5429   /* Expand the operands.  */
5430   mem = get_builtin_sync_mem (TREE_VALUE (arglist), mode);
5431
5432   arglist = TREE_CHAIN (arglist);
5433   val = expand_expr (TREE_VALUE (arglist), NULL, mode, EXPAND_NORMAL);
5434
5435   if (ignore)
5436     return expand_sync_operation (mem, val, code);
5437   else
5438     return expand_sync_fetch_operation (mem, val, code, after, target);
5439 }
5440
5441 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5442    intrinsics.  ARGLIST is the operands list to the function.  IS_BOOL is
5443    true if this is the boolean form.  TARGET is a place for us to store the
5444    results; this is NOT optional if IS_BOOL is true.  */
5445
5446 static rtx
5447 expand_builtin_compare_and_swap (enum machine_mode mode, tree arglist,
5448                                  bool is_bool, rtx target)
5449 {
5450   rtx old_val, new_val, mem;
5451
5452   /* Expand the operands.  */
5453   mem = get_builtin_sync_mem (TREE_VALUE (arglist), mode);
5454
5455   arglist = TREE_CHAIN (arglist);
5456   old_val = expand_expr (TREE_VALUE (arglist), NULL, mode, EXPAND_NORMAL);
5457
5458   arglist = TREE_CHAIN (arglist);
5459   new_val = expand_expr (TREE_VALUE (arglist), NULL, mode, EXPAND_NORMAL);
5460
5461   if (is_bool)
5462     return expand_bool_compare_and_swap (mem, old_val, new_val, target);
5463   else
5464     return expand_val_compare_and_swap (mem, old_val, new_val, target);
5465 }
5466
5467 /* Expand the __sync_lock_test_and_set intrinsic.  Note that the most
5468    general form is actually an atomic exchange, and some targets only
5469    support a reduced form with the second argument being a constant 1.
5470    ARGLIST is the operands list to the function; TARGET is an optional
5471    place for us to store the results.  */
5472
5473 static rtx
5474 expand_builtin_lock_test_and_set (enum machine_mode mode, tree arglist,
5475                                   rtx target)
5476 {
5477   rtx val, mem;
5478
5479   /* Expand the operands.  */
5480   mem = get_builtin_sync_mem (TREE_VALUE (arglist), mode);
5481
5482   arglist = TREE_CHAIN (arglist);
5483   val = expand_expr (TREE_VALUE (arglist), NULL, mode, EXPAND_NORMAL);
5484
5485   return expand_sync_lock_test_and_set (mem, val, target);
5486 }
5487
5488 /* Expand the __sync_synchronize intrinsic.  */
5489
5490 static void
5491 expand_builtin_synchronize (void)
5492 {
5493   tree x;
5494
5495 #ifdef HAVE_memory_barrier
5496   if (HAVE_memory_barrier)
5497     {
5498       emit_insn (gen_memory_barrier ());
5499       return;
5500     }
5501 #endif
5502
5503   /* If no explicit memory barrier instruction is available, create an
5504      empty asm stmt with a memory clobber.  */
5505   x = build4 (ASM_EXPR, void_type_node, build_string (0, ""), NULL, NULL,
5506               tree_cons (NULL, build_string (6, "memory"), NULL));
5507   ASM_VOLATILE_P (x) = 1;
5508   expand_asm_expr (x);
5509 }
5510
5511 /* Expand the __sync_lock_release intrinsic.  ARGLIST is the operands list
5512    to the function.  */
5513
5514 static void
5515 expand_builtin_lock_release (enum machine_mode mode, tree arglist)
5516 {
5517   enum insn_code icode;
5518   rtx mem, insn;
5519   rtx val = const0_rtx;
5520
5521   /* Expand the operands.  */
5522   mem = get_builtin_sync_mem (TREE_VALUE (arglist), mode);
5523
5524   /* If there is an explicit operation in the md file, use it.  */
5525   icode = sync_lock_release[mode];
5526   if (icode != CODE_FOR_nothing)
5527     {
5528       if (!insn_data[icode].operand[1].predicate (val, mode))
5529         val = force_reg (mode, val);
5530
5531       insn = GEN_FCN (icode) (mem, val);
5532       if (insn)
5533         {
5534           emit_insn (insn);
5535           return;
5536         }
5537     }
5538
5539   /* Otherwise we can implement this operation by emitting a barrier
5540      followed by a store of zero.  */
5541   expand_builtin_synchronize ();
5542   emit_move_insn (mem, val);
5543 }
5544 \f
5545 /* Expand an expression EXP that calls a built-in function,
5546    with result going to TARGET if that's convenient
5547    (and in mode MODE if that's convenient).
5548    SUBTARGET may be used as the target for computing one of EXP's operands.
5549    IGNORE is nonzero if the value is to be ignored.  */
5550
5551 rtx
5552 expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
5553                 int ignore)
5554 {
5555   tree fndecl = get_callee_fndecl (exp);
5556   tree arglist = TREE_OPERAND (exp, 1);
5557   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5558   enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
5559
5560   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
5561     return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
5562
5563   /* When not optimizing, generate calls to library functions for a certain
5564      set of builtins.  */
5565   if (!optimize
5566       && !called_as_built_in (fndecl)
5567       && DECL_ASSEMBLER_NAME_SET_P (fndecl)
5568       && fcode != BUILT_IN_ALLOCA)
5569     return expand_call (exp, target, ignore);
5570
5571   /* The built-in function expanders test for target == const0_rtx
5572      to determine whether the function's result will be ignored.  */
5573   if (ignore)
5574     target = const0_rtx;
5575
5576   /* If the result of a pure or const built-in function is ignored, and
5577      none of its arguments are volatile, we can avoid expanding the
5578      built-in call and just evaluate the arguments for side-effects.  */
5579   if (target == const0_rtx
5580       && (DECL_IS_PURE (fndecl) || TREE_READONLY (fndecl)))
5581     {
5582       bool volatilep = false;
5583       tree arg;
5584
5585       for (arg = arglist; arg; arg = TREE_CHAIN (arg))
5586         if (TREE_THIS_VOLATILE (TREE_VALUE (arg)))
5587           {
5588             volatilep = true;
5589             break;
5590           }
5591
5592       if (! volatilep)
5593         {
5594           for (arg = arglist; arg; arg = TREE_CHAIN (arg))
5595             expand_expr (TREE_VALUE (arg), const0_rtx,
5596                          VOIDmode, EXPAND_NORMAL);
5597           return const0_rtx;
5598         }
5599     }
5600
5601   switch (fcode)
5602     {
5603     CASE_FLT_FN (BUILT_IN_FABS):
5604       target = expand_builtin_fabs (arglist, target, subtarget);
5605       if (target)
5606         return target;
5607       break;
5608
5609     CASE_FLT_FN (BUILT_IN_COPYSIGN):
5610       target = expand_builtin_copysign (arglist, target, subtarget);
5611       if (target)
5612         return target;
5613       break;
5614
5615       /* Just do a normal library call if we were unable to fold
5616          the values.  */
5617     CASE_FLT_FN (BUILT_IN_CABS):
5618       break;
5619
5620     CASE_FLT_FN (BUILT_IN_EXP):
5621     CASE_FLT_FN (BUILT_IN_EXP10):
5622     CASE_FLT_FN (BUILT_IN_POW10):
5623     CASE_FLT_FN (BUILT_IN_EXP2):
5624     CASE_FLT_FN (BUILT_IN_EXPM1):
5625     CASE_FLT_FN (BUILT_IN_LOGB):
5626     CASE_FLT_FN (BUILT_IN_ILOGB):
5627     CASE_FLT_FN (BUILT_IN_LOG):
5628     CASE_FLT_FN (BUILT_IN_LOG10):
5629     CASE_FLT_FN (BUILT_IN_LOG2):
5630     CASE_FLT_FN (BUILT_IN_LOG1P):
5631     CASE_FLT_FN (BUILT_IN_TAN):
5632     CASE_FLT_FN (BUILT_IN_ASIN):
5633     CASE_FLT_FN (BUILT_IN_ACOS):
5634     CASE_FLT_FN (BUILT_IN_ATAN):
5635       /* Treat these like sqrt only if unsafe math optimizations are allowed,
5636          because of possible accuracy problems.  */
5637       if (! flag_unsafe_math_optimizations)
5638         break;
5639     CASE_FLT_FN (BUILT_IN_SQRT):
5640     CASE_FLT_FN (BUILT_IN_FLOOR):
5641     CASE_FLT_FN (BUILT_IN_CEIL):
5642     CASE_FLT_FN (BUILT_IN_TRUNC):
5643     CASE_FLT_FN (BUILT_IN_ROUND):
5644     CASE_FLT_FN (BUILT_IN_NEARBYINT):
5645     CASE_FLT_FN (BUILT_IN_RINT):
5646     CASE_FLT_FN (BUILT_IN_LRINT):
5647     CASE_FLT_FN (BUILT_IN_LLRINT):
5648       target = expand_builtin_mathfn (exp, target, subtarget);
5649       if (target)
5650         return target;
5651       break;
5652
5653     CASE_FLT_FN (BUILT_IN_LCEIL):
5654     CASE_FLT_FN (BUILT_IN_LLCEIL):
5655     CASE_FLT_FN (BUILT_IN_LFLOOR):
5656     CASE_FLT_FN (BUILT_IN_LLFLOOR):
5657       target = expand_builtin_int_roundingfn (exp, target, subtarget);
5658       if (target)
5659         return target;
5660       break;
5661
5662     CASE_FLT_FN (BUILT_IN_POW):
5663       target = expand_builtin_pow (exp, target, subtarget);
5664       if (target)
5665         return target;
5666       break;
5667
5668     CASE_FLT_FN (BUILT_IN_POWI):
5669       target = expand_builtin_powi (exp, target, subtarget);
5670       if (target)
5671         return target;
5672       break;
5673
5674     CASE_FLT_FN (BUILT_IN_ATAN2):
5675     CASE_FLT_FN (BUILT_IN_LDEXP):
5676     CASE_FLT_FN (BUILT_IN_FMOD):
5677     CASE_FLT_FN (BUILT_IN_DREM):
5678       if (! flag_unsafe_math_optimizations)
5679         break;
5680       target = expand_builtin_mathfn_2 (exp, target, subtarget);
5681       if (target)
5682         return target;
5683       break;
5684
5685     CASE_FLT_FN (BUILT_IN_SIN):
5686     CASE_FLT_FN (BUILT_IN_COS):
5687       if (! flag_unsafe_math_optimizations)
5688         break;
5689       target = expand_builtin_mathfn_3 (exp, target, subtarget);
5690       if (target)
5691         return target;
5692       break;
5693
5694     CASE_FLT_FN (BUILT_IN_SINCOS):
5695       if (! flag_unsafe_math_optimizations)
5696         break;
5697       target = expand_builtin_sincos (exp);
5698       if (target)
5699         return target;
5700       break;
5701
5702     case BUILT_IN_APPLY_ARGS:
5703       return expand_builtin_apply_args ();
5704
5705       /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5706          FUNCTION with a copy of the parameters described by
5707          ARGUMENTS, and ARGSIZE.  It returns a block of memory
5708          allocated on the stack into which is stored all the registers
5709          that might possibly be used for returning the result of a
5710          function.  ARGUMENTS is the value returned by
5711          __builtin_apply_args.  ARGSIZE is the number of bytes of
5712          arguments that must be copied.  ??? How should this value be
5713          computed?  We'll also need a safe worst case value for varargs
5714          functions.  */
5715     case BUILT_IN_APPLY:
5716       if (!validate_arglist (arglist, POINTER_TYPE,
5717                              POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
5718           && !validate_arglist (arglist, REFERENCE_TYPE,
5719                                 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
5720         return const0_rtx;
5721       else
5722         {
5723           int i;
5724           tree t;
5725           rtx ops[3];
5726
5727           for (t = arglist, i = 0; t; t = TREE_CHAIN (t), i++)
5728             ops[i] = expand_expr (TREE_VALUE (t), NULL_RTX, VOIDmode, 0);
5729
5730           return expand_builtin_apply (ops[0], ops[1], ops[2]);
5731         }
5732
5733       /* __builtin_return (RESULT) causes the function to return the
5734          value described by RESULT.  RESULT is address of the block of
5735          memory returned by __builtin_apply.  */
5736     case BUILT_IN_RETURN:
5737       if (validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
5738         expand_builtin_return (expand_expr (TREE_VALUE (arglist),
5739                                             NULL_RTX, VOIDmode, 0));
5740       return const0_rtx;
5741
5742     case BUILT_IN_SAVEREGS:
5743       return expand_builtin_saveregs ();
5744
5745     case BUILT_IN_ARGS_INFO:
5746       return expand_builtin_args_info (arglist);
5747
5748       /* Return the address of the first anonymous stack arg.  */
5749     case BUILT_IN_NEXT_ARG:
5750       if (fold_builtin_next_arg (arglist))
5751         return const0_rtx;
5752       return expand_builtin_next_arg ();
5753
5754     case BUILT_IN_CLASSIFY_TYPE:
5755       return expand_builtin_classify_type (arglist);
5756
5757     case BUILT_IN_CONSTANT_P:
5758       return const0_rtx;
5759
5760     case BUILT_IN_FRAME_ADDRESS:
5761     case BUILT_IN_RETURN_ADDRESS:
5762       return expand_builtin_frame_address (fndecl, arglist);
5763
5764     /* Returns the address of the area where the structure is returned.
5765        0 otherwise.  */
5766     case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
5767       if (arglist != 0
5768           || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
5769           || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl))))
5770         return const0_rtx;
5771       else
5772         return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
5773
5774     case BUILT_IN_ALLOCA:
5775       target = expand_builtin_alloca (arglist, target);
5776       if (target)
5777         return target;
5778       break;
5779
5780     case BUILT_IN_STACK_SAVE:
5781       return expand_stack_save ();
5782
5783     case BUILT_IN_STACK_RESTORE:
5784       expand_stack_restore (TREE_VALUE (arglist));
5785       return const0_rtx;
5786
5787     CASE_INT_FN (BUILT_IN_FFS):
5788     case BUILT_IN_FFSIMAX:
5789       target = expand_builtin_unop (target_mode, arglist, target,
5790                                     subtarget, ffs_optab);
5791       if (target)
5792         return target;
5793       break;
5794
5795     CASE_INT_FN (BUILT_IN_CLZ):
5796     case BUILT_IN_CLZIMAX:
5797       target = expand_builtin_unop (target_mode, arglist, target,
5798                                     subtarget, clz_optab);
5799       if (target)
5800         return target;
5801       break;
5802
5803     CASE_INT_FN (BUILT_IN_CTZ):
5804     case BUILT_IN_CTZIMAX:
5805       target = expand_builtin_unop (target_mode, arglist, target,
5806                                     subtarget, ctz_optab);
5807       if (target)
5808         return target;
5809       break;
5810
5811     CASE_INT_FN (BUILT_IN_POPCOUNT):
5812     case BUILT_IN_POPCOUNTIMAX:
5813       target = expand_builtin_unop (target_mode, arglist, target,
5814                                     subtarget, popcount_optab);
5815       if (target)
5816         return target;
5817       break;
5818
5819     CASE_INT_FN (BUILT_IN_PARITY):
5820     case BUILT_IN_PARITYIMAX:
5821       target = expand_builtin_unop (target_mode, arglist, target,
5822                                     subtarget, parity_optab);
5823       if (target)
5824         return target;
5825       break;
5826
5827     case BUILT_IN_STRLEN:
5828       target = expand_builtin_strlen (arglist, target, target_mode);
5829       if (target)
5830         return target;
5831       break;
5832
5833     case BUILT_IN_STRCPY:
5834       target = expand_builtin_strcpy (fndecl, arglist, target, mode);
5835       if (target)
5836         return target;
5837       break;
5838
5839     case BUILT_IN_STRNCPY:
5840       target = expand_builtin_strncpy (exp, target, mode);
5841       if (target)
5842         return target;
5843       break;
5844
5845     case BUILT_IN_STPCPY:
5846       target = expand_builtin_stpcpy (exp, target, mode);
5847       if (target)
5848         return target;
5849       break;
5850
5851     case BUILT_IN_STRCAT:
5852       target = expand_builtin_strcat (fndecl, arglist, target, mode);
5853       if (target)
5854         return target;
5855       break;
5856
5857     case BUILT_IN_STRNCAT:
5858       target = expand_builtin_strncat (arglist, target, mode);
5859       if (target)
5860         return target;
5861       break;
5862
5863     case BUILT_IN_STRSPN:
5864       target = expand_builtin_strspn (arglist, target, mode);
5865       if (target)
5866         return target;
5867       break;
5868
5869     case BUILT_IN_STRCSPN:
5870       target = expand_builtin_strcspn (arglist, target, mode);
5871       if (target)
5872         return target;
5873       break;
5874
5875     case BUILT_IN_STRSTR:
5876       target = expand_builtin_strstr (arglist, TREE_TYPE (exp), target, mode);
5877       if (target)
5878         return target;
5879       break;
5880
5881     case BUILT_IN_STRPBRK:
5882       target = expand_builtin_strpbrk (arglist, TREE_TYPE (exp), target, mode);
5883       if (target)
5884         return target;
5885       break;
5886
5887     case BUILT_IN_INDEX:
5888     case BUILT_IN_STRCHR:
5889       target = expand_builtin_strchr (arglist, TREE_TYPE (exp), target, mode);
5890       if (target)
5891         return target;
5892       break;
5893
5894     case BUILT_IN_RINDEX:
5895     case BUILT_IN_STRRCHR:
5896       target = expand_builtin_strrchr (arglist, TREE_TYPE (exp), target, mode);
5897       if (target)
5898         return target;
5899       break;
5900
5901     case BUILT_IN_MEMCPY:
5902       target = expand_builtin_memcpy (exp, target, mode);
5903       if (target)
5904         return target;
5905       break;
5906
5907     case BUILT_IN_MEMPCPY:
5908       target = expand_builtin_mempcpy (arglist, TREE_TYPE (exp), target, mode, /*endp=*/ 1);
5909       if (target)
5910         return target;
5911       break;
5912
5913     case BUILT_IN_MEMMOVE:
5914       target = expand_builtin_memmove (arglist, TREE_TYPE (exp), target,
5915                                        mode, exp);
5916       if (target)
5917         return target;
5918       break;
5919
5920     case BUILT_IN_BCOPY:
5921       target = expand_builtin_bcopy (exp);
5922       if (target)
5923         return target;
5924       break;
5925
5926     case BUILT_IN_MEMSET:
5927       target = expand_builtin_memset (arglist, target, mode, exp);
5928       if (target)
5929         return target;
5930       break;
5931
5932     case BUILT_IN_BZERO:
5933       target = expand_builtin_bzero (exp);
5934       if (target)
5935         return target;
5936       break;
5937
5938     case BUILT_IN_STRCMP:
5939       target = expand_builtin_strcmp (exp, target, mode);
5940       if (target)
5941         return target;
5942       break;
5943
5944     case BUILT_IN_STRNCMP:
5945       target = expand_builtin_strncmp (exp, target, mode);
5946       if (target)
5947         return target;
5948       break;
5949
5950     case BUILT_IN_BCMP:
5951     case BUILT_IN_MEMCMP:
5952       target = expand_builtin_memcmp (exp, arglist, target, mode);
5953       if (target)
5954         return target;
5955       break;
5956
5957     case BUILT_IN_SETJMP:
5958       target = expand_builtin_setjmp (arglist, target);
5959       if (target)
5960         return target;
5961       break;
5962
5963       /* __builtin_longjmp is passed a pointer to an array of five words.
5964          It's similar to the C library longjmp function but works with
5965          __builtin_setjmp above.  */
5966     case BUILT_IN_LONGJMP:
5967       if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
5968         break;
5969       else
5970         {
5971           rtx buf_addr = expand_expr (TREE_VALUE (arglist), subtarget,
5972                                       VOIDmode, 0);
5973           rtx value = expand_expr (TREE_VALUE (TREE_CHAIN (arglist)),
5974                                    NULL_RTX, VOIDmode, 0);
5975
5976           if (value != const1_rtx)
5977             {
5978               error ("%<__builtin_longjmp%> second argument must be 1");
5979               return const0_rtx;
5980             }
5981
5982           expand_builtin_longjmp (buf_addr, value);
5983           return const0_rtx;
5984         }
5985
5986     case BUILT_IN_NONLOCAL_GOTO:
5987       target = expand_builtin_nonlocal_goto (arglist);
5988       if (target)
5989         return target;
5990       break;
5991
5992       /* This updates the setjmp buffer that is its argument with the value
5993          of the current stack pointer.  */
5994     case BUILT_IN_UPDATE_SETJMP_BUF:
5995       if (validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
5996         {
5997           rtx buf_addr
5998             = expand_expr (TREE_VALUE (arglist), NULL_RTX, VOIDmode, 0);
5999
6000           expand_builtin_update_setjmp_buf (buf_addr);
6001           return const0_rtx;
6002         }
6003       break;
6004
6005     case BUILT_IN_TRAP:
6006       expand_builtin_trap ();
6007       return const0_rtx;
6008
6009     case BUILT_IN_PRINTF:
6010       target = expand_builtin_printf (exp, target, mode, false);
6011       if (target)
6012         return target;
6013       break;
6014
6015     case BUILT_IN_PRINTF_UNLOCKED:
6016       target = expand_builtin_printf (exp, target, mode, true);
6017       if (target)
6018         return target;
6019       break;
6020
6021     case BUILT_IN_FPUTS:
6022       target = expand_builtin_fputs (arglist, target, false);
6023       if (target)
6024         return target;
6025       break;
6026     case BUILT_IN_FPUTS_UNLOCKED:
6027       target = expand_builtin_fputs (arglist, target, true);
6028       if (target)
6029         return target;
6030       break;
6031
6032     case BUILT_IN_FPRINTF:
6033       target = expand_builtin_fprintf (exp, target, mode, false);
6034       if (target)
6035         return target;
6036       break;
6037
6038     case BUILT_IN_FPRINTF_UNLOCKED:
6039       target = expand_builtin_fprintf (exp, target, mode, true);
6040       if (target)
6041         return target;
6042       break;
6043
6044     case BUILT_IN_SPRINTF:
6045       target = expand_builtin_sprintf (arglist, target, mode);
6046       if (target)
6047         return target;
6048       break;
6049
6050     CASE_FLT_FN (BUILT_IN_SIGNBIT):
6051       target = expand_builtin_signbit (exp, target);
6052       if (target)
6053         return target;
6054       break;
6055
6056       /* Various hooks for the DWARF 2 __throw routine.  */
6057     case BUILT_IN_UNWIND_INIT:
6058       expand_builtin_unwind_init ();
6059       return const0_rtx;
6060     case BUILT_IN_DWARF_CFA:
6061       return virtual_cfa_rtx;
6062 #ifdef DWARF2_UNWIND_INFO
6063     case BUILT_IN_DWARF_SP_COLUMN:
6064       return expand_builtin_dwarf_sp_column ();
6065     case BUILT_IN_INIT_DWARF_REG_SIZES:
6066       expand_builtin_init_dwarf_reg_sizes (TREE_VALUE (arglist));
6067       return const0_rtx;
6068 #endif
6069     case BUILT_IN_FROB_RETURN_ADDR:
6070       return expand_builtin_frob_return_addr (TREE_VALUE (arglist));
6071     case BUILT_IN_EXTRACT_RETURN_ADDR:
6072       return expand_builtin_extract_return_addr (TREE_VALUE (arglist));
6073     case BUILT_IN_EH_RETURN:
6074       expand_builtin_eh_return (TREE_VALUE (arglist),
6075                                 TREE_VALUE (TREE_CHAIN (arglist)));
6076       return const0_rtx;
6077 #ifdef EH_RETURN_DATA_REGNO
6078     case BUILT_IN_EH_RETURN_DATA_REGNO:
6079       return expand_builtin_eh_return_data_regno (arglist);
6080 #endif
6081     case BUILT_IN_EXTEND_POINTER:
6082       return expand_builtin_extend_pointer (TREE_VALUE (arglist));
6083
6084     case BUILT_IN_VA_START:
6085     case BUILT_IN_STDARG_START:
6086       return expand_builtin_va_start (arglist);
6087     case BUILT_IN_VA_END:
6088       return expand_builtin_va_end (arglist);
6089     case BUILT_IN_VA_COPY:
6090       return expand_builtin_va_copy (arglist);
6091     case BUILT_IN_EXPECT:
6092       return expand_builtin_expect (arglist, target);
6093     case BUILT_IN_PREFETCH:
6094       expand_builtin_prefetch (arglist);
6095       return const0_rtx;
6096
6097     case BUILT_IN_PROFILE_FUNC_ENTER:
6098       return expand_builtin_profile_func (false);
6099     case BUILT_IN_PROFILE_FUNC_EXIT:
6100       return expand_builtin_profile_func (true);
6101
6102     case BUILT_IN_INIT_TRAMPOLINE:
6103       return expand_builtin_init_trampoline (arglist);
6104     case BUILT_IN_ADJUST_TRAMPOLINE:
6105       return expand_builtin_adjust_trampoline (arglist);
6106
6107     case BUILT_IN_FORK:
6108     case BUILT_IN_EXECL:
6109     case BUILT_IN_EXECV:
6110     case BUILT_IN_EXECLP:
6111     case BUILT_IN_EXECLE:
6112     case BUILT_IN_EXECVP:
6113     case BUILT_IN_EXECVE:
6114       target = expand_builtin_fork_or_exec (fndecl, arglist, target, ignore);
6115       if (target)
6116         return target;
6117       break;
6118
6119     case BUILT_IN_FETCH_AND_ADD_1:
6120     case BUILT_IN_FETCH_AND_ADD_2:
6121     case BUILT_IN_FETCH_AND_ADD_4:
6122     case BUILT_IN_FETCH_AND_ADD_8:
6123     case BUILT_IN_FETCH_AND_ADD_16:
6124       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_ADD_1);
6125       target = expand_builtin_sync_operation (mode, arglist, PLUS,
6126                                               false, target, ignore);
6127       if (target)
6128         return target;
6129       break;
6130
6131     case BUILT_IN_FETCH_AND_SUB_1:
6132     case BUILT_IN_FETCH_AND_SUB_2:
6133     case BUILT_IN_FETCH_AND_SUB_4:
6134     case BUILT_IN_FETCH_AND_SUB_8:
6135     case BUILT_IN_FETCH_AND_SUB_16:
6136       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_SUB_1);
6137       target = expand_builtin_sync_operation (mode, arglist, MINUS,
6138                                               false, target, ignore);
6139       if (target)
6140         return target;
6141       break;
6142
6143     case BUILT_IN_FETCH_AND_OR_1:
6144     case BUILT_IN_FETCH_AND_OR_2:
6145     case BUILT_IN_FETCH_AND_OR_4:
6146     case BUILT_IN_FETCH_AND_OR_8:
6147     case BUILT_IN_FETCH_AND_OR_16:
6148       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_OR_1);
6149       target = expand_builtin_sync_operation (mode, arglist, IOR,
6150                                               false, target, ignore);
6151       if (target)
6152         return target;
6153       break;
6154
6155     case BUILT_IN_FETCH_AND_AND_1:
6156     case BUILT_IN_FETCH_AND_AND_2:
6157     case BUILT_IN_FETCH_AND_AND_4:
6158     case BUILT_IN_FETCH_AND_AND_8:
6159     case BUILT_IN_FETCH_AND_AND_16:
6160       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_AND_1);
6161       target = expand_builtin_sync_operation (mode, arglist, AND,
6162                                               false, target, ignore);
6163       if (target)
6164         return target;
6165       break;
6166
6167     case BUILT_IN_FETCH_AND_XOR_1:
6168     case BUILT_IN_FETCH_AND_XOR_2:
6169     case BUILT_IN_FETCH_AND_XOR_4:
6170     case BUILT_IN_FETCH_AND_XOR_8:
6171     case BUILT_IN_FETCH_AND_XOR_16:
6172       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_XOR_1);
6173       target = expand_builtin_sync_operation (mode, arglist, XOR,
6174                                               false, target, ignore);
6175       if (target)
6176         return target;
6177       break;
6178
6179     case BUILT_IN_FETCH_AND_NAND_1:
6180     case BUILT_IN_FETCH_AND_NAND_2:
6181     case BUILT_IN_FETCH_AND_NAND_4:
6182     case BUILT_IN_FETCH_AND_NAND_8:
6183     case BUILT_IN_FETCH_AND_NAND_16:
6184       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_NAND_1);
6185       target = expand_builtin_sync_operation (mode, arglist, NOT,
6186                                               false, target, ignore);
6187       if (target)
6188         return target;
6189       break;
6190
6191     case BUILT_IN_ADD_AND_FETCH_1:
6192     case BUILT_IN_ADD_AND_FETCH_2:
6193     case BUILT_IN_ADD_AND_FETCH_4:
6194     case BUILT_IN_ADD_AND_FETCH_8:
6195     case BUILT_IN_ADD_AND_FETCH_16:
6196       mode = get_builtin_sync_mode (fcode - BUILT_IN_ADD_AND_FETCH_1);
6197       target = expand_builtin_sync_operation (mode, arglist, PLUS,
6198                                               true, target, ignore);
6199       if (target)
6200         return target;
6201       break;
6202
6203     case BUILT_IN_SUB_AND_FETCH_1:
6204     case BUILT_IN_SUB_AND_FETCH_2:
6205     case BUILT_IN_SUB_AND_FETCH_4:
6206     case BUILT_IN_SUB_AND_FETCH_8:
6207     case BUILT_IN_SUB_AND_FETCH_16:
6208       mode = get_builtin_sync_mode (fcode - BUILT_IN_SUB_AND_FETCH_1);
6209       target = expand_builtin_sync_operation (mode, arglist, MINUS,
6210                                               true, target, ignore);
6211       if (target)
6212         return target;
6213       break;
6214
6215     case BUILT_IN_OR_AND_FETCH_1:
6216     case BUILT_IN_OR_AND_FETCH_2:
6217     case BUILT_IN_OR_AND_FETCH_4:
6218     case BUILT_IN_OR_AND_FETCH_8:
6219     case BUILT_IN_OR_AND_FETCH_16:
6220       mode = get_builtin_sync_mode (fcode - BUILT_IN_OR_AND_FETCH_1);
6221       target = expand_builtin_sync_operation (mode, arglist, IOR,
6222                                               true, target, ignore);
6223       if (target)
6224         return target;
6225       break;
6226
6227     case BUILT_IN_AND_AND_FETCH_1:
6228     case BUILT_IN_AND_AND_FETCH_2:
6229     case BUILT_IN_AND_AND_FETCH_4:
6230     case BUILT_IN_AND_AND_FETCH_8:
6231     case BUILT_IN_AND_AND_FETCH_16:
6232       mode = get_builtin_sync_mode (fcode - BUILT_IN_AND_AND_FETCH_1);
6233       target = expand_builtin_sync_operation (mode, arglist, AND,
6234                                               true, target, ignore);
6235       if (target)
6236         return target;
6237       break;
6238
6239     case BUILT_IN_XOR_AND_FETCH_1:
6240     case BUILT_IN_XOR_AND_FETCH_2:
6241     case BUILT_IN_XOR_AND_FETCH_4:
6242     case BUILT_IN_XOR_AND_FETCH_8:
6243     case BUILT_IN_XOR_AND_FETCH_16:
6244       mode = get_builtin_sync_mode (fcode - BUILT_IN_XOR_AND_FETCH_1);
6245       target = expand_builtin_sync_operation (mode, arglist, XOR,
6246                                               true, target, ignore);
6247       if (target)
6248         return target;
6249       break;
6250
6251     case BUILT_IN_NAND_AND_FETCH_1:
6252     case BUILT_IN_NAND_AND_FETCH_2:
6253     case BUILT_IN_NAND_AND_FETCH_4:
6254     case BUILT_IN_NAND_AND_FETCH_8:
6255     case BUILT_IN_NAND_AND_FETCH_16:
6256       mode = get_builtin_sync_mode (fcode - BUILT_IN_NAND_AND_FETCH_1);
6257       target = expand_builtin_sync_operation (mode, arglist, NOT,
6258                                               true, target, ignore);
6259       if (target)
6260         return target;
6261       break;
6262
6263     case BUILT_IN_BOOL_COMPARE_AND_SWAP_1:
6264     case BUILT_IN_BOOL_COMPARE_AND_SWAP_2:
6265     case BUILT_IN_BOOL_COMPARE_AND_SWAP_4:
6266     case BUILT_IN_BOOL_COMPARE_AND_SWAP_8:
6267     case BUILT_IN_BOOL_COMPARE_AND_SWAP_16:
6268       if (mode == VOIDmode)
6269         mode = TYPE_MODE (boolean_type_node);
6270       if (!target || !register_operand (target, mode))
6271         target = gen_reg_rtx (mode);
6272
6273       mode = get_builtin_sync_mode (fcode - BUILT_IN_BOOL_COMPARE_AND_SWAP_1);
6274       target = expand_builtin_compare_and_swap (mode, arglist, true, target);
6275       if (target)
6276         return target;
6277       break;
6278
6279     case BUILT_IN_VAL_COMPARE_AND_SWAP_1:
6280     case BUILT_IN_VAL_COMPARE_AND_SWAP_2:
6281     case BUILT_IN_VAL_COMPARE_AND_SWAP_4:
6282     case BUILT_IN_VAL_COMPARE_AND_SWAP_8:
6283     case BUILT_IN_VAL_COMPARE_AND_SWAP_16:
6284       mode = get_builtin_sync_mode (fcode - BUILT_IN_VAL_COMPARE_AND_SWAP_1);
6285       target = expand_builtin_compare_and_swap (mode, arglist, false, target);
6286       if (target)
6287         return target;
6288       break;
6289
6290     case BUILT_IN_LOCK_TEST_AND_SET_1:
6291     case BUILT_IN_LOCK_TEST_AND_SET_2:
6292     case BUILT_IN_LOCK_TEST_AND_SET_4:
6293     case BUILT_IN_LOCK_TEST_AND_SET_8:
6294     case BUILT_IN_LOCK_TEST_AND_SET_16:
6295       mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_TEST_AND_SET_1);
6296       target = expand_builtin_lock_test_and_set (mode, arglist, target);
6297       if (target)
6298         return target;
6299       break;
6300
6301     case BUILT_IN_LOCK_RELEASE_1:
6302     case BUILT_IN_LOCK_RELEASE_2:
6303     case BUILT_IN_LOCK_RELEASE_4:
6304     case BUILT_IN_LOCK_RELEASE_8:
6305     case BUILT_IN_LOCK_RELEASE_16:
6306       mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_RELEASE_1);
6307       expand_builtin_lock_release (mode, arglist);
6308       return const0_rtx;
6309
6310     case BUILT_IN_SYNCHRONIZE:
6311       expand_builtin_synchronize ();
6312       return const0_rtx;
6313
6314     case BUILT_IN_OBJECT_SIZE:
6315       return expand_builtin_object_size (exp);
6316
6317     case BUILT_IN_MEMCPY_CHK:
6318     case BUILT_IN_MEMPCPY_CHK:
6319     case BUILT_IN_MEMMOVE_CHK:
6320     case BUILT_IN_MEMSET_CHK:
6321       target = expand_builtin_memory_chk (exp, target, mode, fcode);
6322       if (target)
6323         return target;
6324       break;
6325
6326     case BUILT_IN_STRCPY_CHK:
6327     case BUILT_IN_STPCPY_CHK:
6328     case BUILT_IN_STRNCPY_CHK:
6329     case BUILT_IN_STRCAT_CHK:
6330     case BUILT_IN_SNPRINTF_CHK:
6331     case BUILT_IN_VSNPRINTF_CHK:
6332       maybe_emit_chk_warning (exp, fcode);
6333       break;
6334
6335     case BUILT_IN_SPRINTF_CHK:
6336     case BUILT_IN_VSPRINTF_CHK:
6337       maybe_emit_sprintf_chk_warning (exp, fcode);
6338       break;
6339
6340     default:    /* just do library call, if unknown builtin */
6341       break;
6342     }
6343
6344   /* The switch statement above can drop through to cause the function
6345      to be called normally.  */
6346   return expand_call (exp, target, ignore);
6347 }
6348
6349 /* Determine whether a tree node represents a call to a built-in
6350    function.  If the tree T is a call to a built-in function with
6351    the right number of arguments of the appropriate types, return
6352    the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6353    Otherwise the return value is END_BUILTINS.  */
6354
6355 enum built_in_function
6356 builtin_mathfn_code (tree t)
6357 {
6358   tree fndecl, arglist, parmlist;
6359   tree argtype, parmtype;
6360
6361   if (TREE_CODE (t) != CALL_EXPR
6362       || TREE_CODE (TREE_OPERAND (t, 0)) != ADDR_EXPR)
6363     return END_BUILTINS;
6364
6365   fndecl = get_callee_fndecl (t);
6366   if (fndecl == NULL_TREE
6367       || TREE_CODE (fndecl) != FUNCTION_DECL
6368       || ! DECL_BUILT_IN (fndecl)
6369       || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6370     return END_BUILTINS;
6371
6372   arglist = TREE_OPERAND (t, 1);
6373   parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6374   for (; parmlist; parmlist = TREE_CHAIN (parmlist))
6375     {
6376       /* If a function doesn't take a variable number of arguments,
6377          the last element in the list will have type `void'.  */
6378       parmtype = TREE_VALUE (parmlist);
6379       if (VOID_TYPE_P (parmtype))
6380         {
6381           if (arglist)
6382             return END_BUILTINS;
6383           return DECL_FUNCTION_CODE (fndecl);
6384         }
6385
6386       if (! arglist)
6387         return END_BUILTINS;
6388
6389       argtype = TREE_TYPE (TREE_VALUE (arglist));
6390
6391       if (SCALAR_FLOAT_TYPE_P (parmtype))
6392         {
6393           if (! SCALAR_FLOAT_TYPE_P (argtype))
6394             return END_BUILTINS;
6395         }
6396       else if (COMPLEX_FLOAT_TYPE_P (parmtype))
6397         {
6398           if (! COMPLEX_FLOAT_TYPE_P (argtype))
6399             return END_BUILTINS;
6400         }
6401       else if (POINTER_TYPE_P (parmtype))
6402         {
6403           if (! POINTER_TYPE_P (argtype))
6404             return END_BUILTINS;
6405         }
6406       else if (INTEGRAL_TYPE_P (parmtype))
6407         {
6408           if (! INTEGRAL_TYPE_P (argtype))
6409             return END_BUILTINS;
6410         }
6411       else
6412         return END_BUILTINS;
6413
6414       arglist = TREE_CHAIN (arglist);
6415     }
6416
6417   /* Variable-length argument list.  */
6418   return DECL_FUNCTION_CODE (fndecl);
6419 }
6420
6421 /* Fold a call to __builtin_constant_p, if we know it will evaluate to a
6422    constant.  ARGLIST is the argument list of the call.  */
6423
6424 static tree
6425 fold_builtin_constant_p (tree arglist)
6426 {
6427   if (arglist == 0)
6428     return 0;
6429
6430   arglist = TREE_VALUE (arglist);
6431
6432   /* We return 1 for a numeric type that's known to be a constant
6433      value at compile-time or for an aggregate type that's a
6434      literal constant.  */
6435   STRIP_NOPS (arglist);
6436
6437   /* If we know this is a constant, emit the constant of one.  */
6438   if (CONSTANT_CLASS_P (arglist)
6439       || (TREE_CODE (arglist) == CONSTRUCTOR
6440           && TREE_CONSTANT (arglist)))
6441     return integer_one_node;
6442   if (TREE_CODE (arglist) == ADDR_EXPR)
6443     {
6444        tree op = TREE_OPERAND (arglist, 0);
6445        if (TREE_CODE (op) == STRING_CST
6446            || (TREE_CODE (op) == ARRAY_REF
6447                && integer_zerop (TREE_OPERAND (op, 1))
6448                && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST))
6449          return integer_one_node;
6450     }
6451
6452   /* If this expression has side effects, show we don't know it to be a
6453      constant.  Likewise if it's a pointer or aggregate type since in
6454      those case we only want literals, since those are only optimized
6455      when generating RTL, not later.
6456      And finally, if we are compiling an initializer, not code, we
6457      need to return a definite result now; there's not going to be any
6458      more optimization done.  */
6459   if (TREE_SIDE_EFFECTS (arglist)
6460       || AGGREGATE_TYPE_P (TREE_TYPE (arglist))
6461       || POINTER_TYPE_P (TREE_TYPE (arglist))
6462       || cfun == 0)
6463     return integer_zero_node;
6464
6465   return 0;
6466 }
6467
6468 /* Fold a call to __builtin_expect, if we expect that a comparison against
6469    the argument will fold to a constant.  In practice, this means a true
6470    constant or the address of a non-weak symbol.  ARGLIST is the argument
6471    list of the call.  */
6472
6473 static tree
6474 fold_builtin_expect (tree arglist)
6475 {
6476   tree arg, inner;
6477
6478   if (arglist == 0)
6479     return 0;
6480
6481   arg = TREE_VALUE (arglist);
6482
6483   /* If the argument isn't invariant, then there's nothing we can do.  */
6484   if (!TREE_INVARIANT (arg))
6485     return 0;
6486
6487   /* If we're looking at an address of a weak decl, then do not fold.  */
6488   inner = arg;
6489   STRIP_NOPS (inner);
6490   if (TREE_CODE (inner) == ADDR_EXPR)
6491     {
6492       do
6493         {
6494           inner = TREE_OPERAND (inner, 0);
6495         }
6496       while (TREE_CODE (inner) == COMPONENT_REF
6497              || TREE_CODE (inner) == ARRAY_REF);
6498       if (DECL_P (inner) && DECL_WEAK (inner))
6499         return 0;
6500     }
6501
6502   /* Otherwise, ARG already has the proper type for the return value.  */
6503   return arg;
6504 }
6505
6506 /* Fold a call to __builtin_classify_type.  */
6507
6508 static tree
6509 fold_builtin_classify_type (tree arglist)
6510 {
6511   if (arglist == 0)
6512     return build_int_cst (NULL_TREE, no_type_class);
6513
6514   return build_int_cst (NULL_TREE,
6515                         type_to_class (TREE_TYPE (TREE_VALUE (arglist))));
6516 }
6517
6518 /* Fold a call to __builtin_strlen.  */
6519
6520 static tree
6521 fold_builtin_strlen (tree arglist)
6522 {
6523   if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
6524     return NULL_TREE;
6525   else
6526     {
6527       tree len = c_strlen (TREE_VALUE (arglist), 0);
6528
6529       if (len)
6530         {
6531           /* Convert from the internal "sizetype" type to "size_t".  */
6532           if (size_type_node)
6533             len = fold_convert (size_type_node, len);
6534           return len;
6535         }
6536
6537       return NULL_TREE;
6538     }
6539 }
6540
6541 /* Fold a call to __builtin_inf or __builtin_huge_val.  */
6542
6543 static tree
6544 fold_builtin_inf (tree type, int warn)
6545 {
6546   REAL_VALUE_TYPE real;
6547
6548   /* __builtin_inff is intended to be usable to define INFINITY on all
6549      targets.  If an infinity is not available, INFINITY expands "to a
6550      positive constant of type float that overflows at translation
6551      time", footnote "In this case, using INFINITY will violate the
6552      constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
6553      Thus we pedwarn to ensure this constraint violation is
6554      diagnosed.  */
6555   if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
6556     pedwarn ("target format does not support infinity");
6557
6558   real_inf (&real);
6559   return build_real (type, real);
6560 }
6561
6562 /* Fold a call to __builtin_nan or __builtin_nans.  */
6563
6564 static tree
6565 fold_builtin_nan (tree arglist, tree type, int quiet)
6566 {
6567   REAL_VALUE_TYPE real;
6568   const char *str;
6569
6570   if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
6571     return 0;
6572   str = c_getstr (TREE_VALUE (arglist));
6573   if (!str)
6574     return 0;
6575
6576   if (!real_nan (&real, str, quiet, TYPE_MODE (type)))
6577     return 0;
6578
6579   return build_real (type, real);
6580 }
6581
6582 /* Return true if the floating point expression T has an integer value.
6583    We also allow +Inf, -Inf and NaN to be considered integer values.  */
6584
6585 static bool
6586 integer_valued_real_p (tree t)
6587 {
6588   switch (TREE_CODE (t))
6589     {
6590     case FLOAT_EXPR:
6591       return true;
6592
6593     case ABS_EXPR:
6594     case SAVE_EXPR:
6595     case NON_LVALUE_EXPR:
6596       return integer_valued_real_p (TREE_OPERAND (t, 0));
6597
6598     case COMPOUND_EXPR:
6599     case MODIFY_EXPR:
6600     case BIND_EXPR:
6601       return integer_valued_real_p (TREE_OPERAND (t, 1));
6602
6603     case PLUS_EXPR:
6604     case MINUS_EXPR:
6605     case MULT_EXPR:
6606     case MIN_EXPR:
6607     case MAX_EXPR:
6608       return integer_valued_real_p (TREE_OPERAND (t, 0))
6609              && integer_valued_real_p (TREE_OPERAND (t, 1));
6610
6611     case COND_EXPR:
6612       return integer_valued_real_p (TREE_OPERAND (t, 1))
6613              && integer_valued_real_p (TREE_OPERAND (t, 2));
6614
6615     case REAL_CST:
6616       if (! TREE_CONSTANT_OVERFLOW (t))
6617       {
6618         REAL_VALUE_TYPE c, cint;
6619
6620         c = TREE_REAL_CST (t);
6621         real_trunc (&cint, TYPE_MODE (TREE_TYPE (t)), &c);
6622         return real_identical (&c, &cint);
6623       }
6624       break;
6625
6626     case NOP_EXPR:
6627       {
6628         tree type = TREE_TYPE (TREE_OPERAND (t, 0));
6629         if (TREE_CODE (type) == INTEGER_TYPE)
6630           return true;
6631         if (TREE_CODE (type) == REAL_TYPE)
6632           return integer_valued_real_p (TREE_OPERAND (t, 0));
6633         break;
6634       }
6635
6636     case CALL_EXPR:
6637       switch (builtin_mathfn_code (t))
6638         {
6639         CASE_FLT_FN (BUILT_IN_CEIL):
6640         CASE_FLT_FN (BUILT_IN_FLOOR):
6641         CASE_FLT_FN (BUILT_IN_NEARBYINT):
6642         CASE_FLT_FN (BUILT_IN_RINT):
6643         CASE_FLT_FN (BUILT_IN_ROUND):
6644         CASE_FLT_FN (BUILT_IN_TRUNC):
6645           return true;
6646
6647         default:
6648           break;
6649         }
6650       break;
6651
6652     default:
6653       break;
6654     }
6655   return false;
6656 }
6657
6658 /* EXP is assumed to be builtin call where truncation can be propagated
6659    across (for instance floor((double)f) == (double)floorf (f).
6660    Do the transformation.  */
6661
6662 static tree
6663 fold_trunc_transparent_mathfn (tree fndecl, tree arglist)
6664 {
6665   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6666   tree arg;
6667
6668   if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6669     return 0;
6670
6671   arg = TREE_VALUE (arglist);
6672   /* Integer rounding functions are idempotent.  */
6673   if (fcode == builtin_mathfn_code (arg))
6674     return arg;
6675
6676   /* If argument is already integer valued, and we don't need to worry
6677      about setting errno, there's no need to perform rounding.  */
6678   if (! flag_errno_math && integer_valued_real_p (arg))
6679     return arg;
6680
6681   if (optimize)
6682     {
6683       tree arg0 = strip_float_extensions (arg);
6684       tree ftype = TREE_TYPE (TREE_TYPE (fndecl));
6685       tree newtype = TREE_TYPE (arg0);
6686       tree decl;
6687
6688       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
6689           && (decl = mathfn_built_in (newtype, fcode)))
6690         {
6691           arglist =
6692             build_tree_list (NULL_TREE, fold_convert (newtype, arg0));
6693           return fold_convert (ftype,
6694                                build_function_call_expr (decl, arglist));
6695         }
6696     }
6697   return 0;
6698 }
6699
6700 /* EXP is assumed to be builtin call which can narrow the FP type of
6701    the argument, for instance lround((double)f) -> lroundf (f).  */
6702
6703 static tree
6704 fold_fixed_mathfn (tree fndecl, tree arglist)
6705 {
6706   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6707   tree arg;
6708
6709   if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6710     return 0;
6711
6712   arg = TREE_VALUE (arglist);
6713
6714   /* If argument is already integer valued, and we don't need to worry
6715      about setting errno, there's no need to perform rounding.  */
6716   if (! flag_errno_math && integer_valued_real_p (arg))
6717     return fold_build1 (FIX_TRUNC_EXPR, TREE_TYPE (TREE_TYPE (fndecl)), arg);
6718
6719   if (optimize)
6720     {
6721       tree ftype = TREE_TYPE (arg);
6722       tree arg0 = strip_float_extensions (arg);
6723       tree newtype = TREE_TYPE (arg0);
6724       tree decl;
6725
6726       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
6727           && (decl = mathfn_built_in (newtype, fcode)))
6728         {
6729           arglist =
6730             build_tree_list (NULL_TREE, fold_convert (newtype, arg0));
6731           return build_function_call_expr (decl, arglist);
6732         }
6733     }
6734   return 0;
6735 }
6736
6737 /* Fold function call to builtin cabs, cabsf or cabsl.  ARGLIST
6738    is the argument list and TYPE is the return type.  Return
6739    NULL_TREE if no if no simplification can be made.  */
6740
6741 static tree
6742 fold_builtin_cabs (tree arglist, tree type)
6743 {
6744   tree arg;
6745
6746   if (!arglist || TREE_CHAIN (arglist))
6747     return NULL_TREE;
6748
6749   arg = TREE_VALUE (arglist);
6750   if (TREE_CODE (TREE_TYPE (arg)) != COMPLEX_TYPE
6751       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
6752     return NULL_TREE;
6753
6754   /* Evaluate cabs of a constant at compile-time.  */
6755   if (flag_unsafe_math_optimizations
6756       && TREE_CODE (arg) == COMPLEX_CST
6757       && TREE_CODE (TREE_REALPART (arg)) == REAL_CST
6758       && TREE_CODE (TREE_IMAGPART (arg)) == REAL_CST
6759       && ! TREE_CONSTANT_OVERFLOW (TREE_REALPART (arg))
6760       && ! TREE_CONSTANT_OVERFLOW (TREE_IMAGPART (arg)))
6761     {
6762       REAL_VALUE_TYPE r, i;
6763
6764       r = TREE_REAL_CST (TREE_REALPART (arg));
6765       i = TREE_REAL_CST (TREE_IMAGPART (arg));
6766
6767       real_arithmetic (&r, MULT_EXPR, &r, &r);
6768       real_arithmetic (&i, MULT_EXPR, &i, &i);
6769       real_arithmetic (&r, PLUS_EXPR, &r, &i);
6770       if (real_sqrt (&r, TYPE_MODE (type), &r)
6771           || ! flag_trapping_math)
6772         return build_real (type, r);
6773     }
6774
6775   /* If either part is zero, cabs is fabs of the other.  */
6776   if (TREE_CODE (arg) == COMPLEX_EXPR
6777       && real_zerop (TREE_OPERAND (arg, 0)))
6778     return fold_build1 (ABS_EXPR, type, TREE_OPERAND (arg, 1));
6779   if (TREE_CODE (arg) == COMPLEX_EXPR
6780       && real_zerop (TREE_OPERAND (arg, 1)))
6781     return fold_build1 (ABS_EXPR, type, TREE_OPERAND (arg, 0));
6782
6783   /* Don't do this when optimizing for size.  */
6784   if (flag_unsafe_math_optimizations
6785       && optimize && !optimize_size)
6786     {
6787       tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
6788
6789       if (sqrtfn != NULL_TREE)
6790         {
6791           tree rpart, ipart, result, arglist;
6792
6793           arg = builtin_save_expr (arg);
6794
6795           rpart = fold_build1 (REALPART_EXPR, type, arg);
6796           ipart = fold_build1 (IMAGPART_EXPR, type, arg);
6797
6798           rpart = builtin_save_expr (rpart);
6799           ipart = builtin_save_expr (ipart);
6800
6801           result = fold_build2 (PLUS_EXPR, type,
6802                                 fold_build2 (MULT_EXPR, type,
6803                                              rpart, rpart),
6804                                 fold_build2 (MULT_EXPR, type,
6805                                              ipart, ipart));
6806
6807           arglist = build_tree_list (NULL_TREE, result);
6808           return build_function_call_expr (sqrtfn, arglist);
6809         }
6810     }
6811
6812   return NULL_TREE;
6813 }
6814
6815 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl.  Return
6816    NULL_TREE if no simplification can be made.  */
6817
6818 static tree
6819 fold_builtin_sqrt (tree arglist, tree type)
6820 {
6821
6822   enum built_in_function fcode;
6823   tree arg = TREE_VALUE (arglist);
6824
6825   if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6826     return NULL_TREE;
6827
6828   /* Optimize sqrt of constant value.  */
6829   if (TREE_CODE (arg) == REAL_CST
6830       && ! TREE_CONSTANT_OVERFLOW (arg))
6831     {
6832       REAL_VALUE_TYPE r, x;
6833
6834       x = TREE_REAL_CST (arg);
6835       if (real_sqrt (&r, TYPE_MODE (type), &x)
6836           || (!flag_trapping_math && !flag_errno_math))
6837         return build_real (type, r);
6838     }
6839
6840   /* Optimize sqrt(expN(x)) = expN(x*0.5).  */
6841   fcode = builtin_mathfn_code (arg);
6842   if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
6843     {
6844       tree expfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
6845       arg = fold_build2 (MULT_EXPR, type,
6846                          TREE_VALUE (TREE_OPERAND (arg, 1)),
6847                          build_real (type, dconsthalf));
6848       arglist = build_tree_list (NULL_TREE, arg);
6849       return build_function_call_expr (expfn, arglist);
6850     }
6851
6852   /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)).  */
6853   if (flag_unsafe_math_optimizations && BUILTIN_ROOT_P (fcode))
6854     {
6855       tree powfn = mathfn_built_in (type, BUILT_IN_POW);
6856
6857       if (powfn)
6858         {
6859           tree arg0 = TREE_VALUE (TREE_OPERAND (arg, 1));
6860           tree tree_root;
6861           /* The inner root was either sqrt or cbrt.  */
6862           REAL_VALUE_TYPE dconstroot =
6863             BUILTIN_SQRT_P (fcode) ? dconsthalf : dconstthird;
6864
6865           /* Adjust for the outer root.  */
6866           SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
6867           dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
6868           tree_root = build_real (type, dconstroot);
6869           arglist = tree_cons (NULL_TREE, arg0,
6870                                build_tree_list (NULL_TREE, tree_root));
6871           return build_function_call_expr (powfn, arglist);
6872         }
6873     }
6874
6875   /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5).  */
6876   if (flag_unsafe_math_optimizations
6877       && (fcode == BUILT_IN_POW
6878           || fcode == BUILT_IN_POWF
6879           || fcode == BUILT_IN_POWL))
6880     {
6881       tree powfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
6882       tree arg0 = TREE_VALUE (TREE_OPERAND (arg, 1));
6883       tree arg1 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg, 1)));
6884       tree narg1;
6885       if (!tree_expr_nonnegative_p (arg0))
6886         arg0 = build1 (ABS_EXPR, type, arg0);
6887       narg1 = fold_build2 (MULT_EXPR, type, arg1,
6888                            build_real (type, dconsthalf));
6889       arglist = tree_cons (NULL_TREE, arg0,
6890                            build_tree_list (NULL_TREE, narg1));
6891       return build_function_call_expr (powfn, arglist);
6892     }
6893
6894   return NULL_TREE;
6895 }
6896
6897 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl.  Return
6898    NULL_TREE if no simplification can be made.  */
6899 static tree
6900 fold_builtin_cbrt (tree arglist, tree type)
6901 {
6902   tree arg = TREE_VALUE (arglist);
6903   const enum built_in_function fcode = builtin_mathfn_code (arg);
6904
6905   if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6906     return NULL_TREE;
6907
6908   /* Optimize cbrt of constant value.  */
6909   if (real_zerop (arg) || real_onep (arg) || real_minus_onep (arg))
6910     return arg;
6911
6912   if (flag_unsafe_math_optimizations)
6913     {
6914       /* Optimize cbrt(expN(x)) -> expN(x/3).  */
6915       if (BUILTIN_EXPONENT_P (fcode))
6916         {
6917           tree expfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
6918           const REAL_VALUE_TYPE third_trunc =
6919             real_value_truncate (TYPE_MODE (type), dconstthird);
6920           arg = fold_build2 (MULT_EXPR, type,
6921                              TREE_VALUE (TREE_OPERAND (arg, 1)),
6922                              build_real (type, third_trunc));
6923           arglist = build_tree_list (NULL_TREE, arg);
6924           return build_function_call_expr (expfn, arglist);
6925         }
6926
6927       /* Optimize cbrt(sqrt(x)) -> pow(x,1/6).  */
6928       if (BUILTIN_SQRT_P (fcode))
6929         {
6930           tree powfn = mathfn_built_in (type, BUILT_IN_POW);
6931
6932           if (powfn)
6933             {
6934               tree arg0 = TREE_VALUE (TREE_OPERAND (arg, 1));
6935               tree tree_root;
6936               REAL_VALUE_TYPE dconstroot = dconstthird;
6937
6938               SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
6939               dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
6940               tree_root = build_real (type, dconstroot);
6941               arglist = tree_cons (NULL_TREE, arg0,
6942                                    build_tree_list (NULL_TREE, tree_root));
6943               return build_function_call_expr (powfn, arglist);
6944             }
6945         }
6946
6947       /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative.  */
6948       if (BUILTIN_CBRT_P (fcode))
6949         {
6950           tree arg0 = TREE_VALUE (TREE_OPERAND (arg, 1));
6951           if (tree_expr_nonnegative_p (arg0))
6952             {
6953               tree powfn = mathfn_built_in (type, BUILT_IN_POW);
6954
6955               if (powfn)
6956                 {
6957                   tree tree_root;
6958                   REAL_VALUE_TYPE dconstroot;
6959
6960                   real_arithmetic (&dconstroot, MULT_EXPR, &dconstthird, &dconstthird);
6961                   dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
6962                   tree_root = build_real (type, dconstroot);
6963                   arglist = tree_cons (NULL_TREE, arg0,
6964                                        build_tree_list (NULL_TREE, tree_root));
6965                   return build_function_call_expr (powfn, arglist);
6966                 }
6967             }
6968         }
6969
6970       /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative.  */
6971       if (fcode == BUILT_IN_POW || fcode == BUILT_IN_POWF
6972           || fcode == BUILT_IN_POWL)
6973         {
6974           tree arg00 = TREE_VALUE (TREE_OPERAND (arg, 1));
6975           tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg, 1)));
6976           if (tree_expr_nonnegative_p (arg00))
6977             {
6978               tree powfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
6979               const REAL_VALUE_TYPE dconstroot
6980                 = real_value_truncate (TYPE_MODE (type), dconstthird);
6981               tree narg01 = fold_build2 (MULT_EXPR, type, arg01,
6982                                          build_real (type, dconstroot));
6983               arglist = tree_cons (NULL_TREE, arg00,
6984                                    build_tree_list (NULL_TREE, narg01));
6985               return build_function_call_expr (powfn, arglist);
6986             }
6987         }
6988     }
6989   return NULL_TREE;
6990 }
6991
6992 /* Fold function call to builtin sin, sinf, or sinl.  Return
6993    NULL_TREE if no simplification can be made.  */
6994 static tree
6995 fold_builtin_sin (tree arglist)
6996 {
6997   tree arg = TREE_VALUE (arglist);
6998
6999   if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7000     return NULL_TREE;
7001
7002   /* Optimize sin (0.0) = 0.0.  */
7003   if (real_zerop (arg))
7004     return arg;
7005
7006   return NULL_TREE;
7007 }
7008
7009 /* Fold function call to builtin cos, cosf, or cosl.  Return
7010    NULL_TREE if no simplification can be made.  */
7011 static tree
7012 fold_builtin_cos (tree arglist, tree type, tree fndecl)
7013 {
7014   tree arg = TREE_VALUE (arglist);
7015
7016   if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7017     return NULL_TREE;
7018
7019   /* Optimize cos (0.0) = 1.0.  */
7020   if (real_zerop (arg))
7021     return build_real (type, dconst1);
7022
7023   /* Optimize cos(-x) into cos (x).  */
7024   if (TREE_CODE (arg) == NEGATE_EXPR)
7025     {
7026       tree args = build_tree_list (NULL_TREE,
7027                                    TREE_OPERAND (arg, 0));
7028       return build_function_call_expr (fndecl, args);
7029     }
7030
7031   return NULL_TREE;
7032 }
7033
7034 /* Fold function call to builtin tan, tanf, or tanl.  Return
7035    NULL_TREE if no simplification can be made.  */
7036 static tree
7037 fold_builtin_tan (tree arglist)
7038 {
7039   enum built_in_function fcode;
7040   tree arg = TREE_VALUE (arglist);
7041
7042   if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7043     return NULL_TREE;
7044
7045   /* Optimize tan(0.0) = 0.0.  */
7046   if (real_zerop (arg))
7047     return arg;
7048
7049   /* Optimize tan(atan(x)) = x.  */
7050   fcode = builtin_mathfn_code (arg);
7051   if (flag_unsafe_math_optimizations
7052       && (fcode == BUILT_IN_ATAN
7053           || fcode == BUILT_IN_ATANF
7054           || fcode == BUILT_IN_ATANL))
7055     return TREE_VALUE (TREE_OPERAND (arg, 1));
7056
7057   return NULL_TREE;
7058 }
7059
7060 /* Fold function call to builtin atan, atanf, or atanl.  Return
7061    NULL_TREE if no simplification can be made.  */
7062
7063 static tree
7064 fold_builtin_atan (tree arglist, tree type)
7065 {
7066
7067   tree arg = TREE_VALUE (arglist);
7068
7069   if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7070     return NULL_TREE;
7071
7072   /* Optimize atan(0.0) = 0.0.  */
7073   if (real_zerop (arg))
7074     return arg;
7075
7076   /* Optimize atan(1.0) = pi/4.  */
7077   if (real_onep (arg))
7078     {
7079       REAL_VALUE_TYPE cst;
7080
7081       real_convert (&cst, TYPE_MODE (type), &dconstpi);
7082       SET_REAL_EXP (&cst, REAL_EXP (&cst) - 2);
7083       return build_real (type, cst);
7084     }
7085
7086   return NULL_TREE;
7087 }
7088
7089 /* Fold function call to builtin trunc, truncf or truncl.  Return
7090    NULL_TREE if no simplification can be made.  */
7091
7092 static tree
7093 fold_builtin_trunc (tree fndecl, tree arglist)
7094 {
7095   tree arg;
7096
7097   if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7098     return 0;
7099
7100   /* Optimize trunc of constant value.  */
7101   arg = TREE_VALUE (arglist);
7102   if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
7103     {
7104       REAL_VALUE_TYPE r, x;
7105       tree type = TREE_TYPE (TREE_TYPE (fndecl));
7106
7107       x = TREE_REAL_CST (arg);
7108       real_trunc (&r, TYPE_MODE (type), &x);
7109       return build_real (type, r);
7110     }
7111
7112   return fold_trunc_transparent_mathfn (fndecl, arglist);
7113 }
7114
7115 /* Fold function call to builtin floor, floorf or floorl.  Return
7116    NULL_TREE if no simplification can be made.  */
7117
7118 static tree
7119 fold_builtin_floor (tree fndecl, tree arglist)
7120 {
7121   tree arg;
7122
7123   if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7124     return 0;
7125
7126   /* Optimize floor of constant value.  */
7127   arg = TREE_VALUE (arglist);
7128   if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
7129     {
7130       REAL_VALUE_TYPE x;
7131
7132       x = TREE_REAL_CST (arg);
7133       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7134         {
7135           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7136           REAL_VALUE_TYPE r;
7137
7138           real_floor (&r, TYPE_MODE (type), &x);
7139           return build_real (type, r);
7140         }
7141     }
7142
7143   return fold_trunc_transparent_mathfn (fndecl, arglist);
7144 }
7145
7146 /* Fold function call to builtin ceil, ceilf or ceill.  Return
7147    NULL_TREE if no simplification can be made.  */
7148
7149 static tree
7150 fold_builtin_ceil (tree fndecl, tree arglist)
7151 {
7152   tree arg;
7153
7154   if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7155     return 0;
7156
7157   /* Optimize ceil of constant value.  */
7158   arg = TREE_VALUE (arglist);
7159   if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
7160     {
7161       REAL_VALUE_TYPE x;
7162
7163       x = TREE_REAL_CST (arg);
7164       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7165         {
7166           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7167           REAL_VALUE_TYPE r;
7168
7169           real_ceil (&r, TYPE_MODE (type), &x);
7170           return build_real (type, r);
7171         }
7172     }
7173
7174   return fold_trunc_transparent_mathfn (fndecl, arglist);
7175 }
7176
7177 /* Fold function call to builtin round, roundf or roundl.  Return
7178    NULL_TREE if no simplification can be made.  */
7179
7180 static tree
7181 fold_builtin_round (tree fndecl, tree arglist)
7182 {
7183   tree arg;
7184
7185   if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7186     return 0;
7187
7188   /* Optimize round of constant value.  */
7189   arg = TREE_VALUE (arglist);
7190   if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
7191     {
7192       REAL_VALUE_TYPE x;
7193
7194       x = TREE_REAL_CST (arg);
7195       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7196         {
7197           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7198           REAL_VALUE_TYPE r;
7199
7200           real_round (&r, TYPE_MODE (type), &x);
7201           return build_real (type, r);
7202         }
7203     }
7204
7205   return fold_trunc_transparent_mathfn (fndecl, arglist);
7206 }
7207
7208 /* Fold function call to builtin lround, lroundf or lroundl (or the
7209    corresponding long long versions) and other rounding functions.
7210    Return NULL_TREE if no simplification can be made.  */
7211
7212 static tree
7213 fold_builtin_int_roundingfn (tree fndecl, tree arglist)
7214 {
7215   tree arg;
7216
7217   if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7218     return 0;
7219
7220   /* Optimize lround of constant value.  */
7221   arg = TREE_VALUE (arglist);
7222   if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
7223     {
7224       const REAL_VALUE_TYPE x = TREE_REAL_CST (arg);
7225
7226       if (! REAL_VALUE_ISNAN (x) && ! REAL_VALUE_ISINF (x))
7227         {
7228           tree itype = TREE_TYPE (TREE_TYPE (fndecl));
7229           tree ftype = TREE_TYPE (arg), result;
7230           HOST_WIDE_INT hi, lo;
7231           REAL_VALUE_TYPE r;
7232
7233           switch (DECL_FUNCTION_CODE (fndecl))
7234             {
7235             CASE_FLT_FN (BUILT_IN_LFLOOR):
7236             CASE_FLT_FN (BUILT_IN_LLFLOOR):
7237               real_floor (&r, TYPE_MODE (ftype), &x);
7238               break;
7239
7240             CASE_FLT_FN (BUILT_IN_LCEIL):
7241             CASE_FLT_FN (BUILT_IN_LLCEIL):
7242               real_ceil (&r, TYPE_MODE (ftype), &x);
7243               break;
7244
7245             CASE_FLT_FN (BUILT_IN_LROUND):
7246             CASE_FLT_FN (BUILT_IN_LLROUND):
7247               real_round (&r, TYPE_MODE (ftype), &x);
7248               break;
7249
7250             default:
7251               gcc_unreachable ();
7252             }
7253
7254           REAL_VALUE_TO_INT (&lo, &hi, r);
7255           result = build_int_cst_wide (NULL_TREE, lo, hi);
7256           if (int_fits_type_p (result, itype))
7257             return fold_convert (itype, result);
7258         }
7259     }
7260
7261   return fold_fixed_mathfn (fndecl, arglist);
7262 }
7263
7264 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
7265    and their long and long long variants (i.e. ffsl and ffsll).
7266    Return NULL_TREE if no simplification can be made.  */
7267
7268 static tree
7269 fold_builtin_bitop (tree fndecl, tree arglist)
7270 {
7271   tree arg;
7272
7273   if (! validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
7274     return NULL_TREE;
7275
7276   /* Optimize for constant argument.  */
7277   arg = TREE_VALUE (arglist);
7278   if (TREE_CODE (arg) == INTEGER_CST && ! TREE_CONSTANT_OVERFLOW (arg))
7279     {
7280       HOST_WIDE_INT hi, width, result;
7281       unsigned HOST_WIDE_INT lo;
7282       tree type;
7283
7284       type = TREE_TYPE (arg);
7285       width = TYPE_PRECISION (type);
7286       lo = TREE_INT_CST_LOW (arg);
7287
7288       /* Clear all the bits that are beyond the type's precision.  */
7289       if (width > HOST_BITS_PER_WIDE_INT)
7290         {
7291           hi = TREE_INT_CST_HIGH (arg);
7292           if (width < 2 * HOST_BITS_PER_WIDE_INT)
7293             hi &= ~((HOST_WIDE_INT) (-1) >> (width - HOST_BITS_PER_WIDE_INT));
7294         }
7295       else
7296         {
7297           hi = 0;
7298           if (width < HOST_BITS_PER_WIDE_INT)
7299             lo &= ~((unsigned HOST_WIDE_INT) (-1) << width);
7300         }
7301
7302       switch (DECL_FUNCTION_CODE (fndecl))
7303         {
7304         CASE_INT_FN (BUILT_IN_FFS):
7305           if (lo != 0)
7306             result = exact_log2 (lo & -lo) + 1;
7307           else if (hi != 0)
7308             result = HOST_BITS_PER_WIDE_INT + exact_log2 (hi & -hi) + 1;
7309           else
7310             result = 0;
7311           break;
7312
7313         CASE_INT_FN (BUILT_IN_CLZ):
7314           if (hi != 0)
7315             result = width - floor_log2 (hi) - 1 - HOST_BITS_PER_WIDE_INT;
7316           else if (lo != 0)
7317             result = width - floor_log2 (lo) - 1;
7318           else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7319             result = width;
7320           break;
7321
7322         CASE_INT_FN (BUILT_IN_CTZ):
7323           if (lo != 0)
7324             result = exact_log2 (lo & -lo);
7325           else if (hi != 0)
7326             result = HOST_BITS_PER_WIDE_INT + exact_log2 (hi & -hi);
7327           else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7328             result = width;
7329           break;
7330
7331         CASE_INT_FN (BUILT_IN_POPCOUNT):
7332           result = 0;
7333           while (lo)
7334             result++, lo &= lo - 1;
7335           while (hi)
7336             result++, hi &= hi - 1;
7337           break;
7338
7339         CASE_INT_FN (BUILT_IN_PARITY):
7340           result = 0;
7341           while (lo)
7342             result++, lo &= lo - 1;
7343           while (hi)
7344             result++, hi &= hi - 1;
7345           result &= 1;
7346           break;
7347
7348         default:
7349           gcc_unreachable ();
7350         }
7351
7352       return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), result);
7353     }
7354
7355   return NULL_TREE;
7356 }
7357
7358 /* Return true if EXPR is the real constant contained in VALUE.  */
7359
7360 static bool
7361 real_dconstp (tree expr, const REAL_VALUE_TYPE *value)
7362 {
7363   STRIP_NOPS (expr);
7364
7365   return ((TREE_CODE (expr) == REAL_CST
7366            && ! TREE_CONSTANT_OVERFLOW (expr)
7367            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), *value))
7368           || (TREE_CODE (expr) == COMPLEX_CST
7369               && real_dconstp (TREE_REALPART (expr), value)
7370               && real_zerop (TREE_IMAGPART (expr))));
7371 }
7372
7373 /* A subroutine of fold_builtin to fold the various logarithmic
7374    functions.  EXP is the CALL_EXPR of a call to a builtin logN
7375    function.  VALUE is the base of the logN function.  */
7376
7377 static tree
7378 fold_builtin_logarithm (tree fndecl, tree arglist,
7379                         const REAL_VALUE_TYPE *value)
7380 {
7381   if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7382     {
7383       tree type = TREE_TYPE (TREE_TYPE (fndecl));
7384       tree arg = TREE_VALUE (arglist);
7385       const enum built_in_function fcode = builtin_mathfn_code (arg);
7386
7387       /* Optimize logN(1.0) = 0.0.  */
7388       if (real_onep (arg))
7389         return build_real (type, dconst0);
7390
7391       /* Optimize logN(N) = 1.0.  If N can't be truncated to MODE
7392          exactly, then only do this if flag_unsafe_math_optimizations.  */
7393       if (exact_real_truncate (TYPE_MODE (type), value)
7394           || flag_unsafe_math_optimizations)
7395         {
7396           const REAL_VALUE_TYPE value_truncate =
7397             real_value_truncate (TYPE_MODE (type), *value);
7398           if (real_dconstp (arg, &value_truncate))
7399             return build_real (type, dconst1);
7400         }
7401
7402       /* Special case, optimize logN(expN(x)) = x.  */
7403       if (flag_unsafe_math_optimizations
7404           && ((value == &dconste
7405                && (fcode == BUILT_IN_EXP
7406                    || fcode == BUILT_IN_EXPF
7407                    || fcode == BUILT_IN_EXPL))
7408               || (value == &dconst2
7409                   && (fcode == BUILT_IN_EXP2
7410                       || fcode == BUILT_IN_EXP2F
7411                       || fcode == BUILT_IN_EXP2L))
7412               || (value == &dconst10 && (BUILTIN_EXP10_P (fcode)))))
7413         return fold_convert (type, TREE_VALUE (TREE_OPERAND (arg, 1)));
7414
7415       /* Optimize logN(func()) for various exponential functions.  We
7416          want to determine the value "x" and the power "exponent" in
7417          order to transform logN(x**exponent) into exponent*logN(x).  */
7418       if (flag_unsafe_math_optimizations)
7419         {
7420           tree exponent = 0, x = 0;
7421
7422           switch (fcode)
7423           {
7424           CASE_FLT_FN (BUILT_IN_EXP):
7425             /* Prepare to do logN(exp(exponent) -> exponent*logN(e).  */
7426             x = build_real (type,
7427                             real_value_truncate (TYPE_MODE (type), dconste));
7428             exponent = TREE_VALUE (TREE_OPERAND (arg, 1));
7429             break;
7430           CASE_FLT_FN (BUILT_IN_EXP2):
7431             /* Prepare to do logN(exp2(exponent) -> exponent*logN(2).  */
7432             x = build_real (type, dconst2);
7433             exponent = TREE_VALUE (TREE_OPERAND (arg, 1));
7434             break;
7435           CASE_FLT_FN (BUILT_IN_EXP10):
7436           CASE_FLT_FN (BUILT_IN_POW10):
7437             /* Prepare to do logN(exp10(exponent) -> exponent*logN(10).  */
7438             x = build_real (type, dconst10);
7439             exponent = TREE_VALUE (TREE_OPERAND (arg, 1));
7440             break;
7441           CASE_FLT_FN (BUILT_IN_SQRT):
7442             /* Prepare to do logN(sqrt(x) -> 0.5*logN(x).  */
7443             x = TREE_VALUE (TREE_OPERAND (arg, 1));
7444             exponent = build_real (type, dconsthalf);
7445             break;
7446           CASE_FLT_FN (BUILT_IN_CBRT):
7447             /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x).  */
7448             x = TREE_VALUE (TREE_OPERAND (arg, 1));
7449             exponent = build_real (type, real_value_truncate (TYPE_MODE (type),
7450                                                               dconstthird));
7451             break;
7452           CASE_FLT_FN (BUILT_IN_POW):
7453             /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x).  */
7454             x = TREE_VALUE (TREE_OPERAND (arg, 1));
7455             exponent = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg, 1)));
7456             break;
7457           default:
7458             break;
7459           }
7460
7461           /* Now perform the optimization.  */
7462           if (x && exponent)
7463             {
7464               tree logfn;
7465               arglist = build_tree_list (NULL_TREE, x);
7466               logfn = build_function_call_expr (fndecl, arglist);
7467               return fold_build2 (MULT_EXPR, type, exponent, logfn);
7468             }
7469         }
7470     }
7471
7472   return 0;
7473 }
7474
7475 /* Fold a builtin function call to pow, powf, or powl.  Return
7476    NULL_TREE if no simplification can be made.  */
7477 static tree
7478 fold_builtin_pow (tree fndecl, tree arglist, tree type)
7479 {
7480   tree arg0 = TREE_VALUE (arglist);
7481   tree arg1 = TREE_VALUE (TREE_CHAIN (arglist));
7482
7483   if (!validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
7484     return NULL_TREE;
7485
7486   /* Optimize pow(1.0,y) = 1.0.  */
7487   if (real_onep (arg0))
7488     return omit_one_operand (type, build_real (type, dconst1), arg1);
7489
7490   if (TREE_CODE (arg1) == REAL_CST
7491       && ! TREE_CONSTANT_OVERFLOW (arg1))
7492     {
7493       REAL_VALUE_TYPE cint;
7494       REAL_VALUE_TYPE c;
7495       HOST_WIDE_INT n;
7496
7497       c = TREE_REAL_CST (arg1);
7498
7499       /* Optimize pow(x,0.0) = 1.0.  */
7500       if (REAL_VALUES_EQUAL (c, dconst0))
7501         return omit_one_operand (type, build_real (type, dconst1),
7502                                  arg0);
7503
7504       /* Optimize pow(x,1.0) = x.  */
7505       if (REAL_VALUES_EQUAL (c, dconst1))
7506         return arg0;
7507
7508       /* Optimize pow(x,-1.0) = 1.0/x.  */
7509       if (REAL_VALUES_EQUAL (c, dconstm1))
7510         return fold_build2 (RDIV_EXPR, type,
7511                             build_real (type, dconst1), arg0);
7512
7513       /* Optimize pow(x,0.5) = sqrt(x).  */
7514       if (flag_unsafe_math_optimizations
7515           && REAL_VALUES_EQUAL (c, dconsthalf))
7516         {
7517           tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
7518
7519           if (sqrtfn != NULL_TREE)
7520             {
7521               tree arglist = build_tree_list (NULL_TREE, arg0);
7522               return build_function_call_expr (sqrtfn, arglist);
7523             }
7524         }
7525
7526       /* Check for an integer exponent.  */
7527       n = real_to_integer (&c);
7528       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
7529       if (real_identical (&c, &cint))
7530         {
7531           /* Attempt to evaluate pow at compile-time.  */
7532           if (TREE_CODE (arg0) == REAL_CST
7533               && ! TREE_CONSTANT_OVERFLOW (arg0))
7534             {
7535               REAL_VALUE_TYPE x;
7536               bool inexact;
7537
7538               x = TREE_REAL_CST (arg0);
7539               inexact = real_powi (&x, TYPE_MODE (type), &x, n);
7540               if (flag_unsafe_math_optimizations || !inexact)
7541                 return build_real (type, x);
7542             }
7543
7544           /* Strip sign ops from even integer powers.  */
7545           if ((n & 1) == 0 && flag_unsafe_math_optimizations)
7546             {
7547               tree narg0 = fold_strip_sign_ops (arg0);
7548               if (narg0)
7549                 {
7550                   arglist = build_tree_list (NULL_TREE, arg1);
7551                   arglist = tree_cons (NULL_TREE, narg0, arglist);
7552                   return build_function_call_expr (fndecl, arglist);
7553                 }
7554             }
7555         }
7556     }
7557
7558   if (flag_unsafe_math_optimizations)
7559     {
7560       const enum built_in_function fcode = builtin_mathfn_code (arg0);
7561
7562       /* Optimize pow(expN(x),y) = expN(x*y).  */
7563       if (BUILTIN_EXPONENT_P (fcode))
7564         {
7565           tree expfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7566           tree arg = TREE_VALUE (TREE_OPERAND (arg0, 1));
7567           arg = fold_build2 (MULT_EXPR, type, arg, arg1);
7568           arglist = build_tree_list (NULL_TREE, arg);
7569           return build_function_call_expr (expfn, arglist);
7570         }
7571
7572       /* Optimize pow(sqrt(x),y) = pow(x,y*0.5).  */
7573       if (BUILTIN_SQRT_P (fcode))
7574         {
7575           tree narg0 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7576           tree narg1 = fold_build2 (MULT_EXPR, type, arg1,
7577                                     build_real (type, dconsthalf));
7578
7579           arglist = tree_cons (NULL_TREE, narg0,
7580                                build_tree_list (NULL_TREE, narg1));
7581           return build_function_call_expr (fndecl, arglist);
7582         }
7583
7584       /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative.  */
7585       if (BUILTIN_CBRT_P (fcode))
7586         {
7587           tree arg = TREE_VALUE (TREE_OPERAND (arg0, 1));
7588           if (tree_expr_nonnegative_p (arg))
7589             {
7590               const REAL_VALUE_TYPE dconstroot
7591                 = real_value_truncate (TYPE_MODE (type), dconstthird);
7592               tree narg1 = fold_build2 (MULT_EXPR, type, arg1,
7593                                         build_real (type, dconstroot));
7594               arglist = tree_cons (NULL_TREE, arg,
7595                                    build_tree_list (NULL_TREE, narg1));
7596               return build_function_call_expr (fndecl, arglist);
7597             }
7598         }
7599
7600       /* Optimize pow(pow(x,y),z) = pow(x,y*z).  */
7601       if (fcode == BUILT_IN_POW || fcode == BUILT_IN_POWF
7602            || fcode == BUILT_IN_POWL)
7603         {
7604           tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7605           tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0, 1)));
7606           tree narg1 = fold_build2 (MULT_EXPR, type, arg01, arg1);
7607           arglist = tree_cons (NULL_TREE, arg00,
7608                                build_tree_list (NULL_TREE, narg1));
7609           return build_function_call_expr (fndecl, arglist);
7610         }
7611     }
7612
7613   return NULL_TREE;
7614 }
7615
7616 /* Fold a builtin function call to powi, powif, or powil.  Return
7617    NULL_TREE if no simplification can be made.  */
7618 static tree
7619 fold_builtin_powi (tree fndecl ATTRIBUTE_UNUSED, tree arglist, tree type)
7620 {
7621   tree arg0 = TREE_VALUE (arglist);
7622   tree arg1 = TREE_VALUE (TREE_CHAIN (arglist));
7623
7624   if (!validate_arglist (arglist, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
7625     return NULL_TREE;
7626
7627   /* Optimize pow(1.0,y) = 1.0.  */
7628   if (real_onep (arg0))
7629     return omit_one_operand (type, build_real (type, dconst1), arg1);
7630
7631   if (host_integerp (arg1, 0))
7632     {
7633       HOST_WIDE_INT c = TREE_INT_CST_LOW (arg1);
7634
7635       /* Evaluate powi at compile-time.  */
7636       if (TREE_CODE (arg0) == REAL_CST
7637           && ! TREE_CONSTANT_OVERFLOW (arg0))
7638         {
7639           REAL_VALUE_TYPE x;
7640           x = TREE_REAL_CST (arg0);
7641           real_powi (&x, TYPE_MODE (type), &x, c);
7642           return build_real (type, x);
7643         }
7644
7645       /* Optimize pow(x,0) = 1.0.  */
7646       if (c == 0)
7647         return omit_one_operand (type, build_real (type, dconst1),
7648                                  arg0);
7649
7650       /* Optimize pow(x,1) = x.  */
7651       if (c == 1)
7652         return arg0;
7653
7654       /* Optimize pow(x,-1) = 1.0/x.  */
7655       if (c == -1)
7656         return fold_build2 (RDIV_EXPR, type,
7657                            build_real (type, dconst1), arg0);
7658     }
7659
7660   return NULL_TREE;
7661 }
7662
7663 /* A subroutine of fold_builtin to fold the various exponent
7664    functions.  EXP is the CALL_EXPR of a call to a builtin function.
7665    VALUE is the value which will be raised to a power.  */
7666
7667 static tree
7668 fold_builtin_exponent (tree fndecl, tree arglist,
7669                        const REAL_VALUE_TYPE *value)
7670 {
7671   if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7672     {
7673       tree type = TREE_TYPE (TREE_TYPE (fndecl));
7674       tree arg = TREE_VALUE (arglist);
7675
7676       /* Optimize exp*(0.0) = 1.0.  */
7677       if (real_zerop (arg))
7678         return build_real (type, dconst1);
7679
7680       /* Optimize expN(1.0) = N.  */
7681       if (real_onep (arg))
7682         {
7683           REAL_VALUE_TYPE cst;
7684
7685           real_convert (&cst, TYPE_MODE (type), value);
7686           return build_real (type, cst);
7687         }
7688
7689       /* Attempt to evaluate expN(integer) at compile-time.  */
7690       if (flag_unsafe_math_optimizations
7691           && TREE_CODE (arg) == REAL_CST
7692           && ! TREE_CONSTANT_OVERFLOW (arg))
7693         {
7694           REAL_VALUE_TYPE cint;
7695           REAL_VALUE_TYPE c;
7696           HOST_WIDE_INT n;
7697
7698           c = TREE_REAL_CST (arg);
7699           n = real_to_integer (&c);
7700           real_from_integer (&cint, VOIDmode, n,
7701                              n < 0 ? -1 : 0, 0);
7702           if (real_identical (&c, &cint))
7703             {
7704               REAL_VALUE_TYPE x;
7705
7706               real_powi (&x, TYPE_MODE (type), value, n);
7707               return build_real (type, x);
7708             }
7709         }
7710
7711       /* Optimize expN(logN(x)) = x.  */
7712       if (flag_unsafe_math_optimizations)
7713         {
7714           const enum built_in_function fcode = builtin_mathfn_code (arg);
7715
7716           if ((value == &dconste
7717                && (fcode == BUILT_IN_LOG
7718                    || fcode == BUILT_IN_LOGF
7719                    || fcode == BUILT_IN_LOGL))
7720               || (value == &dconst2
7721                   && (fcode == BUILT_IN_LOG2
7722                       || fcode == BUILT_IN_LOG2F
7723                       || fcode == BUILT_IN_LOG2L))
7724               || (value == &dconst10
7725                   && (fcode == BUILT_IN_LOG10
7726                       || fcode == BUILT_IN_LOG10F
7727                       || fcode == BUILT_IN_LOG10L)))
7728             return fold_convert (type, TREE_VALUE (TREE_OPERAND (arg, 1)));
7729         }
7730     }
7731
7732   return 0;
7733 }
7734
7735 /* Fold function call to builtin memcpy.  Return
7736    NULL_TREE if no simplification can be made.  */
7737
7738 static tree
7739 fold_builtin_memcpy (tree fndecl, tree arglist)
7740 {
7741   tree dest, src, len;
7742
7743   if (!validate_arglist (arglist,
7744                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
7745     return 0;
7746
7747   dest = TREE_VALUE (arglist);
7748   src = TREE_VALUE (TREE_CHAIN (arglist));
7749   len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
7750
7751   /* If the LEN parameter is zero, return DEST.  */
7752   if (integer_zerop (len))
7753     return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
7754
7755   /* If SRC and DEST are the same (and not volatile), return DEST.  */
7756   if (operand_equal_p (src, dest, 0))
7757     return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
7758
7759   return 0;
7760 }
7761
7762 /* Fold function call to builtin mempcpy.  Return
7763    NULL_TREE if no simplification can be made.  */
7764
7765 static tree
7766 fold_builtin_mempcpy (tree arglist, tree type, int endp)
7767 {
7768   if (validate_arglist (arglist,
7769                         POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
7770     {
7771       tree dest = TREE_VALUE (arglist);
7772       tree src = TREE_VALUE (TREE_CHAIN (arglist));
7773       tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
7774
7775       /* If the LEN parameter is zero, return DEST.  */
7776       if (integer_zerop (len))
7777         return omit_one_operand (type, dest, src);
7778
7779       /* If SRC and DEST are the same (and not volatile), return DEST+LEN.  */
7780       if (operand_equal_p (src, dest, 0))
7781         {
7782           if (endp == 0)
7783             return omit_one_operand (type, dest, len);
7784
7785           if (endp == 2)
7786             len = fold_build2 (MINUS_EXPR, TREE_TYPE (len), len,
7787                                ssize_int (1));
7788
7789           len = fold_convert (TREE_TYPE (dest), len);
7790           len = fold_build2 (PLUS_EXPR, TREE_TYPE (dest), dest, len);
7791           return fold_convert (type, len);
7792         }
7793     }
7794   return 0;
7795 }
7796
7797 /* Fold function call to builtin memmove.  Return
7798    NULL_TREE if no simplification can be made.  */
7799
7800 static tree
7801 fold_builtin_memmove (tree arglist, tree type)
7802 {
7803   tree dest, src, len;
7804
7805   if (!validate_arglist (arglist,
7806                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
7807     return 0;
7808
7809   dest = TREE_VALUE (arglist);
7810   src = TREE_VALUE (TREE_CHAIN (arglist));
7811   len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
7812
7813   /* If the LEN parameter is zero, return DEST.  */
7814   if (integer_zerop (len))
7815     return omit_one_operand (type, dest, src);
7816
7817   /* If SRC and DEST are the same (and not volatile), return DEST.  */
7818   if (operand_equal_p (src, dest, 0))
7819     return omit_one_operand (type, dest, len);
7820
7821   return 0;
7822 }
7823
7824 /* Fold function call to builtin strcpy.  If LEN is not NULL, it represents
7825    the length of the string to be copied.  Return NULL_TREE if no
7826    simplification can be made.  */
7827
7828 tree
7829 fold_builtin_strcpy (tree fndecl, tree arglist, tree len)
7830 {
7831   tree dest, src, fn;
7832
7833   if (!validate_arglist (arglist,
7834                          POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
7835     return 0;
7836
7837   dest = TREE_VALUE (arglist);
7838   src = TREE_VALUE (TREE_CHAIN (arglist));
7839
7840   /* If SRC and DEST are the same (and not volatile), return DEST.  */
7841   if (operand_equal_p (src, dest, 0))
7842     return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), dest);
7843
7844   if (optimize_size)
7845     return 0;
7846
7847   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
7848   if (!fn)
7849     return 0;
7850
7851   if (!len)
7852     {
7853       len = c_strlen (src, 1);
7854       if (! len || TREE_SIDE_EFFECTS (len))
7855         return 0;
7856     }
7857
7858   len = size_binop (PLUS_EXPR, len, ssize_int (1));
7859   arglist = build_tree_list (NULL_TREE, len);
7860   arglist = tree_cons (NULL_TREE, src, arglist);
7861   arglist = tree_cons (NULL_TREE, dest, arglist);
7862   return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)),
7863                        build_function_call_expr (fn, arglist));
7864 }
7865
7866 /* Fold function call to builtin strncpy.  If SLEN is not NULL, it represents
7867    the length of the source string.  Return NULL_TREE if no simplification
7868    can be made.  */
7869
7870 tree
7871 fold_builtin_strncpy (tree fndecl, tree arglist, tree slen)
7872 {
7873   tree dest, src, len, fn;
7874
7875   if (!validate_arglist (arglist,
7876                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
7877     return 0;
7878
7879   dest = TREE_VALUE (arglist);
7880   src = TREE_VALUE (TREE_CHAIN (arglist));
7881   len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
7882
7883   /* If the LEN parameter is zero, return DEST.  */
7884   if (integer_zerop (len))
7885     return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
7886
7887   /* We can't compare slen with len as constants below if len is not a
7888      constant.  */
7889   if (len == 0 || TREE_CODE (len) != INTEGER_CST)
7890     return 0;
7891
7892   if (!slen)
7893     slen = c_strlen (src, 1);
7894
7895   /* Now, we must be passed a constant src ptr parameter.  */
7896   if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
7897     return 0;
7898
7899   slen = size_binop (PLUS_EXPR, slen, ssize_int (1));
7900
7901   /* We do not support simplification of this case, though we do
7902      support it when expanding trees into RTL.  */
7903   /* FIXME: generate a call to __builtin_memset.  */
7904   if (tree_int_cst_lt (slen, len))
7905     return 0;
7906
7907   /* OK transform into builtin memcpy.  */
7908   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
7909   if (!fn)
7910     return 0;
7911   return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)),
7912                        build_function_call_expr (fn, arglist));
7913 }
7914
7915 /* Fold function call to builtin memcmp.  Return
7916    NULL_TREE if no simplification can be made.  */
7917
7918 static tree
7919 fold_builtin_memcmp (tree arglist)
7920 {
7921   tree arg1, arg2, len;
7922   const char *p1, *p2;
7923
7924   if (!validate_arglist (arglist,
7925                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
7926     return 0;
7927
7928   arg1 = TREE_VALUE (arglist);
7929   arg2 = TREE_VALUE (TREE_CHAIN (arglist));
7930   len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
7931
7932   /* If the LEN parameter is zero, return zero.  */
7933   if (integer_zerop (len))
7934     return omit_two_operands (integer_type_node, integer_zero_node,
7935                               arg1, arg2);
7936
7937   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
7938   if (operand_equal_p (arg1, arg2, 0))
7939     return omit_one_operand (integer_type_node, integer_zero_node, len);
7940
7941   p1 = c_getstr (arg1);
7942   p2 = c_getstr (arg2);
7943
7944   /* If all arguments are constant, and the value of len is not greater
7945      than the lengths of arg1 and arg2, evaluate at compile-time.  */
7946   if (host_integerp (len, 1) && p1 && p2
7947       && compare_tree_int (len, strlen (p1) + 1) <= 0
7948       && compare_tree_int (len, strlen (p2) + 1) <= 0)
7949     {
7950       const int r = memcmp (p1, p2, tree_low_cst (len, 1));
7951
7952       if (r > 0)
7953         return integer_one_node;
7954       else if (r < 0)
7955         return integer_minus_one_node;
7956       else
7957         return integer_zero_node;
7958     }
7959
7960   /* If len parameter is one, return an expression corresponding to
7961      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
7962   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
7963     {
7964       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
7965       tree cst_uchar_ptr_node
7966         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
7967
7968       tree ind1 = fold_convert (integer_type_node,
7969                                 build1 (INDIRECT_REF, cst_uchar_node,
7970                                         fold_convert (cst_uchar_ptr_node,
7971                                                       arg1)));
7972       tree ind2 = fold_convert (integer_type_node,
7973                                 build1 (INDIRECT_REF, cst_uchar_node,
7974                                         fold_convert (cst_uchar_ptr_node,
7975                                                       arg2)));
7976       return fold_build2 (MINUS_EXPR, integer_type_node, ind1, ind2);
7977     }
7978
7979   return 0;
7980 }
7981
7982 /* Fold function call to builtin strcmp.  Return
7983    NULL_TREE if no simplification can be made.  */
7984
7985 static tree
7986 fold_builtin_strcmp (tree arglist)
7987 {
7988   tree arg1, arg2;
7989   const char *p1, *p2;
7990
7991   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
7992     return 0;
7993
7994   arg1 = TREE_VALUE (arglist);
7995   arg2 = TREE_VALUE (TREE_CHAIN (arglist));
7996
7997   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
7998   if (operand_equal_p (arg1, arg2, 0))
7999     return integer_zero_node;
8000
8001   p1 = c_getstr (arg1);
8002   p2 = c_getstr (arg2);
8003
8004   if (p1 && p2)
8005     {
8006       const int i = strcmp (p1, p2);
8007       if (i < 0)
8008         return integer_minus_one_node;
8009       else if (i > 0)
8010         return integer_one_node;
8011       else
8012         return integer_zero_node;
8013     }
8014
8015   /* If the second arg is "", return *(const unsigned char*)arg1.  */
8016   if (p2 && *p2 == '\0')
8017     {
8018       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8019       tree cst_uchar_ptr_node
8020         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8021
8022       return fold_convert (integer_type_node,
8023                            build1 (INDIRECT_REF, cst_uchar_node,
8024                                    fold_convert (cst_uchar_ptr_node,
8025                                                  arg1)));
8026     }
8027
8028   /* If the first arg is "", return -*(const unsigned char*)arg2.  */
8029   if (p1 && *p1 == '\0')
8030     {
8031       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8032       tree cst_uchar_ptr_node
8033         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8034
8035       tree temp = fold_convert (integer_type_node,
8036                                 build1 (INDIRECT_REF, cst_uchar_node,
8037                                         fold_convert (cst_uchar_ptr_node,
8038                                                       arg2)));
8039       return fold_build1 (NEGATE_EXPR, integer_type_node, temp);
8040     }
8041
8042   return 0;
8043 }
8044
8045 /* Fold function call to builtin strncmp.  Return
8046    NULL_TREE if no simplification can be made.  */
8047
8048 static tree
8049 fold_builtin_strncmp (tree arglist)
8050 {
8051   tree arg1, arg2, len;
8052   const char *p1, *p2;
8053
8054   if (!validate_arglist (arglist,
8055                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
8056     return 0;
8057
8058   arg1 = TREE_VALUE (arglist);
8059   arg2 = TREE_VALUE (TREE_CHAIN (arglist));
8060   len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
8061
8062   /* If the LEN parameter is zero, return zero.  */
8063   if (integer_zerop (len))
8064     return omit_two_operands (integer_type_node, integer_zero_node,
8065                               arg1, arg2);
8066
8067   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
8068   if (operand_equal_p (arg1, arg2, 0))
8069     return omit_one_operand (integer_type_node, integer_zero_node, len);
8070
8071   p1 = c_getstr (arg1);
8072   p2 = c_getstr (arg2);
8073
8074   if (host_integerp (len, 1) && p1 && p2)
8075     {
8076       const int i = strncmp (p1, p2, tree_low_cst (len, 1));
8077       if (i > 0)
8078         return integer_one_node;
8079       else if (i < 0)
8080         return integer_minus_one_node;
8081       else
8082         return integer_zero_node;
8083     }
8084
8085   /* If the second arg is "", and the length is greater than zero,
8086      return *(const unsigned char*)arg1.  */
8087   if (p2 && *p2 == '\0'
8088       && TREE_CODE (len) == INTEGER_CST
8089       && tree_int_cst_sgn (len) == 1)
8090     {
8091       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8092       tree cst_uchar_ptr_node
8093         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8094
8095       return fold_convert (integer_type_node,
8096                            build1 (INDIRECT_REF, cst_uchar_node,
8097                                    fold_convert (cst_uchar_ptr_node,
8098                                                  arg1)));
8099     }
8100
8101   /* If the first arg is "", and the length is greater than zero,
8102      return -*(const unsigned char*)arg2.  */
8103   if (p1 && *p1 == '\0'
8104       && TREE_CODE (len) == INTEGER_CST
8105       && tree_int_cst_sgn (len) == 1)
8106     {
8107       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8108       tree cst_uchar_ptr_node
8109         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8110
8111       tree temp = fold_convert (integer_type_node,
8112                                 build1 (INDIRECT_REF, cst_uchar_node,
8113                                         fold_convert (cst_uchar_ptr_node,
8114                                                       arg2)));
8115       return fold_build1 (NEGATE_EXPR, integer_type_node, temp);
8116     }
8117
8118   /* If len parameter is one, return an expression corresponding to
8119      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
8120   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
8121     {
8122       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8123       tree cst_uchar_ptr_node
8124         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8125
8126       tree ind1 = fold_convert (integer_type_node,
8127                                 build1 (INDIRECT_REF, cst_uchar_node,
8128                                         fold_convert (cst_uchar_ptr_node,
8129                                                       arg1)));
8130       tree ind2 = fold_convert (integer_type_node,
8131                                 build1 (INDIRECT_REF, cst_uchar_node,
8132                                         fold_convert (cst_uchar_ptr_node,
8133                                                       arg2)));
8134       return fold_build2 (MINUS_EXPR, integer_type_node, ind1, ind2);
8135     }
8136
8137   return 0;
8138 }
8139
8140 /* Fold function call to builtin signbit, signbitf or signbitl.  Return
8141    NULL_TREE if no simplification can be made.  */
8142
8143 static tree
8144 fold_builtin_signbit (tree fndecl, tree arglist)
8145 {
8146   tree type = TREE_TYPE (TREE_TYPE (fndecl));
8147   tree arg, temp;
8148
8149   if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
8150     return NULL_TREE;
8151
8152   arg = TREE_VALUE (arglist);
8153
8154   /* If ARG is a compile-time constant, determine the result.  */
8155   if (TREE_CODE (arg) == REAL_CST
8156       && !TREE_CONSTANT_OVERFLOW (arg))
8157     {
8158       REAL_VALUE_TYPE c;
8159
8160       c = TREE_REAL_CST (arg);
8161       temp = REAL_VALUE_NEGATIVE (c) ? integer_one_node : integer_zero_node;
8162       return fold_convert (type, temp);
8163     }
8164
8165   /* If ARG is non-negative, the result is always zero.  */
8166   if (tree_expr_nonnegative_p (arg))
8167     return omit_one_operand (type, integer_zero_node, arg);
8168
8169   /* If ARG's format doesn't have signed zeros, return "arg < 0.0".  */
8170   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
8171     return fold_build2 (LT_EXPR, type, arg,
8172                         build_real (TREE_TYPE (arg), dconst0));
8173
8174   return NULL_TREE;
8175 }
8176
8177 /* Fold function call to builtin copysign, copysignf or copysignl.
8178    Return NULL_TREE if no simplification can be made.  */
8179
8180 static tree
8181 fold_builtin_copysign (tree fndecl, tree arglist, tree type)
8182 {
8183   tree arg1, arg2, tem;
8184
8185   if (!validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
8186     return NULL_TREE;
8187
8188   arg1 = TREE_VALUE (arglist);
8189   arg2 = TREE_VALUE (TREE_CHAIN (arglist));
8190
8191   /* copysign(X,X) is X.  */
8192   if (operand_equal_p (arg1, arg2, 0))
8193     return fold_convert (type, arg1);
8194
8195   /* If ARG1 and ARG2 are compile-time constants, determine the result.  */
8196   if (TREE_CODE (arg1) == REAL_CST
8197       && TREE_CODE (arg2) == REAL_CST
8198       && !TREE_CONSTANT_OVERFLOW (arg1)
8199       && !TREE_CONSTANT_OVERFLOW (arg2))
8200     {
8201       REAL_VALUE_TYPE c1, c2;
8202
8203       c1 = TREE_REAL_CST (arg1);
8204       c2 = TREE_REAL_CST (arg2);
8205       real_copysign (&c1, &c2);
8206       return build_real (type, c1);
8207       c1.sign = c2.sign;
8208     }
8209
8210   /* copysign(X, Y) is fabs(X) when Y is always non-negative.
8211      Remember to evaluate Y for side-effects.  */
8212   if (tree_expr_nonnegative_p (arg2))
8213     return omit_one_operand (type,
8214                              fold_build1 (ABS_EXPR, type, arg1),
8215                              arg2);
8216
8217   /* Strip sign changing operations for the first argument.  */
8218   tem = fold_strip_sign_ops (arg1);
8219   if (tem)
8220     {
8221       arglist = tree_cons (NULL_TREE, tem, TREE_CHAIN (arglist));
8222       return build_function_call_expr (fndecl, arglist);
8223     }
8224
8225   return NULL_TREE;
8226 }
8227
8228 /* Fold a call to builtin isascii.  */
8229
8230 static tree
8231 fold_builtin_isascii (tree arglist)
8232 {
8233   if (! validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
8234     return 0;
8235   else
8236     {
8237       /* Transform isascii(c) -> ((c & ~0x7f) == 0).  */
8238       tree arg = TREE_VALUE (arglist);
8239
8240       arg = build2 (BIT_AND_EXPR, integer_type_node, arg,
8241                     build_int_cst (NULL_TREE,
8242                                    ~ (unsigned HOST_WIDE_INT) 0x7f));
8243       arg = fold_build2 (EQ_EXPR, integer_type_node,
8244                          arg, integer_zero_node);
8245
8246       if (in_gimple_form && !TREE_CONSTANT (arg))
8247         return NULL_TREE;
8248       else
8249         return arg;
8250     }
8251 }
8252
8253 /* Fold a call to builtin toascii.  */
8254
8255 static tree
8256 fold_builtin_toascii (tree arglist)
8257 {
8258   if (! validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
8259     return 0;
8260   else
8261     {
8262       /* Transform toascii(c) -> (c & 0x7f).  */
8263       tree arg = TREE_VALUE (arglist);
8264
8265       return fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
8266                           build_int_cst (NULL_TREE, 0x7f));
8267     }
8268 }
8269
8270 /* Fold a call to builtin isdigit.  */
8271
8272 static tree
8273 fold_builtin_isdigit (tree arglist)
8274 {
8275   if (! validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
8276     return 0;
8277   else
8278     {
8279       /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9.  */
8280       /* According to the C standard, isdigit is unaffected by locale.
8281          However, it definitely is affected by the target character set.  */
8282       tree arg;
8283       unsigned HOST_WIDE_INT target_digit0
8284         = lang_hooks.to_target_charset ('0');
8285
8286       if (target_digit0 == 0)
8287         return NULL_TREE;
8288
8289       arg = fold_convert (unsigned_type_node, TREE_VALUE (arglist));
8290       arg = build2 (MINUS_EXPR, unsigned_type_node, arg,
8291                     build_int_cst (unsigned_type_node, target_digit0));
8292       arg = fold_build2 (LE_EXPR, integer_type_node, arg,
8293                          build_int_cst (unsigned_type_node, 9));
8294       if (in_gimple_form && !TREE_CONSTANT (arg))
8295         return NULL_TREE;
8296       else
8297         return arg;
8298     }
8299 }
8300
8301 /* Fold a call to fabs, fabsf or fabsl.  */
8302
8303 static tree
8304 fold_builtin_fabs (tree arglist, tree type)
8305 {
8306   tree arg;
8307
8308   if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
8309     return 0;
8310
8311   arg = TREE_VALUE (arglist);
8312   arg = fold_convert (type, arg);
8313   if (TREE_CODE (arg) == REAL_CST)
8314     return fold_abs_const (arg, type);
8315   return fold_build1 (ABS_EXPR, type, arg);
8316 }
8317
8318 /* Fold a call to abs, labs, llabs or imaxabs.  */
8319
8320 static tree
8321 fold_builtin_abs (tree arglist, tree type)
8322 {
8323   tree arg;
8324
8325   if (!validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
8326     return 0;
8327
8328   arg = TREE_VALUE (arglist);
8329   arg = fold_convert (type, arg);
8330   if (TREE_CODE (arg) == INTEGER_CST)
8331     return fold_abs_const (arg, type);
8332   return fold_build1 (ABS_EXPR, type, arg);
8333 }
8334
8335 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
8336    EXP is the CALL_EXPR for the call.  */
8337
8338 static tree
8339 fold_builtin_classify (tree fndecl, tree arglist, int builtin_index)
8340 {
8341   tree type = TREE_TYPE (TREE_TYPE (fndecl));
8342   tree arg;
8343   REAL_VALUE_TYPE r;
8344
8345   if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
8346     {
8347       /* Check that we have exactly one argument.  */
8348       if (arglist == 0)
8349         {
8350           error ("too few arguments to function %qs",
8351                  IDENTIFIER_POINTER (DECL_NAME (fndecl)));
8352           return error_mark_node;
8353         }
8354       else if (TREE_CHAIN (arglist) != 0)
8355         {
8356           error ("too many arguments to function %qs",
8357                  IDENTIFIER_POINTER (DECL_NAME (fndecl)));
8358           return error_mark_node;
8359         }
8360       else
8361         {
8362           error ("non-floating-point argument to function %qs",
8363                  IDENTIFIER_POINTER (DECL_NAME (fndecl)));
8364           return error_mark_node;
8365         }
8366     }
8367
8368   arg = TREE_VALUE (arglist);
8369   switch (builtin_index)
8370     {
8371     case BUILT_IN_ISINF:
8372       if (!MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
8373         return omit_one_operand (type, integer_zero_node, arg);
8374
8375       if (TREE_CODE (arg) == REAL_CST)
8376         {
8377           r = TREE_REAL_CST (arg);
8378           if (real_isinf (&r))
8379             return real_compare (GT_EXPR, &r, &dconst0)
8380                    ? integer_one_node : integer_minus_one_node;
8381           else
8382             return integer_zero_node;
8383         }
8384
8385       return NULL_TREE;
8386
8387     case BUILT_IN_FINITE:
8388       if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg)))
8389           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
8390         return omit_one_operand (type, integer_zero_node, arg);
8391
8392       if (TREE_CODE (arg) == REAL_CST)
8393         {
8394           r = TREE_REAL_CST (arg);
8395           return real_isinf (&r) || real_isnan (&r)
8396                  ? integer_zero_node : integer_one_node;
8397         }
8398
8399       return NULL_TREE;
8400
8401     case BUILT_IN_ISNAN:
8402       if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg))))
8403         return omit_one_operand (type, integer_zero_node, arg);
8404
8405       if (TREE_CODE (arg) == REAL_CST)
8406         {
8407           r = TREE_REAL_CST (arg);
8408           return real_isnan (&r) ? integer_one_node : integer_zero_node;
8409         }
8410
8411       arg = builtin_save_expr (arg);
8412       return fold_build2 (UNORDERED_EXPR, type, arg, arg);
8413
8414     default:
8415       gcc_unreachable ();
8416     }
8417 }
8418
8419 /* Fold a call to an unordered comparison function such as
8420    __builtin_isgreater().  FNDECL is the FUNCTION_DECL for the function
8421    being called and ARGLIST is the argument list for the call.
8422    UNORDERED_CODE and ORDERED_CODE are comparison codes that give
8423    the opposite of the desired result.  UNORDERED_CODE is used
8424    for modes that can hold NaNs and ORDERED_CODE is used for
8425    the rest.  */
8426
8427 static tree
8428 fold_builtin_unordered_cmp (tree fndecl, tree arglist,
8429                             enum tree_code unordered_code,
8430                             enum tree_code ordered_code)
8431 {
8432   tree type = TREE_TYPE (TREE_TYPE (fndecl));
8433   enum tree_code code;
8434   tree arg0, arg1;
8435   tree type0, type1;
8436   enum tree_code code0, code1;
8437   tree cmp_type = NULL_TREE;
8438
8439   if (!validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
8440     {
8441       /* Check that we have exactly two arguments.  */
8442       if (arglist == 0 || TREE_CHAIN (arglist) == 0)
8443         {
8444           error ("too few arguments to function %qs",
8445                  IDENTIFIER_POINTER (DECL_NAME (fndecl)));
8446           return error_mark_node;
8447         }
8448       else if (TREE_CHAIN (TREE_CHAIN (arglist)) != 0)
8449         {
8450           error ("too many arguments to function %qs",
8451                  IDENTIFIER_POINTER (DECL_NAME (fndecl)));
8452           return error_mark_node;
8453         }
8454     }
8455
8456   arg0 = TREE_VALUE (arglist);
8457   arg1 = TREE_VALUE (TREE_CHAIN (arglist));
8458
8459   type0 = TREE_TYPE (arg0);
8460   type1 = TREE_TYPE (arg1);
8461
8462   code0 = TREE_CODE (type0);
8463   code1 = TREE_CODE (type1);
8464
8465   if (code0 == REAL_TYPE && code1 == REAL_TYPE)
8466     /* Choose the wider of two real types.  */
8467     cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
8468       ? type0 : type1;
8469   else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
8470     cmp_type = type0;
8471   else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
8472     cmp_type = type1;
8473   else
8474     {
8475       error ("non-floating-point argument to function %qs",
8476                  IDENTIFIER_POINTER (DECL_NAME (fndecl)));
8477       return error_mark_node;
8478     }
8479
8480   arg0 = fold_convert (cmp_type, arg0);
8481   arg1 = fold_convert (cmp_type, arg1);
8482
8483   if (unordered_code == UNORDERED_EXPR)
8484     {
8485       if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8486         return omit_two_operands (type, integer_zero_node, arg0, arg1);
8487       return fold_build2 (UNORDERED_EXPR, type, arg0, arg1);
8488     }
8489
8490   code = MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg0))) ? unordered_code
8491                                                       : ordered_code;
8492   return fold_build1 (TRUTH_NOT_EXPR, type,
8493                       fold_build2 (code, type, arg0, arg1));
8494 }
8495
8496 /* Used by constant folding to simplify calls to builtin functions.  EXP is
8497    the CALL_EXPR of a call to a builtin function.  IGNORE is true if the
8498    result of the function call is ignored.  This function returns NULL_TREE
8499    if no simplification was possible.  */
8500
8501 static tree
8502 fold_builtin_1 (tree fndecl, tree arglist, bool ignore)
8503 {
8504   tree type = TREE_TYPE (TREE_TYPE (fndecl));
8505   enum built_in_function fcode;
8506
8507   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
8508     return targetm.fold_builtin (fndecl, arglist, ignore);
8509
8510   fcode = DECL_FUNCTION_CODE (fndecl);
8511   switch (fcode)
8512     {
8513     case BUILT_IN_FPUTS:
8514       return fold_builtin_fputs (arglist, ignore, false, NULL_TREE);
8515
8516     case BUILT_IN_FPUTS_UNLOCKED:
8517       return fold_builtin_fputs (arglist, ignore, true, NULL_TREE);
8518
8519     case BUILT_IN_STRSTR:
8520       return fold_builtin_strstr (arglist, type);
8521
8522     case BUILT_IN_STRCAT:
8523       return fold_builtin_strcat (arglist);
8524
8525     case BUILT_IN_STRNCAT:
8526       return fold_builtin_strncat (arglist);
8527
8528     case BUILT_IN_STRSPN:
8529       return fold_builtin_strspn (arglist);
8530
8531     case BUILT_IN_STRCSPN:
8532       return fold_builtin_strcspn (arglist);
8533
8534     case BUILT_IN_STRCHR:
8535     case BUILT_IN_INDEX:
8536       return fold_builtin_strchr (arglist, type);
8537
8538     case BUILT_IN_STRRCHR:
8539     case BUILT_IN_RINDEX:
8540       return fold_builtin_strrchr (arglist, type);
8541
8542     case BUILT_IN_STRCPY:
8543       return fold_builtin_strcpy (fndecl, arglist, NULL_TREE);
8544
8545     case BUILT_IN_STRNCPY:
8546       return fold_builtin_strncpy (fndecl, arglist, NULL_TREE);
8547
8548     case BUILT_IN_STRCMP:
8549       return fold_builtin_strcmp (arglist);
8550
8551     case BUILT_IN_STRNCMP:
8552       return fold_builtin_strncmp (arglist);
8553
8554     case BUILT_IN_STRPBRK:
8555       return fold_builtin_strpbrk (arglist, type);
8556
8557     case BUILT_IN_BCMP:
8558     case BUILT_IN_MEMCMP:
8559       return fold_builtin_memcmp (arglist);
8560
8561     case BUILT_IN_SPRINTF:
8562       return fold_builtin_sprintf (arglist, ignore);
8563
8564     case BUILT_IN_CONSTANT_P:
8565       {
8566         tree val;
8567
8568         val = fold_builtin_constant_p (arglist);
8569         /* Gimplification will pull the CALL_EXPR for the builtin out of
8570            an if condition.  When not optimizing, we'll not CSE it back.
8571            To avoid link error types of regressions, return false now.  */
8572         if (!val && !optimize)
8573           val = integer_zero_node;
8574
8575         return val;
8576       }
8577
8578     case BUILT_IN_EXPECT:
8579       return fold_builtin_expect (arglist);
8580
8581     case BUILT_IN_CLASSIFY_TYPE:
8582       return fold_builtin_classify_type (arglist);
8583
8584     case BUILT_IN_STRLEN:
8585       return fold_builtin_strlen (arglist);
8586
8587     CASE_FLT_FN (BUILT_IN_FABS):
8588       return fold_builtin_fabs (arglist, type);
8589
8590     case BUILT_IN_ABS:
8591     case BUILT_IN_LABS:
8592     case BUILT_IN_LLABS:
8593     case BUILT_IN_IMAXABS:
8594       return fold_builtin_abs (arglist, type);
8595
8596     CASE_FLT_FN (BUILT_IN_CONJ):
8597       if (validate_arglist (arglist, COMPLEX_TYPE, VOID_TYPE))
8598         return fold_build1 (CONJ_EXPR, type, TREE_VALUE (arglist));
8599       break;
8600
8601     CASE_FLT_FN (BUILT_IN_CREAL):
8602       if (validate_arglist (arglist, COMPLEX_TYPE, VOID_TYPE))
8603         return non_lvalue (fold_build1 (REALPART_EXPR, type,
8604                                         TREE_VALUE (arglist)));
8605       break;
8606
8607     CASE_FLT_FN (BUILT_IN_CIMAG):
8608       if (validate_arglist (arglist, COMPLEX_TYPE, VOID_TYPE))
8609         return non_lvalue (fold_build1 (IMAGPART_EXPR, type,
8610                                         TREE_VALUE (arglist)));
8611       break;
8612
8613     CASE_FLT_FN (BUILT_IN_CABS):
8614       return fold_builtin_cabs (arglist, type);
8615
8616     CASE_FLT_FN (BUILT_IN_SQRT):
8617       return fold_builtin_sqrt (arglist, type);
8618
8619     CASE_FLT_FN (BUILT_IN_CBRT):
8620       return fold_builtin_cbrt (arglist, type);
8621
8622     CASE_FLT_FN (BUILT_IN_SIN):
8623       return fold_builtin_sin (arglist);
8624
8625     CASE_FLT_FN (BUILT_IN_COS):
8626       return fold_builtin_cos (arglist, type, fndecl);
8627
8628     CASE_FLT_FN (BUILT_IN_EXP):
8629       return fold_builtin_exponent (fndecl, arglist, &dconste);
8630
8631     CASE_FLT_FN (BUILT_IN_EXP2):
8632       return fold_builtin_exponent (fndecl, arglist, &dconst2);
8633
8634     CASE_FLT_FN (BUILT_IN_EXP10):
8635     CASE_FLT_FN (BUILT_IN_POW10):
8636       return fold_builtin_exponent (fndecl, arglist, &dconst10);
8637
8638     CASE_FLT_FN (BUILT_IN_LOG):
8639       return fold_builtin_logarithm (fndecl, arglist, &dconste);
8640
8641     CASE_FLT_FN (BUILT_IN_LOG2):
8642       return fold_builtin_logarithm (fndecl, arglist, &dconst2);
8643
8644     CASE_FLT_FN (BUILT_IN_LOG10):
8645       return fold_builtin_logarithm (fndecl, arglist, &dconst10);
8646
8647     CASE_FLT_FN (BUILT_IN_TAN):
8648       return fold_builtin_tan (arglist);
8649
8650     CASE_FLT_FN (BUILT_IN_ATAN):
8651       return fold_builtin_atan (arglist, type);
8652
8653     CASE_FLT_FN (BUILT_IN_POW):
8654       return fold_builtin_pow (fndecl, arglist, type);
8655
8656     CASE_FLT_FN (BUILT_IN_POWI):
8657       return fold_builtin_powi (fndecl, arglist, type);
8658
8659     CASE_FLT_FN (BUILT_IN_INF):
8660     case BUILT_IN_INFD32:
8661     case BUILT_IN_INFD64:
8662     case BUILT_IN_INFD128:
8663       return fold_builtin_inf (type, true);
8664
8665     CASE_FLT_FN (BUILT_IN_HUGE_VAL):
8666       return fold_builtin_inf (type, false);
8667
8668     CASE_FLT_FN (BUILT_IN_NAN):
8669     case BUILT_IN_NAND32:
8670     case BUILT_IN_NAND64:
8671     case BUILT_IN_NAND128:
8672       return fold_builtin_nan (arglist, type, true);
8673
8674     CASE_FLT_FN (BUILT_IN_NANS):
8675       return fold_builtin_nan (arglist, type, false);
8676
8677     CASE_FLT_FN (BUILT_IN_FLOOR):
8678       return fold_builtin_floor (fndecl, arglist);
8679
8680     CASE_FLT_FN (BUILT_IN_CEIL):
8681       return fold_builtin_ceil (fndecl, arglist);
8682
8683     CASE_FLT_FN (BUILT_IN_TRUNC):
8684       return fold_builtin_trunc (fndecl, arglist);
8685
8686     CASE_FLT_FN (BUILT_IN_ROUND):
8687       return fold_builtin_round (fndecl, arglist);
8688
8689     CASE_FLT_FN (BUILT_IN_NEARBYINT):
8690     CASE_FLT_FN (BUILT_IN_RINT):
8691       return fold_trunc_transparent_mathfn (fndecl, arglist);
8692
8693     CASE_FLT_FN (BUILT_IN_LCEIL):
8694     CASE_FLT_FN (BUILT_IN_LLCEIL):
8695     CASE_FLT_FN (BUILT_IN_LFLOOR):
8696     CASE_FLT_FN (BUILT_IN_LLFLOOR):
8697     CASE_FLT_FN (BUILT_IN_LROUND):
8698     CASE_FLT_FN (BUILT_IN_LLROUND):
8699       return fold_builtin_int_roundingfn (fndecl, arglist);
8700
8701     CASE_FLT_FN (BUILT_IN_LRINT):
8702     CASE_FLT_FN (BUILT_IN_LLRINT):
8703       return fold_fixed_mathfn (fndecl, arglist);
8704
8705     CASE_INT_FN (BUILT_IN_FFS):
8706     CASE_INT_FN (BUILT_IN_CLZ):
8707     CASE_INT_FN (BUILT_IN_CTZ):
8708     CASE_INT_FN (BUILT_IN_POPCOUNT):
8709     CASE_INT_FN (BUILT_IN_PARITY):
8710       return fold_builtin_bitop (fndecl, arglist);
8711
8712     case BUILT_IN_MEMCPY:
8713       return fold_builtin_memcpy (fndecl, arglist);
8714
8715     case BUILT_IN_MEMPCPY:
8716       return fold_builtin_mempcpy (arglist, type, /*endp=*/1);
8717
8718     case BUILT_IN_MEMMOVE:
8719       return fold_builtin_memmove (arglist, type);
8720
8721     CASE_FLT_FN (BUILT_IN_SIGNBIT):
8722       return fold_builtin_signbit (fndecl, arglist);
8723
8724     case BUILT_IN_ISASCII:
8725       return fold_builtin_isascii (arglist);
8726
8727     case BUILT_IN_TOASCII:
8728       return fold_builtin_toascii (arglist);
8729
8730     case BUILT_IN_ISDIGIT:
8731       return fold_builtin_isdigit (arglist);
8732
8733     CASE_FLT_FN (BUILT_IN_COPYSIGN):
8734       return fold_builtin_copysign (fndecl, arglist, type);
8735
8736     CASE_FLT_FN (BUILT_IN_FINITE):
8737     case BUILT_IN_FINITED32:
8738     case BUILT_IN_FINITED64:
8739     case BUILT_IN_FINITED128:
8740       return fold_builtin_classify (fndecl, arglist, BUILT_IN_FINITE);
8741
8742     CASE_FLT_FN (BUILT_IN_ISINF):
8743     case BUILT_IN_ISINFD32:
8744     case BUILT_IN_ISINFD64:
8745     case BUILT_IN_ISINFD128:
8746       return fold_builtin_classify (fndecl, arglist, BUILT_IN_ISINF);
8747
8748     CASE_FLT_FN (BUILT_IN_ISNAN):
8749     case BUILT_IN_ISNAND32:
8750     case BUILT_IN_ISNAND64:
8751     case BUILT_IN_ISNAND128:
8752       return fold_builtin_classify (fndecl, arglist, BUILT_IN_ISNAN);
8753
8754     case BUILT_IN_ISGREATER:
8755       return fold_builtin_unordered_cmp (fndecl, arglist, UNLE_EXPR, LE_EXPR);
8756     case BUILT_IN_ISGREATEREQUAL:
8757       return fold_builtin_unordered_cmp (fndecl, arglist, UNLT_EXPR, LT_EXPR);
8758     case BUILT_IN_ISLESS:
8759       return fold_builtin_unordered_cmp (fndecl, arglist, UNGE_EXPR, GE_EXPR);
8760     case BUILT_IN_ISLESSEQUAL:
8761       return fold_builtin_unordered_cmp (fndecl, arglist, UNGT_EXPR, GT_EXPR);
8762     case BUILT_IN_ISLESSGREATER:
8763       return fold_builtin_unordered_cmp (fndecl, arglist, UNEQ_EXPR, EQ_EXPR);
8764     case BUILT_IN_ISUNORDERED:
8765       return fold_builtin_unordered_cmp (fndecl, arglist, UNORDERED_EXPR,
8766                                          NOP_EXPR);
8767
8768       /* We do the folding for va_start in the expander.  */
8769     case BUILT_IN_VA_START:
8770       break;
8771
8772     case BUILT_IN_OBJECT_SIZE:
8773       return fold_builtin_object_size (arglist);
8774     case BUILT_IN_MEMCPY_CHK:
8775     case BUILT_IN_MEMPCPY_CHK:
8776     case BUILT_IN_MEMMOVE_CHK:
8777     case BUILT_IN_MEMSET_CHK:
8778       return fold_builtin_memory_chk (fndecl, arglist, NULL_TREE, ignore,
8779                                       DECL_FUNCTION_CODE (fndecl));
8780     case BUILT_IN_STRCPY_CHK:
8781     case BUILT_IN_STPCPY_CHK:
8782       return fold_builtin_stxcpy_chk (fndecl, arglist, NULL_TREE, ignore,
8783                                       DECL_FUNCTION_CODE (fndecl));
8784     case BUILT_IN_STRNCPY_CHK:
8785       return fold_builtin_strncpy_chk (arglist, NULL_TREE);
8786     case BUILT_IN_STRCAT_CHK:
8787       return fold_builtin_strcat_chk (fndecl, arglist);
8788     case BUILT_IN_STRNCAT_CHK:
8789       return fold_builtin_strncat_chk (fndecl, arglist);
8790     case BUILT_IN_SPRINTF_CHK:
8791     case BUILT_IN_VSPRINTF_CHK:
8792       return fold_builtin_sprintf_chk (arglist, DECL_FUNCTION_CODE (fndecl));
8793     case BUILT_IN_SNPRINTF_CHK:
8794     case BUILT_IN_VSNPRINTF_CHK:
8795       return fold_builtin_snprintf_chk (arglist, NULL_TREE,
8796                                         DECL_FUNCTION_CODE (fndecl));
8797
8798     case BUILT_IN_PRINTF:
8799     case BUILT_IN_PRINTF_UNLOCKED:
8800     case BUILT_IN_VPRINTF:
8801     case BUILT_IN_PRINTF_CHK:
8802     case BUILT_IN_VPRINTF_CHK:
8803       return fold_builtin_printf (fndecl, arglist, ignore,
8804                                   DECL_FUNCTION_CODE (fndecl));
8805
8806     case BUILT_IN_FPRINTF:
8807     case BUILT_IN_FPRINTF_UNLOCKED:
8808     case BUILT_IN_VFPRINTF:
8809     case BUILT_IN_FPRINTF_CHK:
8810     case BUILT_IN_VFPRINTF_CHK:
8811       return fold_builtin_fprintf (fndecl, arglist, ignore,
8812                                    DECL_FUNCTION_CODE (fndecl));
8813
8814     default:
8815       break;
8816     }
8817
8818   return 0;
8819 }
8820
8821 /* A wrapper function for builtin folding that prevents warnings for
8822    "statement without effect" and the like, caused by removing the
8823    call node earlier than the warning is generated.  */
8824
8825 tree
8826 fold_builtin (tree fndecl, tree arglist, bool ignore)
8827 {
8828   tree exp = fold_builtin_1 (fndecl, arglist, ignore);
8829   if (exp)
8830     {
8831       exp = build1 (NOP_EXPR, TREE_TYPE (exp), exp);
8832       TREE_NO_WARNING (exp) = 1;
8833     }
8834
8835   return exp;
8836 }
8837
8838 /* Conveniently construct a function call expression.  */
8839
8840 tree
8841 build_function_call_expr (tree fn, tree arglist)
8842 {
8843   tree call_expr;
8844
8845   call_expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
8846   return fold_build3 (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
8847                       call_expr, arglist, NULL_TREE);
8848 }
8849
8850 /* This function validates the types of a function call argument list
8851    represented as a tree chain of parameters against a specified list
8852    of tree_codes.  If the last specifier is a 0, that represents an
8853    ellipses, otherwise the last specifier must be a VOID_TYPE.  */
8854
8855 static int
8856 validate_arglist (tree arglist, ...)
8857 {
8858   enum tree_code code;
8859   int res = 0;
8860   va_list ap;
8861
8862   va_start (ap, arglist);
8863
8864   do
8865     {
8866       code = va_arg (ap, enum tree_code);
8867       switch (code)
8868         {
8869         case 0:
8870           /* This signifies an ellipses, any further arguments are all ok.  */
8871           res = 1;
8872           goto end;
8873         case VOID_TYPE:
8874           /* This signifies an endlink, if no arguments remain, return
8875              true, otherwise return false.  */
8876           res = arglist == 0;
8877           goto end;
8878         default:
8879           /* If no parameters remain or the parameter's code does not
8880              match the specified code, return false.  Otherwise continue
8881              checking any remaining arguments.  */
8882           if (arglist == 0)
8883             goto end;
8884           if (code == POINTER_TYPE)
8885             {
8886               if (! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist))))
8887                 goto end;
8888             }
8889           else if (code != TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))))
8890             goto end;
8891           break;
8892         }
8893       arglist = TREE_CHAIN (arglist);
8894     }
8895   while (1);
8896
8897   /* We need gotos here since we can only have one VA_CLOSE in a
8898      function.  */
8899  end: ;
8900   va_end (ap);
8901
8902   return res;
8903 }
8904
8905 /* Default target-specific builtin expander that does nothing.  */
8906
8907 rtx
8908 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
8909                         rtx target ATTRIBUTE_UNUSED,
8910                         rtx subtarget ATTRIBUTE_UNUSED,
8911                         enum machine_mode mode ATTRIBUTE_UNUSED,
8912                         int ignore ATTRIBUTE_UNUSED)
8913 {
8914   return NULL_RTX;
8915 }
8916
8917 /* Returns true is EXP represents data that would potentially reside
8918    in a readonly section.  */
8919
8920 static bool
8921 readonly_data_expr (tree exp)
8922 {
8923   STRIP_NOPS (exp);
8924
8925   if (TREE_CODE (exp) != ADDR_EXPR)
8926     return false;
8927
8928   exp = get_base_address (TREE_OPERAND (exp, 0));
8929   if (!exp)
8930     return false;
8931
8932   /* Make sure we call decl_readonly_section only for trees it
8933      can handle (since it returns true for everything it doesn't
8934      understand).  */
8935   if (TREE_CODE (exp) == STRING_CST
8936       || TREE_CODE (exp) == CONSTRUCTOR
8937       || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp)))
8938     return decl_readonly_section (exp, 0);
8939   else
8940     return false;
8941 }
8942
8943 /* Simplify a call to the strstr builtin.
8944
8945    Return 0 if no simplification was possible, otherwise return the
8946    simplified form of the call as a tree.
8947
8948    The simplified form may be a constant or other expression which
8949    computes the same value, but in a more efficient manner (including
8950    calls to other builtin functions).
8951
8952    The call may contain arguments which need to be evaluated, but
8953    which are not useful to determine the result of the call.  In
8954    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
8955    COMPOUND_EXPR will be an argument which must be evaluated.
8956    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
8957    COMPOUND_EXPR in the chain will contain the tree for the simplified
8958    form of the builtin function call.  */
8959
8960 static tree
8961 fold_builtin_strstr (tree arglist, tree type)
8962 {
8963   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
8964     return 0;
8965   else
8966     {
8967       tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
8968       tree fn;
8969       const char *p1, *p2;
8970
8971       p2 = c_getstr (s2);
8972       if (p2 == NULL)
8973         return 0;
8974
8975       p1 = c_getstr (s1);
8976       if (p1 != NULL)
8977         {
8978           const char *r = strstr (p1, p2);
8979           tree tem;
8980
8981           if (r == NULL)
8982             return build_int_cst (TREE_TYPE (s1), 0);
8983
8984           /* Return an offset into the constant string argument.  */
8985           tem = fold_build2 (PLUS_EXPR, TREE_TYPE (s1),
8986                              s1, build_int_cst (TREE_TYPE (s1), r - p1));
8987           return fold_convert (type, tem);
8988         }
8989
8990       /* The argument is const char *, and the result is char *, so we need
8991          a type conversion here to avoid a warning.  */
8992       if (p2[0] == '\0')
8993         return fold_convert (type, s1);
8994
8995       if (p2[1] != '\0')
8996         return 0;
8997
8998       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
8999       if (!fn)
9000         return 0;
9001
9002       /* New argument list transforming strstr(s1, s2) to
9003          strchr(s1, s2[0]).  */
9004       arglist = build_tree_list (NULL_TREE,
9005                                  build_int_cst (NULL_TREE, p2[0]));
9006       arglist = tree_cons (NULL_TREE, s1, arglist);
9007       return build_function_call_expr (fn, arglist);
9008     }
9009 }
9010
9011 /* Simplify a call to the strchr builtin.
9012
9013    Return 0 if no simplification was possible, otherwise return the
9014    simplified form of the call as a tree.
9015
9016    The simplified form may be a constant or other expression which
9017    computes the same value, but in a more efficient manner (including
9018    calls to other builtin functions).
9019
9020    The call may contain arguments which need to be evaluated, but
9021    which are not useful to determine the result of the call.  In
9022    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
9023    COMPOUND_EXPR will be an argument which must be evaluated.
9024    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
9025    COMPOUND_EXPR in the chain will contain the tree for the simplified
9026    form of the builtin function call.  */
9027
9028 static tree
9029 fold_builtin_strchr (tree arglist, tree type)
9030 {
9031   if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
9032     return 0;
9033   else
9034     {
9035       tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
9036       const char *p1;
9037
9038       if (TREE_CODE (s2) != INTEGER_CST)
9039         return 0;
9040
9041       p1 = c_getstr (s1);
9042       if (p1 != NULL)
9043         {
9044           char c;
9045           const char *r;
9046           tree tem;
9047
9048           if (target_char_cast (s2, &c))
9049             return 0;
9050
9051           r = strchr (p1, c);
9052
9053           if (r == NULL)
9054             return build_int_cst (TREE_TYPE (s1), 0);
9055
9056           /* Return an offset into the constant string argument.  */
9057           tem = fold_build2 (PLUS_EXPR, TREE_TYPE (s1),
9058                              s1, build_int_cst (TREE_TYPE (s1), r - p1));
9059           return fold_convert (type, tem);
9060         }
9061       return 0;
9062     }
9063 }
9064
9065 /* Simplify a call to the strrchr builtin.
9066
9067    Return 0 if no simplification was possible, otherwise return the
9068    simplified form of the call as a tree.
9069
9070    The simplified form may be a constant or other expression which
9071    computes the same value, but in a more efficient manner (including
9072    calls to other builtin functions).
9073
9074    The call may contain arguments which need to be evaluated, but
9075    which are not useful to determine the result of the call.  In
9076    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
9077    COMPOUND_EXPR will be an argument which must be evaluated.
9078    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
9079    COMPOUND_EXPR in the chain will contain the tree for the simplified
9080    form of the builtin function call.  */
9081
9082 static tree
9083 fold_builtin_strrchr (tree arglist, tree type)
9084 {
9085   if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
9086     return 0;
9087   else
9088     {
9089       tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
9090       tree fn;
9091       const char *p1;
9092
9093       if (TREE_CODE (s2) != INTEGER_CST)
9094         return 0;
9095
9096       p1 = c_getstr (s1);
9097       if (p1 != NULL)
9098         {
9099           char c;
9100           const char *r;
9101           tree tem;
9102
9103           if (target_char_cast (s2, &c))
9104             return 0;
9105
9106           r = strrchr (p1, c);
9107
9108           if (r == NULL)
9109             return build_int_cst (TREE_TYPE (s1), 0);
9110
9111           /* Return an offset into the constant string argument.  */
9112           tem = fold_build2 (PLUS_EXPR, TREE_TYPE (s1),
9113                              s1, build_int_cst (TREE_TYPE (s1), r - p1));
9114           return fold_convert (type, tem);
9115         }
9116
9117       if (! integer_zerop (s2))
9118         return 0;
9119
9120       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
9121       if (!fn)
9122         return 0;
9123
9124       /* Transform strrchr(s1, '\0') to strchr(s1, '\0').  */
9125       return build_function_call_expr (fn, arglist);
9126     }
9127 }
9128
9129 /* Simplify a call to the strpbrk builtin.
9130
9131    Return 0 if no simplification was possible, otherwise return the
9132    simplified form of the call as a tree.
9133
9134    The simplified form may be a constant or other expression which
9135    computes the same value, but in a more efficient manner (including
9136    calls to other builtin functions).
9137
9138    The call may contain arguments which need to be evaluated, but
9139    which are not useful to determine the result of the call.  In
9140    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
9141    COMPOUND_EXPR will be an argument which must be evaluated.
9142    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
9143    COMPOUND_EXPR in the chain will contain the tree for the simplified
9144    form of the builtin function call.  */
9145
9146 static tree
9147 fold_builtin_strpbrk (tree arglist, tree type)
9148 {
9149   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
9150     return 0;
9151   else
9152     {
9153       tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
9154       tree fn;
9155       const char *p1, *p2;
9156
9157       p2 = c_getstr (s2);
9158       if (p2 == NULL)
9159         return 0;
9160
9161       p1 = c_getstr (s1);
9162       if (p1 != NULL)
9163         {
9164           const char *r = strpbrk (p1, p2);
9165           tree tem;
9166
9167           if (r == NULL)
9168             return build_int_cst (TREE_TYPE (s1), 0);
9169
9170           /* Return an offset into the constant string argument.  */
9171           tem = fold_build2 (PLUS_EXPR, TREE_TYPE (s1),
9172                              s1, build_int_cst (TREE_TYPE (s1), r - p1));
9173           return fold_convert (type, tem);
9174         }
9175
9176       if (p2[0] == '\0')
9177         /* strpbrk(x, "") == NULL.
9178            Evaluate and ignore s1 in case it had side-effects.  */
9179         return omit_one_operand (TREE_TYPE (s1), integer_zero_node, s1);
9180
9181       if (p2[1] != '\0')
9182         return 0;  /* Really call strpbrk.  */
9183
9184       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
9185       if (!fn)
9186         return 0;
9187
9188       /* New argument list transforming strpbrk(s1, s2) to
9189          strchr(s1, s2[0]).  */
9190       arglist = build_tree_list (NULL_TREE,
9191                                  build_int_cst (NULL_TREE, p2[0]));
9192       arglist = tree_cons (NULL_TREE, s1, arglist);
9193       return build_function_call_expr (fn, arglist);
9194     }
9195 }
9196
9197 /* Simplify a call to the strcat builtin.
9198
9199    Return 0 if no simplification was possible, otherwise return the
9200    simplified form of the call as a tree.
9201
9202    The simplified form may be a constant or other expression which
9203    computes the same value, but in a more efficient manner (including
9204    calls to other builtin functions).
9205
9206    The call may contain arguments which need to be evaluated, but
9207    which are not useful to determine the result of the call.  In
9208    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
9209    COMPOUND_EXPR will be an argument which must be evaluated.
9210    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
9211    COMPOUND_EXPR in the chain will contain the tree for the simplified
9212    form of the builtin function call.  */
9213
9214 static tree
9215 fold_builtin_strcat (tree arglist)
9216 {
9217   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
9218     return 0;
9219   else
9220     {
9221       tree dst = TREE_VALUE (arglist),
9222         src = TREE_VALUE (TREE_CHAIN (arglist));
9223       const char *p = c_getstr (src);
9224
9225       /* If the string length is zero, return the dst parameter.  */
9226       if (p && *p == '\0')
9227         return dst;
9228
9229       return 0;
9230     }
9231 }
9232
9233 /* Simplify a call to the strncat builtin.
9234
9235    Return 0 if no simplification was possible, otherwise return the
9236    simplified form of the call as a tree.
9237
9238    The simplified form may be a constant or other expression which
9239    computes the same value, but in a more efficient manner (including
9240    calls to other builtin functions).
9241
9242    The call may contain arguments which need to be evaluated, but
9243    which are not useful to determine the result of the call.  In
9244    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
9245    COMPOUND_EXPR will be an argument which must be evaluated.
9246    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
9247    COMPOUND_EXPR in the chain will contain the tree for the simplified
9248    form of the builtin function call.  */
9249
9250 static tree
9251 fold_builtin_strncat (tree arglist)
9252 {
9253   if (!validate_arglist (arglist,
9254                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
9255     return 0;
9256   else
9257     {
9258       tree dst = TREE_VALUE (arglist);
9259       tree src = TREE_VALUE (TREE_CHAIN (arglist));
9260       tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
9261       const char *p = c_getstr (src);
9262
9263       /* If the requested length is zero, or the src parameter string
9264          length is zero, return the dst parameter.  */
9265       if (integer_zerop (len) || (p && *p == '\0'))
9266         return omit_two_operands (TREE_TYPE (dst), dst, src, len);
9267
9268       /* If the requested len is greater than or equal to the string
9269          length, call strcat.  */
9270       if (TREE_CODE (len) == INTEGER_CST && p
9271           && compare_tree_int (len, strlen (p)) >= 0)
9272         {
9273           tree newarglist
9274             = tree_cons (NULL_TREE, dst, build_tree_list (NULL_TREE, src));
9275           tree fn = implicit_built_in_decls[BUILT_IN_STRCAT];
9276
9277           /* If the replacement _DECL isn't initialized, don't do the
9278              transformation.  */
9279           if (!fn)
9280             return 0;
9281
9282           return build_function_call_expr (fn, newarglist);
9283         }
9284       return 0;
9285     }
9286 }
9287
9288 /* Simplify a call to the strspn builtin.
9289
9290    Return 0 if no simplification was possible, otherwise return the
9291    simplified form of the call as a tree.
9292
9293    The simplified form may be a constant or other expression which
9294    computes the same value, but in a more efficient manner (including
9295    calls to other builtin functions).
9296
9297    The call may contain arguments which need to be evaluated, but
9298    which are not useful to determine the result of the call.  In
9299    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
9300    COMPOUND_EXPR will be an argument which must be evaluated.
9301    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
9302    COMPOUND_EXPR in the chain will contain the tree for the simplified
9303    form of the builtin function call.  */
9304
9305 static tree
9306 fold_builtin_strspn (tree arglist)
9307 {
9308   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
9309     return 0;
9310   else
9311     {
9312       tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
9313       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
9314
9315       /* If both arguments are constants, evaluate at compile-time.  */
9316       if (p1 && p2)
9317         {
9318           const size_t r = strspn (p1, p2);
9319           return size_int (r);
9320         }
9321
9322       /* If either argument is "", return 0.  */
9323       if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
9324         /* Evaluate and ignore both arguments in case either one has
9325            side-effects.  */
9326         return omit_two_operands (integer_type_node, integer_zero_node,
9327                                   s1, s2);
9328       return 0;
9329     }
9330 }
9331
9332 /* Simplify a call to the strcspn builtin.
9333
9334    Return 0 if no simplification was possible, otherwise return the
9335    simplified form of the call as a tree.
9336
9337    The simplified form may be a constant or other expression which
9338    computes the same value, but in a more efficient manner (including
9339    calls to other builtin functions).
9340
9341    The call may contain arguments which need to be evaluated, but
9342    which are not useful to determine the result of the call.  In
9343    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
9344    COMPOUND_EXPR will be an argument which must be evaluated.
9345    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
9346    COMPOUND_EXPR in the chain will contain the tree for the simplified
9347    form of the builtin function call.  */
9348
9349 static tree
9350 fold_builtin_strcspn (tree arglist)
9351 {
9352   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
9353     return 0;
9354   else
9355     {
9356       tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
9357       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
9358
9359       /* If both arguments are constants, evaluate at compile-time.  */
9360       if (p1 && p2)
9361         {
9362           const size_t r = strcspn (p1, p2);
9363           return size_int (r);
9364         }
9365
9366       /* If the first argument is "", return 0.  */
9367       if (p1 && *p1 == '\0')
9368         {
9369           /* Evaluate and ignore argument s2 in case it has
9370              side-effects.  */
9371           return omit_one_operand (integer_type_node,
9372                                    integer_zero_node, s2);
9373         }
9374
9375       /* If the second argument is "", return __builtin_strlen(s1).  */
9376       if (p2 && *p2 == '\0')
9377         {
9378           tree newarglist = build_tree_list (NULL_TREE, s1),
9379             fn = implicit_built_in_decls[BUILT_IN_STRLEN];
9380
9381           /* If the replacement _DECL isn't initialized, don't do the
9382              transformation.  */
9383           if (!fn)
9384             return 0;
9385
9386           return build_function_call_expr (fn, newarglist);
9387         }
9388       return 0;
9389     }
9390 }
9391
9392 /* Fold a call to the fputs builtin.  IGNORE is true if the value returned
9393    by the builtin will be ignored.  UNLOCKED is true is true if this
9394    actually a call to fputs_unlocked.  If LEN in non-NULL, it represents
9395    the known length of the string.  Return NULL_TREE if no simplification
9396    was possible.  */
9397
9398 tree
9399 fold_builtin_fputs (tree arglist, bool ignore, bool unlocked, tree len)
9400 {
9401   tree fn;
9402   /* If we're using an unlocked function, assume the other unlocked
9403      functions exist explicitly.  */
9404   tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
9405     : implicit_built_in_decls[BUILT_IN_FPUTC];
9406   tree const fn_fwrite = unlocked ? built_in_decls[BUILT_IN_FWRITE_UNLOCKED]
9407     : implicit_built_in_decls[BUILT_IN_FWRITE];
9408
9409   /* If the return value is used, don't do the transformation.  */
9410   if (!ignore)
9411     return 0;
9412
9413   /* Verify the arguments in the original call.  */
9414   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
9415     return 0;
9416
9417   if (! len)
9418     len = c_strlen (TREE_VALUE (arglist), 0);
9419
9420   /* Get the length of the string passed to fputs.  If the length
9421      can't be determined, punt.  */
9422   if (!len
9423       || TREE_CODE (len) != INTEGER_CST)
9424     return 0;
9425
9426   switch (compare_tree_int (len, 1))
9427     {
9428     case -1: /* length is 0, delete the call entirely .  */
9429       return omit_one_operand (integer_type_node, integer_zero_node,
9430                                TREE_VALUE (TREE_CHAIN (arglist)));
9431
9432     case 0: /* length is 1, call fputc.  */
9433       {
9434         const char *p = c_getstr (TREE_VALUE (arglist));
9435
9436         if (p != NULL)
9437           {
9438             /* New argument list transforming fputs(string, stream) to
9439                fputc(string[0], stream).  */
9440             arglist = build_tree_list (NULL_TREE,
9441                                        TREE_VALUE (TREE_CHAIN (arglist)));
9442             arglist = tree_cons (NULL_TREE,
9443                                  build_int_cst (NULL_TREE, p[0]),
9444                                  arglist);
9445             fn = fn_fputc;
9446             break;
9447           }
9448       }
9449       /* FALLTHROUGH */
9450     case 1: /* length is greater than 1, call fwrite.  */
9451       {
9452         tree string_arg;
9453
9454         /* If optimizing for size keep fputs.  */
9455         if (optimize_size)
9456           return 0;
9457         string_arg = TREE_VALUE (arglist);
9458         /* New argument list transforming fputs(string, stream) to
9459            fwrite(string, 1, len, stream).  */
9460         arglist = build_tree_list (NULL_TREE,
9461                                    TREE_VALUE (TREE_CHAIN (arglist)));
9462         arglist = tree_cons (NULL_TREE, len, arglist);
9463         arglist = tree_cons (NULL_TREE, size_one_node, arglist);
9464         arglist = tree_cons (NULL_TREE, string_arg, arglist);
9465         fn = fn_fwrite;
9466         break;
9467       }
9468     default:
9469       gcc_unreachable ();
9470     }
9471
9472   /* If the replacement _DECL isn't initialized, don't do the
9473      transformation.  */
9474   if (!fn)
9475     return 0;
9476
9477   /* These optimizations are only performed when the result is ignored,
9478      hence there's no need to cast the result to integer_type_node.  */
9479   return build_function_call_expr (fn, arglist);
9480 }
9481
9482 /* Fold the new_arg's arguments (ARGLIST). Returns true if there was an error
9483    produced.  False otherwise.  This is done so that we don't output the error
9484    or warning twice or three times.  */
9485 bool
9486 fold_builtin_next_arg (tree arglist)
9487 {
9488   tree fntype = TREE_TYPE (current_function_decl);
9489
9490   if (TYPE_ARG_TYPES (fntype) == 0
9491       || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
9492           == void_type_node))
9493     {
9494       error ("%<va_start%> used in function with fixed args");
9495       return true;
9496     }
9497   else if (!arglist)
9498     {
9499       /* Evidently an out of date version of <stdarg.h>; can't validate
9500          va_start's second argument, but can still work as intended.  */
9501       warning (0, "%<__builtin_next_arg%> called without an argument");
9502       return true;
9503     }
9504   /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
9505      when we checked the arguments and if needed issued a warning.  */
9506   else if (!TREE_CHAIN (arglist)
9507            || !integer_zerop (TREE_VALUE (arglist))
9508            || !integer_zerop (TREE_VALUE (TREE_CHAIN (arglist)))
9509            || TREE_CHAIN (TREE_CHAIN (arglist)))
9510     {
9511       tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
9512       tree arg = TREE_VALUE (arglist);
9513
9514       if (TREE_CHAIN (arglist))
9515         {
9516           error ("%<va_start%> used with too many arguments");
9517           return true;
9518         }
9519
9520       /* Strip off all nops for the sake of the comparison.  This
9521          is not quite the same as STRIP_NOPS.  It does more.
9522          We must also strip off INDIRECT_EXPR for C++ reference
9523          parameters.  */
9524       while (TREE_CODE (arg) == NOP_EXPR
9525              || TREE_CODE (arg) == CONVERT_EXPR
9526              || TREE_CODE (arg) == NON_LVALUE_EXPR
9527              || TREE_CODE (arg) == INDIRECT_REF)
9528         arg = TREE_OPERAND (arg, 0);
9529       if (arg != last_parm)
9530         {
9531           /* FIXME: Sometimes with the tree optimizers we can get the
9532              not the last argument even though the user used the last
9533              argument.  We just warn and set the arg to be the last
9534              argument so that we will get wrong-code because of
9535              it.  */
9536           warning (0, "second parameter of %<va_start%> not last named argument");
9537         }
9538       /* We want to verify the second parameter just once before the tree
9539          optimizers are run and then avoid keeping it in the tree,
9540          as otherwise we could warn even for correct code like:
9541          void foo (int i, ...)
9542          { va_list ap; i++; va_start (ap, i); va_end (ap); }  */
9543       TREE_VALUE (arglist) = integer_zero_node;
9544       TREE_CHAIN (arglist) = build_tree_list (NULL, integer_zero_node);
9545     }
9546   return false;
9547 }
9548
9549
9550 /* Simplify a call to the sprintf builtin.
9551
9552    Return 0 if no simplification was possible, otherwise return the
9553    simplified form of the call as a tree.  If IGNORED is true, it means that
9554    the caller does not use the returned value of the function.  */
9555
9556 static tree
9557 fold_builtin_sprintf (tree arglist, int ignored)
9558 {
9559   tree call, retval, dest, fmt;
9560   const char *fmt_str = NULL;
9561
9562   /* Verify the required arguments in the original call.  We deal with two
9563      types of sprintf() calls: 'sprintf (str, fmt)' and
9564      'sprintf (dest, "%s", orig)'.  */
9565   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE)
9566       && !validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, POINTER_TYPE,
9567                             VOID_TYPE))
9568     return NULL_TREE;
9569
9570   /* Get the destination string and the format specifier.  */
9571   dest = TREE_VALUE (arglist);
9572   fmt = TREE_VALUE (TREE_CHAIN (arglist));
9573
9574   /* Check whether the format is a literal string constant.  */
9575   fmt_str = c_getstr (fmt);
9576   if (fmt_str == NULL)
9577     return NULL_TREE;
9578
9579   call = NULL_TREE;
9580   retval = NULL_TREE;
9581
9582   if (!init_target_chars())
9583     return 0;
9584
9585   /* If the format doesn't contain % args or %%, use strcpy.  */
9586   if (strchr (fmt_str, target_percent) == NULL)
9587     {
9588       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
9589
9590       if (!fn)
9591         return NULL_TREE;
9592
9593       /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
9594          'format' is known to contain no % formats.  */
9595       arglist = build_tree_list (NULL_TREE, fmt);
9596       arglist = tree_cons (NULL_TREE, dest, arglist);
9597       call = build_function_call_expr (fn, arglist);
9598       if (!ignored)
9599         retval = build_int_cst (NULL_TREE, strlen (fmt_str));
9600     }
9601
9602   /* If the format is "%s", use strcpy if the result isn't used.  */
9603   else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
9604     {
9605       tree fn, orig;
9606       fn = implicit_built_in_decls[BUILT_IN_STRCPY];
9607
9608       if (!fn)
9609         return NULL_TREE;
9610
9611       /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2).  */
9612       orig = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
9613       arglist = build_tree_list (NULL_TREE, orig);
9614       arglist = tree_cons (NULL_TREE, dest, arglist);
9615       if (!ignored)
9616         {
9617           retval = c_strlen (orig, 1);
9618           if (!retval || TREE_CODE (retval) != INTEGER_CST)
9619             return NULL_TREE;
9620         }
9621       call = build_function_call_expr (fn, arglist);
9622     }
9623
9624   if (call && retval)
9625     {
9626       retval = convert
9627         (TREE_TYPE (TREE_TYPE (implicit_built_in_decls[BUILT_IN_SPRINTF])),
9628          retval);
9629       return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
9630     }
9631   else
9632     return call;
9633 }
9634
9635 /* Expand a call to __builtin_object_size.  */
9636
9637 rtx
9638 expand_builtin_object_size (tree exp)
9639 {
9640   tree ost;
9641   int object_size_type;
9642   tree fndecl = get_callee_fndecl (exp);
9643   tree arglist = TREE_OPERAND (exp, 1);
9644   location_t locus = EXPR_LOCATION (exp);
9645
9646   if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
9647     {
9648       error ("%Hfirst argument of %D must be a pointer, second integer constant",
9649              &locus, fndecl);
9650       expand_builtin_trap ();
9651       return const0_rtx;
9652     }
9653
9654   ost = TREE_VALUE (TREE_CHAIN (arglist));
9655   STRIP_NOPS (ost);
9656
9657   if (TREE_CODE (ost) != INTEGER_CST
9658       || tree_int_cst_sgn (ost) < 0
9659       || compare_tree_int (ost, 3) > 0)
9660     {
9661       error ("%Hlast argument of %D is not integer constant between 0 and 3",
9662              &locus, fndecl);
9663       expand_builtin_trap ();
9664       return const0_rtx;
9665     }
9666
9667   object_size_type = tree_low_cst (ost, 0);
9668
9669   return object_size_type < 2 ? constm1_rtx : const0_rtx;
9670 }
9671
9672 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
9673    FCODE is the BUILT_IN_* to use.
9674    Return 0 if we failed; the caller should emit a normal call,
9675    otherwise try to get the result in TARGET, if convenient (and in
9676    mode MODE if that's convenient).  */
9677
9678 static rtx
9679 expand_builtin_memory_chk (tree exp, rtx target, enum machine_mode mode,
9680                            enum built_in_function fcode)
9681 {
9682   tree arglist = TREE_OPERAND (exp, 1);
9683   tree dest, src, len, size;
9684
9685   if (!validate_arglist (arglist,
9686                          POINTER_TYPE,
9687                          fcode == BUILT_IN_MEMSET_CHK
9688                          ? INTEGER_TYPE : POINTER_TYPE,
9689                          INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
9690     return 0;
9691
9692   dest = TREE_VALUE (arglist);
9693   src = TREE_VALUE (TREE_CHAIN (arglist));
9694   len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
9695   size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist))));
9696
9697   if (! host_integerp (size, 1))
9698     return 0;
9699
9700   if (host_integerp (len, 1) || integer_all_onesp (size))
9701     {
9702       tree fn;
9703
9704       if (! integer_all_onesp (size) && tree_int_cst_lt (size, len))
9705         {
9706           location_t locus = EXPR_LOCATION (exp);
9707           warning (0, "%Hcall to %D will always overflow destination buffer",
9708                    &locus, get_callee_fndecl (exp));
9709           return 0;
9710         }
9711
9712       arglist = build_tree_list (NULL_TREE, len);
9713       arglist = tree_cons (NULL_TREE, src, arglist);
9714       arglist = tree_cons (NULL_TREE, dest, arglist);
9715
9716       fn = NULL_TREE;
9717       /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
9718          mem{cpy,pcpy,move,set} is available.  */
9719       switch (fcode)
9720         {
9721         case BUILT_IN_MEMCPY_CHK:
9722           fn = built_in_decls[BUILT_IN_MEMCPY];
9723           break;
9724         case BUILT_IN_MEMPCPY_CHK:
9725           fn = built_in_decls[BUILT_IN_MEMPCPY];
9726           break;
9727         case BUILT_IN_MEMMOVE_CHK:
9728           fn = built_in_decls[BUILT_IN_MEMMOVE];
9729           break;
9730         case BUILT_IN_MEMSET_CHK:
9731           fn = built_in_decls[BUILT_IN_MEMSET];
9732           break;
9733         default:
9734           break;
9735         }
9736
9737       if (! fn)
9738         return 0;
9739
9740       fn = build_function_call_expr (fn, arglist);
9741       if (TREE_CODE (fn) == CALL_EXPR)
9742         CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
9743       return expand_expr (fn, target, mode, EXPAND_NORMAL);
9744     }
9745   else if (fcode == BUILT_IN_MEMSET_CHK)
9746     return 0;
9747   else
9748     {
9749       unsigned int dest_align
9750         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
9751
9752       /* If DEST is not a pointer type, call the normal function.  */
9753       if (dest_align == 0)
9754         return 0;
9755
9756       /* If SRC and DEST are the same (and not volatile), do nothing.  */
9757       if (operand_equal_p (src, dest, 0))
9758         {
9759           tree expr;
9760
9761           if (fcode != BUILT_IN_MEMPCPY_CHK)
9762             {
9763               /* Evaluate and ignore LEN in case it has side-effects.  */
9764               expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
9765               return expand_expr (dest, target, mode, EXPAND_NORMAL);
9766             }
9767
9768           len = fold_convert (TREE_TYPE (dest), len);
9769           expr = fold_build2 (PLUS_EXPR, TREE_TYPE (dest), dest, len);
9770           return expand_expr (expr, target, mode, EXPAND_NORMAL);
9771         }
9772
9773       /* __memmove_chk special case.  */
9774       if (fcode == BUILT_IN_MEMMOVE_CHK)
9775         {
9776           unsigned int src_align
9777             = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
9778
9779           if (src_align == 0)
9780             return 0;
9781
9782           /* If src is categorized for a readonly section we can use
9783              normal __memcpy_chk.  */
9784           if (readonly_data_expr (src))
9785             {
9786               tree fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
9787               if (!fn)
9788                 return 0;
9789               fn = build_function_call_expr (fn, arglist);
9790               if (TREE_CODE (fn) == CALL_EXPR)
9791                 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
9792               return expand_expr (fn, target, mode, EXPAND_NORMAL);
9793             }
9794         }
9795       return 0;
9796     }
9797 }
9798
9799 /* Emit warning if a buffer overflow is detected at compile time.  */
9800
9801 static void
9802 maybe_emit_chk_warning (tree exp, enum built_in_function fcode)
9803 {
9804   int arg_mask, is_strlen = 0;
9805   tree arglist = TREE_OPERAND (exp, 1), a;
9806   tree len, size;
9807   location_t locus;
9808
9809   switch (fcode)
9810     {
9811     case BUILT_IN_STRCPY_CHK:
9812     case BUILT_IN_STPCPY_CHK:
9813     /* For __strcat_chk the warning will be emitted only if overflowing
9814        by at least strlen (dest) + 1 bytes.  */
9815     case BUILT_IN_STRCAT_CHK:
9816       arg_mask = 6;
9817       is_strlen = 1;
9818       break;
9819     case BUILT_IN_STRNCPY_CHK:
9820       arg_mask = 12;
9821       break;
9822     case BUILT_IN_SNPRINTF_CHK:
9823     case BUILT_IN_VSNPRINTF_CHK:
9824       arg_mask = 10;
9825       break;
9826     default:
9827       gcc_unreachable ();
9828     }
9829
9830   len = NULL_TREE;
9831   size = NULL_TREE;
9832   for (a = arglist; a && arg_mask; a = TREE_CHAIN (a), arg_mask >>= 1)
9833     if (arg_mask & 1)
9834       {
9835         if (len)
9836           size = a;
9837         else
9838           len = a;
9839       }
9840
9841   if (!len || !size)
9842     return;
9843
9844   len = TREE_VALUE (len);
9845   size = TREE_VALUE (size);
9846
9847   if (! host_integerp (size, 1) || integer_all_onesp (size))
9848     return;
9849
9850   if (is_strlen)
9851     {
9852       len = c_strlen (len, 1);
9853       if (! len || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
9854         return;
9855     }
9856   else if (! host_integerp (len, 1) || ! tree_int_cst_lt (size, len))
9857     return;
9858
9859   locus = EXPR_LOCATION (exp);
9860   warning (0, "%Hcall to %D will always overflow destination buffer",
9861            &locus, get_callee_fndecl (exp));
9862 }
9863
9864 /* Emit warning if a buffer overflow is detected at compile time
9865    in __sprintf_chk/__vsprintf_chk calls.  */
9866
9867 static void
9868 maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode)
9869 {
9870   tree arglist = TREE_OPERAND (exp, 1);
9871   tree dest, size, len, fmt, flag;
9872   const char *fmt_str;
9873
9874   /* Verify the required arguments in the original call.  */
9875   if (! arglist)
9876     return;
9877   dest = TREE_VALUE (arglist);
9878   arglist = TREE_CHAIN (arglist);
9879   if (! arglist)
9880     return;
9881   flag = TREE_VALUE (arglist);
9882   arglist = TREE_CHAIN (arglist);
9883   if (! arglist)
9884     return;
9885   size = TREE_VALUE (arglist);
9886   arglist = TREE_CHAIN (arglist);
9887   if (! arglist)
9888     return;
9889   fmt = TREE_VALUE (arglist);
9890   arglist = TREE_CHAIN (arglist);
9891
9892   if (! host_integerp (size, 1) || integer_all_onesp (size))
9893     return;
9894
9895   /* Check whether the format is a literal string constant.  */
9896   fmt_str = c_getstr (fmt);
9897   if (fmt_str == NULL)
9898     return;
9899
9900   if (!init_target_chars())
9901     return;
9902
9903   /* If the format doesn't contain % args or %%, we know its size.  */
9904   if (strchr (fmt_str, target_percent) == 0)
9905     len = build_int_cstu (size_type_node, strlen (fmt_str));
9906   /* If the format is "%s" and first ... argument is a string literal,
9907      we know it too.  */
9908   else if (fcode == BUILT_IN_SPRINTF_CHK && strcmp (fmt_str, target_percent_s) == 0)
9909     {
9910       tree arg;
9911
9912       if (! arglist)
9913         return;
9914       arg = TREE_VALUE (arglist);
9915       if (! POINTER_TYPE_P (TREE_TYPE (arg)))
9916         return;
9917
9918       len = c_strlen (arg, 1);
9919       if (!len || ! host_integerp (len, 1))
9920         return;
9921     }
9922   else
9923     return;
9924
9925   if (! tree_int_cst_lt (len, size))
9926     {
9927       location_t locus = EXPR_LOCATION (exp);
9928       warning (0, "%Hcall to %D will always overflow destination buffer",
9929                &locus, get_callee_fndecl (exp));
9930     }
9931 }
9932
9933 /* Fold a call to __builtin_object_size, if possible.  */
9934
9935 tree
9936 fold_builtin_object_size (tree arglist)
9937 {
9938   tree ptr, ost, ret = 0;
9939   int object_size_type;
9940
9941   if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
9942     return 0;
9943
9944   ptr = TREE_VALUE (arglist);
9945   ost = TREE_VALUE (TREE_CHAIN (arglist));
9946   STRIP_NOPS (ost);
9947
9948   if (TREE_CODE (ost) != INTEGER_CST
9949       || tree_int_cst_sgn (ost) < 0
9950       || compare_tree_int (ost, 3) > 0)
9951     return 0;
9952
9953   object_size_type = tree_low_cst (ost, 0);
9954
9955   /* __builtin_object_size doesn't evaluate side-effects in its arguments;
9956      if there are any side-effects, it returns (size_t) -1 for types 0 and 1
9957      and (size_t) 0 for types 2 and 3.  */
9958   if (TREE_SIDE_EFFECTS (ptr))
9959     return fold_convert (size_type_node,
9960                          object_size_type < 2
9961                          ? integer_minus_one_node : integer_zero_node);
9962
9963   if (TREE_CODE (ptr) == ADDR_EXPR)
9964     ret = build_int_cstu (size_type_node,
9965                         compute_builtin_object_size (ptr, object_size_type));
9966
9967   else if (TREE_CODE (ptr) == SSA_NAME)
9968     {
9969       unsigned HOST_WIDE_INT bytes;
9970
9971       /* If object size is not known yet, delay folding until
9972        later.  Maybe subsequent passes will help determining
9973        it.  */
9974       bytes = compute_builtin_object_size (ptr, object_size_type);
9975       if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2
9976                                              ? -1 : 0))
9977         ret = build_int_cstu (size_type_node, bytes);
9978     }
9979
9980   if (ret)
9981     {
9982       ret = force_fit_type (ret, -1, false, false);
9983       if (TREE_CONSTANT_OVERFLOW (ret))
9984         ret = 0;
9985     }
9986
9987   return ret;
9988 }
9989
9990 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
9991    IGNORE is true, if return value can be ignored.  FCODE is the BUILT_IN_*
9992    code of the builtin.  If MAXLEN is not NULL, it is maximum length
9993    passed as third argument.  */
9994
9995 tree
9996 fold_builtin_memory_chk (tree fndecl, tree arglist, tree maxlen, bool ignore,
9997                          enum built_in_function fcode)
9998 {
9999   tree dest, src, len, size, fn;
10000
10001   if (!validate_arglist (arglist,
10002                          POINTER_TYPE,
10003                          fcode == BUILT_IN_MEMSET_CHK
10004                          ? INTEGER_TYPE : POINTER_TYPE,
10005                          INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
10006     return 0;
10007
10008   dest = TREE_VALUE (arglist);
10009   /* Actually val for __memset_chk, but it doesn't matter.  */
10010   src = TREE_VALUE (TREE_CHAIN (arglist));
10011   len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
10012   size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist))));
10013
10014   /* If SRC and DEST are the same (and not volatile), return DEST
10015      (resp. DEST+LEN for __mempcpy_chk).  */
10016   if (fcode != BUILT_IN_MEMSET_CHK && operand_equal_p (src, dest, 0))
10017     {
10018       if (fcode != BUILT_IN_MEMPCPY_CHK)
10019         return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
10020       else
10021         {
10022           tree temp = fold_convert (TREE_TYPE (dest), len);
10023           temp = fold_build2 (PLUS_EXPR, TREE_TYPE (dest), dest, temp);
10024           return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), temp);
10025         }
10026     }
10027
10028   if (! host_integerp (size, 1))
10029     return 0;
10030
10031   if (! integer_all_onesp (size))
10032     {
10033       if (! host_integerp (len, 1))
10034         {
10035           /* If LEN is not constant, try MAXLEN too.
10036              For MAXLEN only allow optimizing into non-_ocs function
10037              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
10038           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
10039             {
10040               if (fcode == BUILT_IN_MEMPCPY_CHK && ignore)
10041                 {
10042                   /* (void) __mempcpy_chk () can be optimized into
10043                      (void) __memcpy_chk ().  */
10044                   fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
10045                   if (!fn)
10046                     return 0;
10047
10048                   return build_function_call_expr (fn, arglist);
10049                 }
10050               return 0;
10051             }
10052         }
10053       else
10054         maxlen = len;
10055
10056       if (tree_int_cst_lt (size, maxlen))
10057         return 0;
10058     }
10059
10060   arglist = build_tree_list (NULL_TREE, len);
10061   arglist = tree_cons (NULL_TREE, src, arglist);
10062   arglist = tree_cons (NULL_TREE, dest, arglist);
10063
10064   fn = NULL_TREE;
10065   /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
10066      mem{cpy,pcpy,move,set} is available.  */
10067   switch (fcode)
10068     {
10069     case BUILT_IN_MEMCPY_CHK:
10070       fn = built_in_decls[BUILT_IN_MEMCPY];
10071       break;
10072     case BUILT_IN_MEMPCPY_CHK:
10073       fn = built_in_decls[BUILT_IN_MEMPCPY];
10074       break;
10075     case BUILT_IN_MEMMOVE_CHK:
10076       fn = built_in_decls[BUILT_IN_MEMMOVE];
10077       break;
10078     case BUILT_IN_MEMSET_CHK:
10079       fn = built_in_decls[BUILT_IN_MEMSET];
10080       break;
10081     default:
10082       break;
10083     }
10084
10085   if (!fn)
10086     return 0;
10087
10088   return build_function_call_expr (fn, arglist);
10089 }
10090
10091 /* Fold a call to the __st[rp]cpy_chk builtin.
10092    IGNORE is true, if return value can be ignored.  FCODE is the BUILT_IN_*
10093    code of the builtin.  If MAXLEN is not NULL, it is maximum length of
10094    strings passed as second argument.  */
10095
10096 tree
10097 fold_builtin_stxcpy_chk (tree fndecl, tree arglist, tree maxlen, bool ignore,
10098                          enum built_in_function fcode)
10099 {
10100   tree dest, src, size, len, fn;
10101
10102   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE,
10103                          VOID_TYPE))
10104     return 0;
10105
10106   dest = TREE_VALUE (arglist);
10107   src = TREE_VALUE (TREE_CHAIN (arglist));
10108   size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
10109
10110   /* If SRC and DEST are the same (and not volatile), return DEST.  */
10111   if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0))
10112     return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), dest);
10113
10114   if (! host_integerp (size, 1))
10115     return 0;
10116
10117   if (! integer_all_onesp (size))
10118     {
10119       len = c_strlen (src, 1);
10120       if (! len || ! host_integerp (len, 1))
10121         {
10122           /* If LEN is not constant, try MAXLEN too.
10123              For MAXLEN only allow optimizing into non-_ocs function
10124              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
10125           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
10126             {
10127               if (fcode == BUILT_IN_STPCPY_CHK)
10128                 {
10129                   if (! ignore)
10130                     return 0;
10131
10132                   /* If return value of __stpcpy_chk is ignored,
10133                      optimize into __strcpy_chk.  */
10134                   fn = built_in_decls[BUILT_IN_STRCPY_CHK];
10135                   if (!fn)
10136                     return 0;
10137
10138                   return build_function_call_expr (fn, arglist);
10139                 }
10140
10141               if (! len || TREE_SIDE_EFFECTS (len))
10142                 return 0;
10143
10144               /* If c_strlen returned something, but not a constant,
10145                  transform __strcpy_chk into __memcpy_chk.  */
10146               fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
10147               if (!fn)
10148                 return 0;
10149
10150               len = size_binop (PLUS_EXPR, len, ssize_int (1));
10151               arglist = build_tree_list (NULL_TREE, size);
10152               arglist = tree_cons (NULL_TREE, len, arglist);
10153               arglist = tree_cons (NULL_TREE, src, arglist);
10154               arglist = tree_cons (NULL_TREE, dest, arglist);
10155               return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)),
10156                                    build_function_call_expr (fn, arglist));
10157             }
10158         }
10159       else
10160         maxlen = len;
10161
10162       if (! tree_int_cst_lt (maxlen, size))
10163         return 0;
10164     }
10165
10166   arglist = build_tree_list (NULL_TREE, src);
10167   arglist = tree_cons (NULL_TREE, dest, arglist);
10168
10169   /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available.  */
10170   fn = built_in_decls[fcode == BUILT_IN_STPCPY_CHK
10171                       ? BUILT_IN_STPCPY : BUILT_IN_STRCPY];
10172   if (!fn)
10173     return 0;
10174
10175   return build_function_call_expr (fn, arglist);
10176 }
10177
10178 /* Fold a call to the __strncpy_chk builtin.
10179    If MAXLEN is not NULL, it is maximum length passed as third argument.  */
10180
10181 tree
10182 fold_builtin_strncpy_chk (tree arglist, tree maxlen)
10183 {
10184   tree dest, src, size, len, fn;
10185
10186   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE,
10187                          INTEGER_TYPE, VOID_TYPE))
10188     return 0;
10189
10190   dest = TREE_VALUE (arglist);
10191   src = TREE_VALUE (TREE_CHAIN (arglist));
10192   len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
10193   size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist))));
10194
10195   if (! host_integerp (size, 1))
10196     return 0;
10197
10198   if (! integer_all_onesp (size))
10199     {
10200       if (! host_integerp (len, 1))
10201         {
10202           /* If LEN is not constant, try MAXLEN too.
10203              For MAXLEN only allow optimizing into non-_ocs function
10204              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
10205           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
10206             return 0;
10207         }
10208       else
10209         maxlen = len;
10210
10211       if (tree_int_cst_lt (size, maxlen))
10212         return 0;
10213     }
10214
10215   arglist = build_tree_list (NULL_TREE, len);
10216   arglist = tree_cons (NULL_TREE, src, arglist);
10217   arglist = tree_cons (NULL_TREE, dest, arglist);
10218
10219   /* If __builtin_strncpy_chk is used, assume strncpy is available.  */
10220   fn = built_in_decls[BUILT_IN_STRNCPY];
10221   if (!fn)
10222     return 0;
10223
10224   return build_function_call_expr (fn, arglist);
10225 }
10226
10227 /* Fold a call to the __strcat_chk builtin FNDECL with ARGLIST.  */
10228
10229 static tree
10230 fold_builtin_strcat_chk (tree fndecl, tree arglist)
10231 {
10232   tree dest, src, size, fn;
10233   const char *p;
10234
10235   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE,
10236                          VOID_TYPE))
10237     return 0;
10238
10239   dest = TREE_VALUE (arglist);
10240   src = TREE_VALUE (TREE_CHAIN (arglist));
10241   size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
10242
10243   p = c_getstr (src);
10244   /* If the SRC parameter is "", return DEST.  */
10245   if (p && *p == '\0')
10246     return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
10247
10248   if (! host_integerp (size, 1) || ! integer_all_onesp (size))
10249     return 0;
10250
10251   arglist = build_tree_list (NULL_TREE, src);
10252   arglist = tree_cons (NULL_TREE, dest, arglist);
10253
10254   /* If __builtin_strcat_chk is used, assume strcat is available.  */
10255   fn = built_in_decls[BUILT_IN_STRCAT];
10256   if (!fn)
10257     return 0;
10258
10259   return build_function_call_expr (fn, arglist);
10260 }
10261
10262 /* Fold a call to the __strncat_chk builtin EXP.  */
10263
10264 static tree
10265 fold_builtin_strncat_chk (tree fndecl, tree arglist)
10266 {
10267   tree dest, src, size, len, fn;
10268   const char *p;
10269
10270   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE,
10271                          INTEGER_TYPE, VOID_TYPE))
10272     return 0;
10273
10274   dest = TREE_VALUE (arglist);
10275   src = TREE_VALUE (TREE_CHAIN (arglist));
10276   len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
10277   size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist))));
10278
10279   p = c_getstr (src);
10280   /* If the SRC parameter is "" or if LEN is 0, return DEST.  */
10281   if (p && *p == '\0')
10282     return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
10283   else if (integer_zerop (len))
10284     return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
10285
10286   if (! host_integerp (size, 1))
10287     return 0;
10288
10289   if (! integer_all_onesp (size))
10290     {
10291       tree src_len = c_strlen (src, 1);
10292       if (src_len
10293           && host_integerp (src_len, 1)
10294           && host_integerp (len, 1)
10295           && ! tree_int_cst_lt (len, src_len))
10296         {
10297           /* If LEN >= strlen (SRC), optimize into __strcat_chk.  */
10298           fn = built_in_decls[BUILT_IN_STRCAT_CHK];
10299           if (!fn)
10300             return 0;
10301
10302           arglist = build_tree_list (NULL_TREE, size);
10303           arglist = tree_cons (NULL_TREE, src, arglist);
10304           arglist = tree_cons (NULL_TREE, dest, arglist);
10305           return build_function_call_expr (fn, arglist);
10306         }
10307       return 0;
10308     }
10309
10310   arglist = build_tree_list (NULL_TREE, len);
10311   arglist = tree_cons (NULL_TREE, src, arglist);
10312   arglist = tree_cons (NULL_TREE, dest, arglist);
10313
10314   /* If __builtin_strncat_chk is used, assume strncat is available.  */
10315   fn = built_in_decls[BUILT_IN_STRNCAT];
10316   if (!fn)
10317     return 0;
10318
10319   return build_function_call_expr (fn, arglist);
10320 }
10321
10322 /* Fold a call to __{,v}sprintf_chk with argument list ARGLIST.  Return 0 if
10323    a normal call should be emitted rather than expanding the function
10324    inline.  FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK.  */
10325
10326 static tree
10327 fold_builtin_sprintf_chk (tree arglist, enum built_in_function fcode)
10328 {
10329   tree dest, size, len, fn, fmt, flag;
10330   const char *fmt_str;
10331
10332   /* Verify the required arguments in the original call.  */
10333   if (! arglist)
10334     return 0;
10335   dest = TREE_VALUE (arglist);
10336   if (! POINTER_TYPE_P (TREE_TYPE (dest)))
10337     return 0;
10338   arglist = TREE_CHAIN (arglist);
10339   if (! arglist)
10340     return 0;
10341   flag = TREE_VALUE (arglist);
10342   if (TREE_CODE (TREE_TYPE (flag)) != INTEGER_TYPE)
10343     return 0;
10344   arglist = TREE_CHAIN (arglist);
10345   if (! arglist)
10346     return 0;
10347   size = TREE_VALUE (arglist);
10348   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE)
10349     return 0;
10350   arglist = TREE_CHAIN (arglist);
10351   if (! arglist)
10352     return 0;
10353   fmt = TREE_VALUE (arglist);
10354   if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
10355     return 0;
10356   arglist = TREE_CHAIN (arglist);
10357
10358   if (! host_integerp (size, 1))
10359     return 0;
10360
10361   len = NULL_TREE;
10362
10363   if (!init_target_chars())
10364     return 0;
10365
10366   /* Check whether the format is a literal string constant.  */
10367   fmt_str = c_getstr (fmt);
10368   if (fmt_str != NULL)
10369     {
10370       /* If the format doesn't contain % args or %%, we know the size.  */
10371       if (strchr (fmt_str, target_percent) == 0)
10372         {
10373           if (fcode != BUILT_IN_SPRINTF_CHK || arglist == NULL_TREE)
10374             len = build_int_cstu (size_type_node, strlen (fmt_str));
10375         }
10376       /* If the format is "%s" and first ... argument is a string literal,
10377          we know the size too.  */
10378       else if (fcode == BUILT_IN_SPRINTF_CHK && strcmp (fmt_str, target_percent_s) == 0)
10379         {
10380           tree arg;
10381
10382           if (arglist && !TREE_CHAIN (arglist))
10383             {
10384               arg = TREE_VALUE (arglist);
10385               if (POINTER_TYPE_P (TREE_TYPE (arg)))
10386                 {
10387                   len = c_strlen (arg, 1);
10388                   if (! len || ! host_integerp (len, 1))
10389                     len = NULL_TREE;
10390                 }
10391             }
10392         }
10393     }
10394
10395   if (! integer_all_onesp (size))
10396     {
10397       if (! len || ! tree_int_cst_lt (len, size))
10398         return 0;
10399     }
10400
10401   /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
10402      or if format doesn't contain % chars or is "%s".  */
10403   if (! integer_zerop (flag))
10404     {
10405       if (fmt_str == NULL)
10406         return 0;
10407       if (strchr (fmt_str, target_percent) != NULL && strcmp (fmt_str, target_percent_s))
10408         return 0;
10409     }
10410
10411   arglist = tree_cons (NULL_TREE, fmt, arglist);
10412   arglist = tree_cons (NULL_TREE, dest, arglist);
10413
10414   /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available.  */
10415   fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
10416                       ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
10417   if (!fn)
10418     return 0;
10419
10420   return build_function_call_expr (fn, arglist);
10421 }
10422
10423 /* Fold a call to {,v}snprintf with argument list ARGLIST.  Return 0 if
10424    a normal call should be emitted rather than expanding the function
10425    inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
10426    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
10427    passed as second argument.  */
10428
10429 tree
10430 fold_builtin_snprintf_chk (tree arglist, tree maxlen,
10431                            enum built_in_function fcode)
10432 {
10433   tree dest, size, len, fn, fmt, flag;
10434   const char *fmt_str;
10435
10436   /* Verify the required arguments in the original call.  */
10437   if (! arglist)
10438     return 0;
10439   dest = TREE_VALUE (arglist);
10440   if (! POINTER_TYPE_P (TREE_TYPE (dest)))
10441     return 0;
10442   arglist = TREE_CHAIN (arglist);
10443   if (! arglist)
10444     return 0;
10445   len = TREE_VALUE (arglist);
10446   if (TREE_CODE (TREE_TYPE (len)) != INTEGER_TYPE)
10447     return 0;
10448   arglist = TREE_CHAIN (arglist);
10449   if (! arglist)
10450     return 0;
10451   flag = TREE_VALUE (arglist);
10452   if (TREE_CODE (TREE_TYPE (len)) != INTEGER_TYPE)
10453     return 0;
10454   arglist = TREE_CHAIN (arglist);
10455   if (! arglist)
10456     return 0;
10457   size = TREE_VALUE (arglist);
10458   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE)
10459     return 0;
10460   arglist = TREE_CHAIN (arglist);
10461   if (! arglist)
10462     return 0;
10463   fmt = TREE_VALUE (arglist);
10464   if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
10465     return 0;
10466   arglist = TREE_CHAIN (arglist);
10467
10468   if (! host_integerp (size, 1))
10469     return 0;
10470
10471   if (! integer_all_onesp (size))
10472     {
10473       if (! host_integerp (len, 1))
10474         {
10475           /* If LEN is not constant, try MAXLEN too.
10476              For MAXLEN only allow optimizing into non-_ocs function
10477              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
10478           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
10479             return 0;
10480         }
10481       else
10482         maxlen = len;
10483
10484       if (tree_int_cst_lt (size, maxlen))
10485         return 0;
10486     }
10487
10488   if (!init_target_chars())
10489     return 0;
10490
10491   /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
10492      or if format doesn't contain % chars or is "%s".  */
10493   if (! integer_zerop (flag))
10494     {
10495       fmt_str = c_getstr (fmt);
10496       if (fmt_str == NULL)
10497         return 0;
10498       if (strchr (fmt_str, target_percent) != NULL && strcmp (fmt_str, target_percent_s))
10499         return 0;
10500     }
10501
10502   arglist = tree_cons (NULL_TREE, fmt, arglist);
10503   arglist = tree_cons (NULL_TREE, len, arglist);
10504   arglist = tree_cons (NULL_TREE, dest, arglist);
10505
10506   /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
10507      available.  */
10508   fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
10509                       ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
10510   if (!fn)
10511     return 0;
10512
10513   return build_function_call_expr (fn, arglist);
10514 }
10515
10516 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
10517
10518    Return 0 if no simplification was possible, otherwise return the
10519    simplified form of the call as a tree.  FCODE is the BUILT_IN_*
10520    code of the function to be simplified.  */
10521
10522 static tree
10523 fold_builtin_printf (tree fndecl, tree arglist, bool ignore,
10524                      enum built_in_function fcode)
10525 {
10526   tree fmt, fn = NULL_TREE, fn_putchar, fn_puts, arg, call;
10527   const char *fmt_str = NULL;
10528
10529   /* If the return value is used, don't do the transformation.  */
10530   if (! ignore)
10531     return 0;
10532
10533   /* Verify the required arguments in the original call.  */
10534   if (fcode == BUILT_IN_PRINTF_CHK || fcode == BUILT_IN_VPRINTF_CHK)
10535     {
10536       tree flag;
10537
10538       if (! arglist)
10539         return 0;
10540       flag = TREE_VALUE (arglist);
10541       if (TREE_CODE (TREE_TYPE (flag)) != INTEGER_TYPE
10542           || TREE_SIDE_EFFECTS (flag))
10543         return 0;
10544       arglist = TREE_CHAIN (arglist);
10545     }
10546
10547   if (! arglist)
10548     return 0;
10549   fmt = TREE_VALUE (arglist);
10550   if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
10551     return 0;
10552   arglist = TREE_CHAIN (arglist);
10553
10554   /* Check whether the format is a literal string constant.  */
10555   fmt_str = c_getstr (fmt);
10556   if (fmt_str == NULL)
10557     return NULL_TREE;
10558
10559   if (fcode == BUILT_IN_PRINTF_UNLOCKED)
10560     {
10561       /* If we're using an unlocked function, assume the other
10562          unlocked functions exist explicitly.  */
10563       fn_putchar = built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED];
10564       fn_puts = built_in_decls[BUILT_IN_PUTS_UNLOCKED];
10565     }
10566   else
10567     {
10568       fn_putchar = implicit_built_in_decls[BUILT_IN_PUTCHAR];
10569       fn_puts = implicit_built_in_decls[BUILT_IN_PUTS];
10570     }
10571
10572   if (!init_target_chars())
10573     return 0;
10574
10575   if (strcmp (fmt_str, target_percent_s) == 0 || strchr (fmt_str, target_percent) == NULL)
10576     {
10577       const char *str;
10578
10579       if (strcmp (fmt_str, target_percent_s) == 0)
10580         {
10581           if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
10582             return 0;
10583
10584           if (! arglist
10585               || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist)))
10586               || TREE_CHAIN (arglist))
10587             return 0;
10588
10589           str = c_getstr (TREE_VALUE (arglist));
10590           if (str == NULL)
10591             return 0;
10592         }
10593       else
10594         {
10595           /* The format specifier doesn't contain any '%' characters.  */
10596           if (fcode != BUILT_IN_VPRINTF && fcode != BUILT_IN_VPRINTF_CHK
10597               && arglist)
10598             return 0;
10599           str = fmt_str;
10600         }
10601
10602       /* If the string was "", printf does nothing.  */
10603       if (str[0] == '\0')
10604         return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
10605
10606       /* If the string has length of 1, call putchar.  */
10607       if (str[1] == '\0')
10608         {
10609           /* Given printf("c"), (where c is any one character,)
10610              convert "c"[0] to an int and pass that to the replacement
10611              function.  */
10612           arg = build_int_cst (NULL_TREE, str[0]);
10613           arglist = build_tree_list (NULL_TREE, arg);
10614           fn = fn_putchar;
10615         }
10616       else
10617         {
10618           /* If the string was "string\n", call puts("string").  */
10619           size_t len = strlen (str);
10620           if ((unsigned char)str[len - 1] == target_newline)
10621             {
10622               /* Create a NUL-terminated string that's one char shorter
10623                  than the original, stripping off the trailing '\n'.  */
10624               char *newstr = alloca (len);
10625               memcpy (newstr, str, len - 1);
10626               newstr[len - 1] = 0;
10627
10628               arg = build_string_literal (len, newstr);
10629               arglist = build_tree_list (NULL_TREE, arg);
10630               fn = fn_puts;
10631             }
10632           else
10633             /* We'd like to arrange to call fputs(string,stdout) here,
10634                but we need stdout and don't have a way to get it yet.  */
10635             return 0;
10636         }
10637     }
10638
10639   /* The other optimizations can be done only on the non-va_list variants.  */
10640   else if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
10641     return 0;
10642
10643   /* If the format specifier was "%s\n", call __builtin_puts(arg).  */
10644   else if (strcmp (fmt_str, target_percent_s_newline) == 0)
10645     {
10646       if (! arglist
10647           || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist)))
10648           || TREE_CHAIN (arglist))
10649         return 0;
10650       fn = fn_puts;
10651     }
10652
10653   /* If the format specifier was "%c", call __builtin_putchar(arg).  */
10654   else if (strcmp (fmt_str, target_percent_c) == 0)
10655     {
10656       if (! arglist
10657           || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE
10658           || TREE_CHAIN (arglist))
10659         return 0;
10660       fn = fn_putchar;
10661     }
10662
10663   if (!fn)
10664     return 0;
10665
10666   call = build_function_call_expr (fn, arglist);
10667   return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), call);
10668 }
10669
10670 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
10671
10672    Return 0 if no simplification was possible, otherwise return the
10673    simplified form of the call as a tree.  FCODE is the BUILT_IN_*
10674    code of the function to be simplified.  */
10675
10676 static tree
10677 fold_builtin_fprintf (tree fndecl, tree arglist, bool ignore,
10678                       enum built_in_function fcode)
10679 {
10680   tree fp, fmt, fn = NULL_TREE, fn_fputc, fn_fputs, arg, call;
10681   const char *fmt_str = NULL;
10682
10683   /* If the return value is used, don't do the transformation.  */
10684   if (! ignore)
10685     return 0;
10686
10687   /* Verify the required arguments in the original call.  */
10688   if (! arglist)
10689     return 0;
10690   fp = TREE_VALUE (arglist);
10691   if (! POINTER_TYPE_P (TREE_TYPE (fp)))
10692     return 0;
10693   arglist = TREE_CHAIN (arglist);
10694
10695   if (fcode == BUILT_IN_FPRINTF_CHK || fcode == BUILT_IN_VFPRINTF_CHK)
10696     {
10697       tree flag;
10698
10699       if (! arglist)
10700         return 0;
10701       flag = TREE_VALUE (arglist);
10702       if (TREE_CODE (TREE_TYPE (flag)) != INTEGER_TYPE
10703           || TREE_SIDE_EFFECTS (flag))
10704         return 0;
10705       arglist = TREE_CHAIN (arglist);
10706     }
10707
10708   if (! arglist)
10709     return 0;
10710   fmt = TREE_VALUE (arglist);
10711   if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
10712     return 0;
10713   arglist = TREE_CHAIN (arglist);
10714
10715   /* Check whether the format is a literal string constant.  */
10716   fmt_str = c_getstr (fmt);
10717   if (fmt_str == NULL)
10718     return NULL_TREE;
10719
10720   if (fcode == BUILT_IN_FPRINTF_UNLOCKED)
10721     {
10722       /* If we're using an unlocked function, assume the other
10723          unlocked functions exist explicitly.  */
10724       fn_fputc = built_in_decls[BUILT_IN_FPUTC_UNLOCKED];
10725       fn_fputs = built_in_decls[BUILT_IN_FPUTS_UNLOCKED];
10726     }
10727   else
10728     {
10729       fn_fputc = implicit_built_in_decls[BUILT_IN_FPUTC];
10730       fn_fputs = implicit_built_in_decls[BUILT_IN_FPUTS];
10731     }
10732
10733   if (!init_target_chars())
10734     return 0;
10735
10736   /* If the format doesn't contain % args or %%, use strcpy.  */
10737   if (strchr (fmt_str, target_percent) == NULL)
10738     {
10739       if (fcode != BUILT_IN_VFPRINTF && fcode != BUILT_IN_VFPRINTF_CHK
10740           && arglist)
10741         return 0;
10742
10743       /* If the format specifier was "", fprintf does nothing.  */
10744       if (fmt_str[0] == '\0')
10745         {
10746           /* If FP has side-effects, just wait until gimplification is
10747              done.  */
10748           if (TREE_SIDE_EFFECTS (fp))
10749             return 0;
10750
10751           return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
10752         }
10753
10754       /* When "string" doesn't contain %, replace all cases of
10755          fprintf (fp, string) with fputs (string, fp).  The fputs
10756          builtin will take care of special cases like length == 1.  */
10757       arglist = build_tree_list (NULL_TREE, fp);
10758       arglist = tree_cons (NULL_TREE, fmt, arglist);
10759       fn = fn_fputs;
10760     }
10761
10762   /* The other optimizations can be done only on the non-va_list variants.  */
10763   else if (fcode == BUILT_IN_VFPRINTF || fcode == BUILT_IN_VFPRINTF_CHK)
10764     return 0;
10765
10766   /* If the format specifier was "%s", call __builtin_fputs (arg, fp).  */
10767   else if (strcmp (fmt_str, target_percent_s) == 0)
10768     {
10769       if (! arglist
10770           || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist)))
10771           || TREE_CHAIN (arglist))
10772         return 0;
10773       arg = TREE_VALUE (arglist);
10774       arglist = build_tree_list (NULL_TREE, fp);
10775       arglist = tree_cons (NULL_TREE, arg, arglist);
10776       fn = fn_fputs;
10777     }
10778
10779   /* If the format specifier was "%c", call __builtin_fputc (arg, fp).  */
10780   else if (strcmp (fmt_str, target_percent_c) == 0)
10781     {
10782       if (! arglist
10783           || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE
10784           || TREE_CHAIN (arglist))
10785         return 0;
10786       arg = TREE_VALUE (arglist);
10787       arglist = build_tree_list (NULL_TREE, fp);
10788       arglist = tree_cons (NULL_TREE, arg, arglist);
10789       fn = fn_fputc;
10790     }
10791
10792   if (!fn)
10793     return 0;
10794
10795   call = build_function_call_expr (fn, arglist);
10796   return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), call);
10797 }
10798
10799 /* Initialize format string characters in the target charset.  */
10800
10801 static bool
10802 init_target_chars (void)
10803 {
10804   static bool init;
10805   if (!init)
10806     {
10807       target_newline = lang_hooks.to_target_charset ('\n');
10808       target_percent = lang_hooks.to_target_charset ('%');
10809       target_c = lang_hooks.to_target_charset ('c');
10810       target_s = lang_hooks.to_target_charset ('s');
10811       if (target_newline == 0 || target_percent == 0 || target_c == 0
10812           || target_s == 0)
10813         return false;
10814
10815       target_percent_c[0] = target_percent;
10816       target_percent_c[1] = target_c;
10817       target_percent_c[2] = '\0';
10818
10819       target_percent_s[0] = target_percent;
10820       target_percent_s[1] = target_s;
10821       target_percent_s[2] = '\0';
10822
10823       target_percent_s_newline[0] = target_percent;
10824       target_percent_s_newline[1] = target_s;
10825       target_percent_s_newline[2] = target_newline;
10826       target_percent_s_newline[3] = '\0';
10827
10828       init = true;
10829     }
10830   return true;
10831 }