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