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