gcc/builtins.c

   1 /* Expand builtin functions.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001 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 "machmode.h"
  25 #include "rtl.h"
  26 #include "tree.h"
  27 #include "obstack.h"
  28 #include "flags.h"
  29 #include "regs.h"
  30 #include "hard-reg-set.h"
  31 #include "except.h"
  32 #include "function.h"
  33 #include "insn-config.h"
  34 #include "expr.h"
  35 #include "optabs.h"
  36 #include "libfuncs.h"
  37 #include "recog.h"
  38 #include "output.h"
  39 #include "typeclass.h"
  40 #include "toplev.h"
  41 #include "predict.h"
  42 #include "tm_p.h"
  43 #include "target.h"
  44
  45 #define CALLED_AS_BUILT_IN(NODE) \
  46    (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
  47
  48 /* Register mappings for target machines without register windows.  */
  49 #ifndef INCOMING_REGNO
  50 #define INCOMING_REGNO(OUT) (OUT)
  51 #endif
  52 #ifndef OUTGOING_REGNO
  53 #define OUTGOING_REGNO(IN) (IN)
  54 #endif
  55
  56 #ifndef PAD_VARARGS_DOWN
  57 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
  58 #endif
  59
  60 /* Define the names of the builtin function types and codes.  */
  61 const char *const built_in_class_names[4]
  62   = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
  63
  64 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA) STRINGX(X),
  65 const char *const built_in_names[(int) END_BUILTINS] =
  66 {
  67 #include "builtins.def"
  68 };
  69 #undef DEF_BUILTIN
  70
  71 /* Setup an array of _DECL trees, make sure each element is
  72    initialized to NULL_TREE.  */
  73 tree built_in_decls[(int) END_BUILTINS];
  74
  75 tree (*lang_type_promotes_to) PARAMS ((tree));
  76
  77 static int get_pointer_alignment        PARAMS ((tree, unsigned int));
  78 static tree c_strlen                    PARAMS ((tree));
  79 static const char *c_getstr             PARAMS ((tree));
  80 static rtx c_readstr                    PARAMS ((const char *,
  81                                                  enum machine_mode));
  82 static int target_char_cast             PARAMS ((tree, char *));
  83 static rtx get_memory_rtx               PARAMS ((tree));
  84 static int apply_args_size              PARAMS ((void));
  85 static int apply_result_size            PARAMS ((void));
  86 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
  87 static rtx result_vector                PARAMS ((int, rtx));
  88 #endif
  89 static rtx expand_builtin_setjmp        PARAMS ((tree, rtx));
  90 static void expand_builtin_prefetch     PARAMS ((tree));
  91 static rtx expand_builtin_apply_args    PARAMS ((void));
  92 static rtx expand_builtin_apply_args_1  PARAMS ((void));
  93 static rtx expand_builtin_apply         PARAMS ((rtx, rtx, rtx));
  94 static void expand_builtin_return       PARAMS ((rtx));
  95 static enum type_class type_to_class    PARAMS ((tree));
  96 static rtx expand_builtin_classify_type PARAMS ((tree));
  97 static rtx expand_builtin_mathfn        PARAMS ((tree, rtx, rtx));
  98 static rtx expand_builtin_constant_p    PARAMS ((tree));
  99 static rtx expand_builtin_args_info     PARAMS ((tree));
 100 static rtx expand_builtin_next_arg      PARAMS ((tree));
 101 static rtx expand_builtin_va_start      PARAMS ((int, tree));
 102 static rtx expand_builtin_va_end        PARAMS ((tree));
 103 static rtx expand_builtin_va_copy       PARAMS ((tree));
 104 static rtx expand_builtin_memcmp        PARAMS ((tree, tree, rtx,
 105                                                  enum machine_mode));
 106 static rtx expand_builtin_strcmp        PARAMS ((tree, rtx,
 107                                                  enum machine_mode));
 108 static rtx expand_builtin_strncmp       PARAMS ((tree, rtx,
 109                                                  enum machine_mode));
 110 static rtx builtin_memcpy_read_str      PARAMS ((PTR, HOST_WIDE_INT,
 111                                                  enum machine_mode));
 112 static rtx expand_builtin_strcat        PARAMS ((tree, rtx,
 113                                                  enum machine_mode));
 114 static rtx expand_builtin_strncat       PARAMS ((tree, rtx,
 115                                                  enum machine_mode));
 116 static rtx expand_builtin_strspn        PARAMS ((tree, rtx,
 117                                                  enum machine_mode));
 118 static rtx expand_builtin_strcspn       PARAMS ((tree, rtx,
 119                                                  enum machine_mode));
 120 static rtx expand_builtin_memcpy        PARAMS ((tree, rtx,
 121                                                  enum machine_mode));
 122 static rtx expand_builtin_strcpy        PARAMS ((tree, rtx,
 123                                                  enum machine_mode));
 124 static rtx builtin_strncpy_read_str     PARAMS ((PTR, HOST_WIDE_INT,
 125                                                  enum machine_mode));
 126 static rtx expand_builtin_strncpy       PARAMS ((tree, rtx,
 127                                                  enum machine_mode));
 128 static rtx builtin_memset_read_str      PARAMS ((PTR, HOST_WIDE_INT,
 129                                                  enum machine_mode));
 130 static rtx expand_builtin_memset        PARAMS ((tree, rtx,
 131                                                  enum machine_mode));
 132 static rtx expand_builtin_bzero         PARAMS ((tree));
 133 static rtx expand_builtin_strlen        PARAMS ((tree, rtx));
 134 static rtx expand_builtin_strstr        PARAMS ((tree, rtx,
 135                                                  enum machine_mode));
 136 static rtx expand_builtin_strpbrk       PARAMS ((tree, rtx,
 137                                                  enum machine_mode));
 138 static rtx expand_builtin_strchr        PARAMS ((tree, rtx,
 139                                                  enum machine_mode));
 140 static rtx expand_builtin_strrchr       PARAMS ((tree, rtx,
 141                                                  enum machine_mode));
 142 static rtx expand_builtin_alloca        PARAMS ((tree, rtx));
 143 static rtx expand_builtin_ffs           PARAMS ((tree, rtx, rtx));
 144 static rtx expand_builtin_frame_address PARAMS ((tree));
 145 static rtx expand_builtin_fputs         PARAMS ((tree, int));
 146 static tree stabilize_va_list           PARAMS ((tree, int));
 147 static rtx expand_builtin_expect        PARAMS ((tree, rtx));
 148 static tree fold_builtin_constant_p     PARAMS ((tree));
 149 static tree fold_builtin_classify_type  PARAMS ((tree));
 150 static tree build_function_call_expr    PARAMS ((tree, tree));
 151 static int validate_arglist             PARAMS ((tree, ...));
 152
 153 /* Return the alignment in bits of EXP, a pointer valued expression.
 154    But don't return more than MAX_ALIGN no matter what.
 155    The alignment returned is, by default, the alignment of the thing that
 156    EXP points to.  If it is not a POINTER_TYPE, 0 is returned.
 157
 158    Otherwise, look at the expression to see if we can do better, i.e., if the
 159    expression is actually pointing at an object whose alignment is tighter.  */
 160
 161 static int
 162 get_pointer_alignment (exp, max_align)
 163      tree exp;
 164      unsigned int max_align;
 165 {
 166   unsigned int align, inner;
 167
 168   if (TREE_CODE (TREE_TYPE (exp)) != POINTER_TYPE)
 169     return 0;
 170
 171   align = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
 172   align = MIN (align, max_align);
 173
 174   while (1)
 175     {
 176       switch (TREE_CODE (exp))
 177         {
 178         case NOP_EXPR:
 179         case CONVERT_EXPR:
 180         case NON_LVALUE_EXPR:
 181           exp = TREE_OPERAND (exp, 0);
 182           if (TREE_CODE (TREE_TYPE (exp)) != POINTER_TYPE)
 183             return align;
 184
 185           inner = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
 186           align = MIN (inner, max_align);
 187           break;
 188
 189         case PLUS_EXPR:
 190           /* If sum of pointer + int, restrict our maximum alignment to that
 191              imposed by the integer.  If not, we can't do any better than
 192              ALIGN.  */
 193           if (! host_integerp (TREE_OPERAND (exp, 1), 1))
 194             return align;
 195
 196           while (((tree_low_cst (TREE_OPERAND (exp, 1), 1))
 197                   & (max_align / BITS_PER_UNIT - 1))
 198                  != 0)
 199             max_align >>= 1;
 200
 201           exp = TREE_OPERAND (exp, 0);
 202           break;
 203
 204         case ADDR_EXPR:
 205           /* See what we are pointing at and look at its alignment.  */
 206           exp = TREE_OPERAND (exp, 0);
 207           if (TREE_CODE (exp) == FUNCTION_DECL)
 208             align = FUNCTION_BOUNDARY;
 209           else if (DECL_P (exp))
 210             align = DECL_ALIGN (exp);
 211 #ifdef CONSTANT_ALIGNMENT
 212           else if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c')
 213             align = CONSTANT_ALIGNMENT (exp, align);
 214 #endif
 215           return MIN (align, max_align);
 216
 217         default:
 218           return align;
 219         }
 220     }
 221 }
 222
 223 /* Compute the length of a C string.  TREE_STRING_LENGTH is not the right
 224    way, because it could contain a zero byte in the middle.
 225    TREE_STRING_LENGTH is the size of the character array, not the string.
 226
 227    The value returned is of type `ssizetype'.
 228
 229    Unfortunately, string_constant can't access the values of const char
 230    arrays with initializers, so neither can we do so here.  */
 231
 232 static tree
 233 c_strlen (src)
 234      tree src;
 235 {
 236   tree offset_node;
 237   HOST_WIDE_INT offset;
 238   int max;
 239   const char *ptr;
 240
 241   src = string_constant (src, &offset_node);
 242   if (src == 0)
 243     return 0;
 244
 245   max = TREE_STRING_LENGTH (src) - 1;
 246   ptr = TREE_STRING_POINTER (src);
 247
 248   if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
 249     {
 250       /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
 251          compute the offset to the following null if we don't know where to
 252          start searching for it.  */
 253       int i;
 254
 255       for (i = 0; i < max; i++)
 256         if (ptr[i] == 0)
 257           return 0;
 258
 259       /* We don't know the starting offset, but we do know that the string
 260          has no internal zero bytes.  We can assume that the offset falls
 261          within the bounds of the string; otherwise, the programmer deserves
 262          what he gets.  Subtract the offset from the length of the string,
 263          and return that.  This would perhaps not be valid if we were dealing
 264          with named arrays in addition to literal string constants.  */
 265
 266       return size_diffop (size_int (max), offset_node);
 267     }
 268
 269   /* We have a known offset into the string.  Start searching there for
 270      a null character if we can represent it as a single HOST_WIDE_INT.  */
 271   if (offset_node == 0)
 272     offset = 0;
 273   else if (! host_integerp (offset_node, 0))
 274     offset = -1;
 275   else
 276     offset = tree_low_cst (offset_node, 0);
 277
 278   /* If the offset is known to be out of bounds, warn, and call strlen at
 279      runtime.  */
 280   if (offset < 0 || offset > max)
 281     {
 282       warning ("offset outside bounds of constant string");
 283       return 0;
 284     }
 285
 286   /* Use strlen to search for the first zero byte.  Since any strings
 287      constructed with build_string will have nulls appended, we win even
 288      if we get handed something like (char[4])"abcd".
 289
 290      Since OFFSET is our starting index into the string, no further
 291      calculation is needed.  */
 292   return ssize_int (strlen (ptr + offset));
 293 }
 294
 295 /* Return a char pointer for a C string if it is a string constant
 296    or sum of string constant and integer constant.  */
 297
 298 static const char *
 299 c_getstr (src)
 300      tree src;
 301 {
 302   tree offset_node;
 303
 304   src = string_constant (src, &offset_node);
 305   if (src == 0)
 306     return 0;
 307
 308   if (offset_node == 0)
 309     return TREE_STRING_POINTER (src);
 310   else if (!host_integerp (offset_node, 1)
 311            || compare_tree_int (offset_node, TREE_STRING_LENGTH (src) - 1) > 0)
 312     return 0;
 313
 314   return TREE_STRING_POINTER (src) + tree_low_cst (offset_node, 1);
 315 }
 316
 317 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
 318    GET_MODE_BITSIZE (MODE) bits from string constant STR.  */
 319
 320 static rtx
 321 c_readstr (str, mode)
 322      const char *str;
 323      enum machine_mode mode;
 324 {
 325   HOST_WIDE_INT c[2];
 326   HOST_WIDE_INT ch;
 327   unsigned int i, j;
 328
 329   if (GET_MODE_CLASS (mode) != MODE_INT)
 330     abort ();
 331   c[0] = 0;
 332   c[1] = 0;
 333   ch = 1;
 334   for (i = 0; i < GET_MODE_SIZE (mode); i++)
 335     {
 336       j = i;
 337       if (WORDS_BIG_ENDIAN)
 338         j = GET_MODE_SIZE (mode) - i - 1;
 339       if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
 340           && GET_MODE_SIZE (mode) > UNITS_PER_WORD)
 341         j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
 342       j *= BITS_PER_UNIT;
 343       if (j > 2 * HOST_BITS_PER_WIDE_INT)
 344         abort ();
 345       if (ch)
 346         ch = (unsigned char) str[i];
 347       c[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
 348     }
 349   return immed_double_const (c[0], c[1], mode);
 350 }
 351
 352 /* Cast a target constant CST to target CHAR and if that value fits into
 353    host char type, return zero and put that value into variable pointed by
 354    P.  */
 355
 356 static int
 357 target_char_cast (cst, p)
 358      tree cst;
 359      char *p;
 360 {
 361   unsigned HOST_WIDE_INT val, hostval;
 362
 363   if (!host_integerp (cst, 1)
 364       || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
 365     return 1;
 366
 367   val = tree_low_cst (cst, 1);
 368   if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
 369     val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
 370
 371   hostval = val;
 372   if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
 373     hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
 374
 375   if (val != hostval)
 376     return 1;
 377
 378   *p = hostval;
 379   return 0;
 380 }
 381
 382 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
 383    times to get the address of either a higher stack frame, or a return
 384    address located within it (depending on FNDECL_CODE).  */
 385
 386 rtx
 387 expand_builtin_return_addr (fndecl_code, count, tem)
 388      enum built_in_function fndecl_code;
 389      int count;
 390      rtx tem;
 391 {
 392   int i;
 393
 394   /* Some machines need special handling before we can access
 395      arbitrary frames.  For example, on the sparc, we must first flush
 396      all register windows to the stack.  */
 397 #ifdef SETUP_FRAME_ADDRESSES
 398   if (count > 0)
 399     SETUP_FRAME_ADDRESSES ();
 400 #endif
 401
 402   /* On the sparc, the return address is not in the frame, it is in a
 403      register.  There is no way to access it off of the current frame
 404      pointer, but it can be accessed off the previous frame pointer by
 405      reading the value from the register window save area.  */
 406 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
 407   if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
 408     count--;
 409 #endif
 410
 411   /* Scan back COUNT frames to the specified frame.  */
 412   for (i = 0; i < count; i++)
 413     {
 414       /* Assume the dynamic chain pointer is in the word that the
 415          frame address points to, unless otherwise specified.  */
 416 #ifdef DYNAMIC_CHAIN_ADDRESS
 417       tem = DYNAMIC_CHAIN_ADDRESS (tem);
 418 #endif
 419       tem = memory_address (Pmode, tem);
 420       tem = gen_rtx_MEM (Pmode, tem);
 421       set_mem_alias_set (tem, get_frame_alias_set ());
 422       tem = copy_to_reg (tem);
 423     }
 424
 425   /* For __builtin_frame_address, return what we've got.  */
 426   if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
 427     return tem;
 428
 429   /* For __builtin_return_address, Get the return address from that
 430      frame.  */
 431 #ifdef RETURN_ADDR_RTX
 432   tem = RETURN_ADDR_RTX (count, tem);
 433 #else
 434   tem = memory_address (Pmode,
 435                         plus_constant (tem, GET_MODE_SIZE (Pmode)));
 436   tem = gen_rtx_MEM (Pmode, tem);
 437   set_mem_alias_set (tem, get_frame_alias_set ());
 438 #endif
 439   return tem;
 440 }
 441
 442 /* Alias set used for setjmp buffer.  */
 443 static HOST_WIDE_INT setjmp_alias_set = -1;
 444
 445 /* Construct the leading half of a __builtin_setjmp call.  Control will
 446    return to RECEIVER_LABEL.  This is used directly by sjlj exception
 447    handling code.  */
 448
 449 void
 450 expand_builtin_setjmp_setup (buf_addr, receiver_label)
 451      rtx buf_addr;
 452      rtx receiver_label;
 453 {
 454   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 455   rtx stack_save;
 456   rtx mem;
 457
 458   if (setjmp_alias_set == -1)
 459     setjmp_alias_set = new_alias_set ();
 460
 461 #ifdef POINTERS_EXTEND_UNSIGNED
 462   if (GET_MODE (buf_addr) != Pmode)
 463     buf_addr = convert_memory_address (Pmode, buf_addr);
 464 #endif
 465
 466   buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
 467
 468   emit_queue ();
 469
 470   /* We store the frame pointer and the address of receiver_label in
 471      the buffer and use the rest of it for the stack save area, which
 472      is machine-dependent.  */
 473
 474 #ifndef BUILTIN_SETJMP_FRAME_VALUE
 475 #define BUILTIN_SETJMP_FRAME_VALUE virtual_stack_vars_rtx
 476 #endif
 477
 478   mem = gen_rtx_MEM (Pmode, buf_addr);
 479   set_mem_alias_set (mem, setjmp_alias_set);
 480   emit_move_insn (mem, BUILTIN_SETJMP_FRAME_VALUE);
 481
 482   mem = gen_rtx_MEM (Pmode, plus_constant (buf_addr, GET_MODE_SIZE (Pmode))),
 483   set_mem_alias_set (mem, setjmp_alias_set);
 484
 485   emit_move_insn (validize_mem (mem),
 486                   force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
 487
 488   stack_save = gen_rtx_MEM (sa_mode,
 489                             plus_constant (buf_addr,
 490                                            2 * GET_MODE_SIZE (Pmode)));
 491   set_mem_alias_set (stack_save, setjmp_alias_set);
 492   emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
 493
 494   /* If there is further processing to do, do it.  */
 495 #ifdef HAVE_builtin_setjmp_setup
 496   if (HAVE_builtin_setjmp_setup)
 497     emit_insn (gen_builtin_setjmp_setup (buf_addr));
 498 #endif
 499
 500   /* Tell optimize_save_area_alloca that extra work is going to
 501      need to go on during alloca.  */
 502   current_function_calls_setjmp = 1;
 503
 504   /* Set this so all the registers get saved in our frame; we need to be
 505      able to copy the saved values for any registers from frames we unwind.  */
 506   current_function_has_nonlocal_label = 1;
 507 }
 508
 509 /* Construct the trailing part of a __builtin_setjmp call.
 510    This is used directly by sjlj exception handling code.  */
 511
 512 void
 513 expand_builtin_setjmp_receiver (receiver_label)
 514       rtx receiver_label ATTRIBUTE_UNUSED;
 515 {
 516   /* Clobber the FP when we get here, so we have to make sure it's
 517      marked as used by this function.  */
 518   emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
 519
 520   /* Mark the static chain as clobbered here so life information
 521      doesn't get messed up for it.  */
 522   emit_insn (gen_rtx_CLOBBER (VOIDmode, static_chain_rtx));
 523
 524   /* Now put in the code to restore the frame pointer, and argument
 525      pointer, if needed.  The code below is from expand_end_bindings
 526      in stmt.c; see detailed documentation there.  */
 527 #ifdef HAVE_nonlocal_goto
 528   if (! HAVE_nonlocal_goto)
 529 #endif
 530     emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
 531
 532 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
 533   if (fixed_regs[ARG_POINTER_REGNUM])
 534     {
 535 #ifdef ELIMINABLE_REGS
 536       size_t i;
 537       static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
 538
 539       for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
 540         if (elim_regs[i].from == ARG_POINTER_REGNUM
 541             && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
 542           break;
 543
 544       if (i == ARRAY_SIZE (elim_regs))
 545 #endif
 546         {
 547           /* Now restore our arg pointer from the address at which it
 548              was saved in our stack frame.  */
 549           emit_move_insn (virtual_incoming_args_rtx,
 550                           copy_to_reg (get_arg_pointer_save_area (cfun)));
 551         }
 552     }
 553 #endif
 554
 555 #ifdef HAVE_builtin_setjmp_receiver
 556   if (HAVE_builtin_setjmp_receiver)
 557     emit_insn (gen_builtin_setjmp_receiver (receiver_label));
 558   else
 559 #endif
 560 #ifdef HAVE_nonlocal_goto_receiver
 561     if (HAVE_nonlocal_goto_receiver)
 562       emit_insn (gen_nonlocal_goto_receiver ());
 563     else
 564 #endif
 565       { /* Nothing */ }
 566
 567   /* @@@ This is a kludge.  Not all machine descriptions define a blockage
 568      insn, but we must not allow the code we just generated to be reordered
 569      by scheduling.  Specifically, the update of the frame pointer must
 570      happen immediately, not later.  So emit an ASM_INPUT to act as blockage
 571      insn.  */
 572   emit_insn (gen_rtx_ASM_INPUT (VOIDmode, ""));
 573 }
 574
 575 /* __builtin_setjmp is passed a pointer to an array of five words (not
 576    all will be used on all machines).  It operates similarly to the C
 577    library function of the same name, but is more efficient.  Much of
 578    the code below (and for longjmp) is copied from the handling of
 579    non-local gotos.
 580
 581    NOTE: This is intended for use by GNAT and the exception handling
 582    scheme in the compiler and will only work in the method used by
 583    them.  */
 584
 585 static rtx
 586 expand_builtin_setjmp (arglist, target)
 587      tree arglist;
 588      rtx target;
 589 {
 590   rtx buf_addr, next_lab, cont_lab;
 591
 592   if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
 593     return NULL_RTX;
 594
 595   if (target == 0 || GET_CODE (target) != REG
 596       || REGNO (target) < FIRST_PSEUDO_REGISTER)
 597     target = gen_reg_rtx (TYPE_MODE (integer_type_node));
 598
 599   buf_addr = expand_expr (TREE_VALUE (arglist), NULL_RTX, VOIDmode, 0);
 600
 601   next_lab = gen_label_rtx ();
 602   cont_lab = gen_label_rtx ();
 603
 604   expand_builtin_setjmp_setup (buf_addr, next_lab);
 605
 606   /* Set TARGET to zero and branch to the continue label.  */
 607   emit_move_insn (target, const0_rtx);
 608   emit_jump_insn (gen_jump (cont_lab));
 609   emit_barrier ();
 610   emit_label (next_lab);
 611
 612   expand_builtin_setjmp_receiver (next_lab);
 613
 614   /* Set TARGET to one.  */
 615   emit_move_insn (target, const1_rtx);
 616   emit_label (cont_lab);
 617
 618   /* Tell flow about the strange goings on.  Putting `next_lab' on
 619      `nonlocal_goto_handler_labels' to indicates that function
 620      calls may traverse the arc back to this label.  */
 621
 622   current_function_has_nonlocal_label = 1;
 623   nonlocal_goto_handler_labels
 624     = gen_rtx_EXPR_LIST (VOIDmode, next_lab, nonlocal_goto_handler_labels);
 625
 626   return target;
 627 }
 628
 629 /* __builtin_longjmp is passed a pointer to an array of five words (not
 630    all will be used on all machines).  It operates similarly to the C
 631    library function of the same name, but is more efficient.  Much of
 632    the code below is copied from the handling of non-local gotos.
 633
 634    NOTE: This is intended for use by GNAT and the exception handling
 635    scheme in the compiler and will only work in the method used by
 636    them.  */
 637
 638 void
 639 expand_builtin_longjmp (buf_addr, value)
 640      rtx buf_addr, value;
 641 {
 642   rtx fp, lab, stack, insn;
 643   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 644
 645   if (setjmp_alias_set == -1)
 646     setjmp_alias_set = new_alias_set ();
 647
 648 #ifdef POINTERS_EXTEND_UNSIGNED
 649   if (GET_MODE (buf_addr) != Pmode)
 650     buf_addr = convert_memory_address (Pmode, buf_addr);
 651 #endif
 652
 653   buf_addr = force_reg (Pmode, buf_addr);
 654
 655   /* We used to store value in static_chain_rtx, but that fails if pointers
 656      are smaller than integers.  We instead require that the user must pass
 657      a second argument of 1, because that is what builtin_setjmp will
 658      return.  This also makes EH slightly more efficient, since we are no
 659      longer copying around a value that we don't care about.  */
 660   if (value != const1_rtx)
 661     abort ();
 662
 663   current_function_calls_longjmp = 1;
 664
 665 #ifdef HAVE_builtin_longjmp
 666   if (HAVE_builtin_longjmp)
 667     emit_insn (gen_builtin_longjmp (buf_addr));
 668   else
 669 #endif
 670     {
 671       fp = gen_rtx_MEM (Pmode, buf_addr);
 672       lab = gen_rtx_MEM (Pmode, plus_constant (buf_addr,
 673                                                GET_MODE_SIZE (Pmode)));
 674
 675       stack = gen_rtx_MEM (sa_mode, plus_constant (buf_addr,
 676                                                    2 * GET_MODE_SIZE (Pmode)));
 677       set_mem_alias_set (fp, setjmp_alias_set);
 678       set_mem_alias_set (lab, setjmp_alias_set);
 679       set_mem_alias_set (stack, setjmp_alias_set);
 680
 681       /* Pick up FP, label, and SP from the block and jump.  This code is
 682          from expand_goto in stmt.c; see there for detailed comments.  */
 683 #if HAVE_nonlocal_goto
 684       if (HAVE_nonlocal_goto)
 685         /* We have to pass a value to the nonlocal_goto pattern that will
 686            get copied into the static_chain pointer, but it does not matter
 687            what that value is, because builtin_setjmp does not use it.  */
 688         emit_insn (gen_nonlocal_goto (value, lab, stack, fp));
 689       else
 690 #endif
 691         {
 692           lab = copy_to_reg (lab);
 693
 694           emit_move_insn (hard_frame_pointer_rtx, fp);
 695           emit_stack_restore (SAVE_NONLOCAL, stack, NULL_RTX);
 696
 697           emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
 698           emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
 699           emit_indirect_jump (lab);
 700         }
 701     }
 702
 703   /* Search backwards and mark the jump insn as a non-local goto.
 704      Note that this precludes the use of __builtin_longjmp to a
 705      __builtin_setjmp target in the same function.  However, we've
 706      already cautioned the user that these functions are for
 707      internal exception handling use only.  */
 708   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
 709     {
 710       if (GET_CODE (insn) == JUMP_INSN)
 711         {
 712           REG_NOTES (insn) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO, const0_rtx,
 713                                               REG_NOTES (insn));
 714           break;
 715         }
 716       else if (GET_CODE (insn) == CALL_INSN)
 717         break;
 718     }
 719 }
 720
 721 /* Expand a call to __builtin_prefetch.  For a target that does not support
 722    data prefetch, evaluate the memory address argument in case it has side
 723    effects.  */
 724
 725 static void
 726 expand_builtin_prefetch (arglist)
 727      tree arglist;
 728 {
 729   tree arg0, arg1, arg2;
 730   rtx op0, op1, op2;
 731
 732   if (!validate_arglist (arglist, POINTER_TYPE, 0))
 733     return;
 734
 735   arg0 = TREE_VALUE (arglist);
 736   /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
 737      zero (read) and argument 2 (locality) defaults to 3 (high degree of
 738      locality).  */
 739   if (TREE_CHAIN (arglist))
 740     {
 741       arg1 = TREE_VALUE (TREE_CHAIN (arglist));
 742       if (TREE_CHAIN (TREE_CHAIN (arglist)))
 743         arg2 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
 744       else
 745         arg2 = build_int_2 (3, 0);
 746     }
 747   else
 748     {
 749       arg1 = integer_zero_node;
 750       arg2 = build_int_2 (3, 0);
 751     }
 752
 753   /* Argument 0 is an address.  */
 754   op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
 755
 756   /* Argument 1 (read/write flag) must be a compile-time constant int.  */
 757   if (TREE_CODE (arg1) != INTEGER_CST)
 758     {
 759        error ("second arg to `__builtin_prefetch' must be a constant");
 760        arg1 = integer_zero_node;
 761     }
 762   op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
 763   /* Argument 1 must be either zero or one.  */
 764   if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
 765     {
 766       warning ("invalid second arg to __builtin_prefetch; using zero");
 767       op1 = const0_rtx;
 768     }
 769
 770   /* Argument 2 (locality) must be a compile-time constant int.  */
 771   if (TREE_CODE (arg2) != INTEGER_CST)
 772     {
 773       error ("third arg to `__builtin_prefetch' must be a constant");
 774       arg2 = integer_zero_node;
 775     }
 776   op2 = expand_expr (arg2, NULL_RTX, VOIDmode, 0);
 777   /* Argument 2 must be 0, 1, 2, or 3.  */
 778   if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
 779     {
 780       warning ("invalid third arg to __builtin_prefetch; using zero");
 781       op2 = const0_rtx;
 782     }
 783
 784 #ifdef HAVE_prefetch
 785   if (HAVE_prefetch)
 786     {
 787       if (! (*insn_data[(int)CODE_FOR_prefetch].operand[0].predicate)
 788             (op0, Pmode))
 789         op0 = force_reg (Pmode, op0);
 790       emit_insn (gen_prefetch (op0, op1, op2));
 791     }
 792   else
 793 #endif
 794     op0 = protect_from_queue (op0, 0);
 795     /* Don't do anything with direct references to volatile memory, but
 796        generate code to handle other side effects.  */
 797     if (GET_CODE (op0) != MEM && side_effects_p (op0))
 798       emit_insn (op0);
 799 }
 800
 801 /* Get a MEM rtx for expression EXP which is the address of an operand
 802    to be used to be used in a string instruction (cmpstrsi, movstrsi, ..).  */
 803
 804 static rtx
 805 get_memory_rtx (exp)
 806      tree exp;
 807 {
 808   rtx addr = expand_expr (exp, NULL_RTX, ptr_mode, EXPAND_SUM);
 809   rtx mem;
 810
 811 #ifdef POINTERS_EXTEND_UNSIGNED
 812   if (GET_MODE (addr) != Pmode)
 813     addr = convert_memory_address (Pmode, addr);
 814 #endif
 815
 816   mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
 817
 818   /* Get an expression we can use to find the attributes to assign to MEM.
 819      If it is an ADDR_EXPR, use the operand.  Otherwise, dereference it if
 820      we can.  First remove any nops.  */
 821   while ((TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
 822          || TREE_CODE (exp) == NON_LVALUE_EXPR)
 823          && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
 824     exp = TREE_OPERAND (exp, 0);
 825
 826   if (TREE_CODE (exp) == ADDR_EXPR)
 827     {
 828       exp = TREE_OPERAND (exp, 0);
 829       set_mem_attributes (mem, exp, 0);
 830     }
 831   else if (POINTER_TYPE_P (TREE_TYPE (exp)))
 832     {
 833       exp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (exp)), exp);
 834       /* memcpy, memset and other builtin stringops can alias with anything.  */
 835       set_mem_alias_set (mem, 0);
 836     }
 837
 838   return mem;
 839 }
 840 \f
 841 /* Built-in functions to perform an untyped call and return.  */
 842
 843 /* For each register that may be used for calling a function, this
 844    gives a mode used to copy the register's value.  VOIDmode indicates
 845    the register is not used for calling a function.  If the machine
 846    has register windows, this gives only the outbound registers.
 847    INCOMING_REGNO gives the corresponding inbound register.  */
 848 static enum machine_mode apply_args_mode[FIRST_PSEUDO_REGISTER];
 849
 850 /* For each register that may be used for returning values, this gives
 851    a mode used to copy the register's value.  VOIDmode indicates the
 852    register is not used for returning values.  If the machine has
 853    register windows, this gives only the outbound registers.
 854    INCOMING_REGNO gives the corresponding inbound register.  */
 855 static enum machine_mode apply_result_mode[FIRST_PSEUDO_REGISTER];
 856
 857 /* For each register that may be used for calling a function, this
 858    gives the offset of that register into the block returned by
 859    __builtin_apply_args.  0 indicates that the register is not
 860    used for calling a function.  */
 861 static int apply_args_reg_offset[FIRST_PSEUDO_REGISTER];
 862
 863 /* Return the offset of register REGNO into the block returned by
 864    __builtin_apply_args.  This is not declared static, since it is
 865    needed in objc-act.c.  */
 866
 867 int
 868 apply_args_register_offset (regno)
 869      int regno;
 870 {
 871   apply_args_size ();
 872
 873   /* Arguments are always put in outgoing registers (in the argument
 874      block) if such make sense.  */
 875 #ifdef OUTGOING_REGNO
 876   regno = OUTGOING_REGNO(regno);
 877 #endif
 878   return apply_args_reg_offset[regno];
 879 }
 880
 881 /* Return the size required for the block returned by __builtin_apply_args,
 882    and initialize apply_args_mode.  */
 883
 884 static int
 885 apply_args_size ()
 886 {
 887   static int size = -1;
 888   int align, regno;
 889   enum machine_mode mode;
 890
 891   /* The values computed by this function never change.  */
 892   if (size < 0)
 893     {
 894       /* The first value is the incoming arg-pointer.  */
 895       size = GET_MODE_SIZE (Pmode);
 896
 897       /* The second value is the structure value address unless this is
 898          passed as an "invisible" first argument.  */
 899       if (struct_value_rtx)
 900         size += GET_MODE_SIZE (Pmode);
 901
 902       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 903         if (FUNCTION_ARG_REGNO_P (regno))
 904           {
 905             /* Search for the proper mode for copying this register's
 906                value.  I'm not sure this is right, but it works so far.  */
 907             enum machine_mode best_mode = VOIDmode;
 908
 909             for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
 910                  mode != VOIDmode;
 911                  mode = GET_MODE_WIDER_MODE (mode))
 912               if (HARD_REGNO_MODE_OK (regno, mode)
 913                   && HARD_REGNO_NREGS (regno, mode) == 1)
 914                 best_mode = mode;
 915
 916             if (best_mode == VOIDmode)
 917               for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
 918                    mode != VOIDmode;
 919                    mode = GET_MODE_WIDER_MODE (mode))
 920                 if (HARD_REGNO_MODE_OK (regno, mode)
 921                     && have_insn_for (SET, mode))
 922                   best_mode = mode;
 923
 924             if (best_mode == VOIDmode)
 925               for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_FLOAT);
 926                    mode != VOIDmode;
 927                    mode = GET_MODE_WIDER_MODE (mode))
 928                 if (HARD_REGNO_MODE_OK (regno, mode)
 929                     && have_insn_for (SET, mode))
 930                   best_mode = mode;
 931
 932             if (best_mode == VOIDmode)
 933               for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_INT);
 934                    mode != VOIDmode;
 935                    mode = GET_MODE_WIDER_MODE (mode))
 936                 if (HARD_REGNO_MODE_OK (regno, mode)
 937                     && have_insn_for (SET, mode))
 938                   best_mode = mode;
 939
 940             mode = best_mode;
 941             if (mode == VOIDmode)
 942               abort ();
 943
 944             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
 945             if (size % align != 0)
 946               size = CEIL (size, align) * align;
 947             apply_args_reg_offset[regno] = size;
 948             size += GET_MODE_SIZE (mode);
 949             apply_args_mode[regno] = mode;
 950           }
 951         else
 952           {
 953             apply_args_mode[regno] = VOIDmode;
 954             apply_args_reg_offset[regno] = 0;
 955           }
 956     }
 957   return size;
 958 }
 959
 960 /* Return the size required for the block returned by __builtin_apply,
 961    and initialize apply_result_mode.  */
 962
 963 static int
 964 apply_result_size ()
 965 {
 966   static int size = -1;
 967   int align, regno;
 968   enum machine_mode mode;
 969
 970   /* The values computed by this function never change.  */
 971   if (size < 0)
 972     {
 973       size = 0;
 974
 975       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 976         if (FUNCTION_VALUE_REGNO_P (regno))
 977           {
 978             /* Search for the proper mode for copying this register's
 979                value.  I'm not sure this is right, but it works so far.  */
 980             enum machine_mode best_mode = VOIDmode;
 981
 982             for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
 983                  mode != TImode;
 984                  mode = GET_MODE_WIDER_MODE (mode))
 985               if (HARD_REGNO_MODE_OK (regno, mode))
 986                 best_mode = mode;
 987
 988             if (best_mode == VOIDmode)
 989               for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
 990                    mode != VOIDmode;
 991                    mode = GET_MODE_WIDER_MODE (mode))
 992                 if (HARD_REGNO_MODE_OK (regno, mode)
 993                     && have_insn_for (SET, mode))
 994                   best_mode = mode;
 995
 996             if (best_mode == VOIDmode)
 997               for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_FLOAT);
 998                    mode != VOIDmode;
 999                    mode = GET_MODE_WIDER_MODE (mode))
1000                 if (HARD_REGNO_MODE_OK (regno, mode)
1001                     && have_insn_for (SET, mode))
1002                       best_mode = mode;
1003
1004             if (best_mode == VOIDmode)
1005               for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_INT);
1006                    mode != VOIDmode;
1007                    mode = GET_MODE_WIDER_MODE (mode))
1008                 if (HARD_REGNO_MODE_OK (regno, mode)
1009                     && have_insn_for (SET, mode))
1010                   best_mode = mode;
1011
1012             mode = best_mode;
1013             if (mode == VOIDmode)
1014               abort ();
1015
1016             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1017             if (size % align != 0)
1018               size = CEIL (size, align) * align;
1019             size += GET_MODE_SIZE (mode);
1020             apply_result_mode[regno] = mode;
1021           }
1022         else
1023           apply_result_mode[regno] = VOIDmode;
1024
1025       /* Allow targets that use untyped_call and untyped_return to override
1026          the size so that machine-specific information can be stored here.  */
1027 #ifdef APPLY_RESULT_SIZE
1028       size = APPLY_RESULT_SIZE;
1029 #endif
1030     }
1031   return size;
1032 }
1033
1034 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1035 /* Create a vector describing the result block RESULT.  If SAVEP is true,
1036    the result block is used to save the values; otherwise it is used to
1037    restore the values.  */
1038
1039 static rtx
1040 result_vector (savep, result)
1041      int savep;
1042      rtx result;
1043 {
1044   int regno, size, align, nelts;
1045   enum machine_mode mode;
1046   rtx reg, mem;
1047   rtx *savevec = (rtx *) alloca (FIRST_PSEUDO_REGISTER * sizeof (rtx));
1048
1049   size = nelts = 0;
1050   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1051     if ((mode = apply_result_mode[regno]) != VOIDmode)
1052       {
1053         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1054         if (size % align != 0)
1055           size = CEIL (size, align) * align;
1056         reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1057         mem = adjust_address (result, mode, size);
1058         savevec[nelts++] = (savep
1059                             ? gen_rtx_SET (VOIDmode, mem, reg)
1060                             : gen_rtx_SET (VOIDmode, reg, mem));
1061         size += GET_MODE_SIZE (mode);
1062       }
1063   return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1064 }
1065 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1066
1067 /* Save the state required to perform an untyped call with the same
1068    arguments as were passed to the current function.  */
1069
1070 static rtx
1071 expand_builtin_apply_args_1 ()
1072 {
1073   rtx registers;
1074   int size, align, regno;
1075   enum machine_mode mode;
1076
1077   /* Create a block where the arg-pointer, structure value address,
1078      and argument registers can be saved.  */
1079   registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1080
1081   /* Walk past the arg-pointer and structure value address.  */
1082   size = GET_MODE_SIZE (Pmode);
1083   if (struct_value_rtx)
1084     size += GET_MODE_SIZE (Pmode);
1085
1086   /* Save each register used in calling a function to the block.  */
1087   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1088     if ((mode = apply_args_mode[regno]) != VOIDmode)
1089       {
1090         rtx tem;
1091
1092         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1093         if (size % align != 0)
1094           size = CEIL (size, align) * align;
1095
1096         tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1097
1098         emit_move_insn (adjust_address (registers, mode, size), tem);
1099         size += GET_MODE_SIZE (mode);
1100       }
1101
1102   /* Save the arg pointer to the block.  */
1103   emit_move_insn (adjust_address (registers, Pmode, 0),
1104                   copy_to_reg (virtual_incoming_args_rtx));
1105   size = GET_MODE_SIZE (Pmode);
1106
1107   /* Save the structure value address unless this is passed as an
1108      "invisible" first argument.  */
1109   if (struct_value_incoming_rtx)
1110     {
1111       emit_move_insn (adjust_address (registers, Pmode, size),
1112                       copy_to_reg (struct_value_incoming_rtx));
1113       size += GET_MODE_SIZE (Pmode);
1114     }
1115
1116   /* Return the address of the block.  */
1117   return copy_addr_to_reg (XEXP (registers, 0));
1118 }
1119
1120 /* __builtin_apply_args returns block of memory allocated on
1121    the stack into which is stored the arg pointer, structure
1122    value address, static chain, and all the registers that might
1123    possibly be used in performing a function call.  The code is
1124    moved to the start of the function so the incoming values are
1125    saved.  */
1126
1127 static rtx
1128 expand_builtin_apply_args ()
1129 {
1130   /* Don't do __builtin_apply_args more than once in a function.
1131      Save the result of the first call and reuse it.  */
1132   if (apply_args_value != 0)
1133     return apply_args_value;
1134   {
1135     /* When this function is called, it means that registers must be
1136        saved on entry to this function.  So we migrate the
1137        call to the first insn of this function.  */
1138     rtx temp;
1139     rtx seq;
1140
1141     start_sequence ();
1142     temp = expand_builtin_apply_args_1 ();
1143     seq = get_insns ();
1144     end_sequence ();
1145
1146     apply_args_value = temp;
1147
1148     /* Put the sequence after the NOTE that starts the function.
1149        If this is inside a SEQUENCE, make the outer-level insn
1150        chain current, so the code is placed at the start of the
1151        function.  */
1152     push_topmost_sequence ();
1153     emit_insns_before (seq, NEXT_INSN (get_insns ()));
1154     pop_topmost_sequence ();
1155     return temp;
1156   }
1157 }
1158
1159 /* Perform an untyped call and save the state required to perform an
1160    untyped return of whatever value was returned by the given function.  */
1161
1162 static rtx
1163 expand_builtin_apply (function, arguments, argsize)
1164      rtx function, arguments, argsize;
1165 {
1166   int size, align, regno;
1167   enum machine_mode mode;
1168   rtx incoming_args, result, reg, dest, src, call_insn;
1169   rtx old_stack_level = 0;
1170   rtx call_fusage = 0;
1171
1172 #ifdef POINTERS_EXTEND_UNSIGNED
1173   if (GET_MODE (arguments) != Pmode)
1174     arguments = convert_memory_address (Pmode, arguments);
1175 #endif
1176
1177   /* Create a block where the return registers can be saved.  */
1178   result = assign_stack_local (BLKmode, apply_result_size (), -1);
1179
1180   /* Fetch the arg pointer from the ARGUMENTS block.  */
1181   incoming_args = gen_reg_rtx (Pmode);
1182   emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1183 #ifndef STACK_GROWS_DOWNWARD
1184   incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1185                                        incoming_args, 0, OPTAB_LIB_WIDEN);
1186 #endif
1187
1188   /* Perform postincrements before actually calling the function.  */
1189   emit_queue ();
1190
1191   /* Push a new argument block and copy the arguments.  Do not allow
1192      the (potential) memcpy call below to interfere with our stack
1193      manipulations.  */
1194   do_pending_stack_adjust ();
1195   NO_DEFER_POP;
1196
1197   /* Save the stack with nonlocal if available */
1198 #ifdef HAVE_save_stack_nonlocal
1199   if (HAVE_save_stack_nonlocal)
1200     emit_stack_save (SAVE_NONLOCAL, &old_stack_level, NULL_RTX);
1201   else
1202 #endif
1203     emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1204
1205   /* Push a block of memory onto the stack to store the memory arguments.
1206      Save the address in a register, and copy the memory arguments.  ??? I
1207      haven't figured out how the calling convention macros effect this,
1208      but it's likely that the source and/or destination addresses in
1209      the block copy will need updating in machine specific ways.  */
1210   dest = allocate_dynamic_stack_space (argsize, 0, BITS_PER_UNIT);
1211   dest = gen_rtx_MEM (BLKmode, dest);
1212   set_mem_align (dest, PARM_BOUNDARY);
1213   src = gen_rtx_MEM (BLKmode, incoming_args);
1214   set_mem_align (src, PARM_BOUNDARY);
1215   emit_block_move (dest, src, argsize);
1216
1217   /* Refer to the argument block.  */
1218   apply_args_size ();
1219   arguments = gen_rtx_MEM (BLKmode, arguments);
1220   set_mem_align (arguments, PARM_BOUNDARY);
1221
1222   /* Walk past the arg-pointer and structure value address.  */
1223   size = GET_MODE_SIZE (Pmode);
1224   if (struct_value_rtx)
1225     size += GET_MODE_SIZE (Pmode);
1226
1227   /* Restore each of the registers previously saved.  Make USE insns
1228      for each of these registers for use in making the call.  */
1229   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1230     if ((mode = apply_args_mode[regno]) != VOIDmode)
1231       {
1232         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1233         if (size % align != 0)
1234           size = CEIL (size, align) * align;
1235         reg = gen_rtx_REG (mode, regno);
1236         emit_move_insn (reg, adjust_address (arguments, mode, size));
1237         use_reg (&call_fusage, reg);
1238         size += GET_MODE_SIZE (mode);
1239       }
1240
1241   /* Restore the structure value address unless this is passed as an
1242      "invisible" first argument.  */
1243   size = GET_MODE_SIZE (Pmode);
1244   if (struct_value_rtx)
1245     {
1246       rtx value = gen_reg_rtx (Pmode);
1247       emit_move_insn (value, adjust_address (arguments, Pmode, size));
1248       emit_move_insn (struct_value_rtx, value);
1249       if (GET_CODE (struct_value_rtx) == REG)
1250           use_reg (&call_fusage, struct_value_rtx);
1251       size += GET_MODE_SIZE (Pmode);
1252     }
1253
1254   /* All arguments and registers used for the call are set up by now!  */
1255   function = prepare_call_address (function, NULL_TREE, &call_fusage, 0, 0);
1256
1257   /* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
1258      and we don't want to load it into a register as an optimization,
1259      because prepare_call_address already did it if it should be done.  */
1260   if (GET_CODE (function) != SYMBOL_REF)
1261     function = memory_address (FUNCTION_MODE, function);
1262
1263   /* Generate the actual call instruction and save the return value.  */
1264 #ifdef HAVE_untyped_call
1265   if (HAVE_untyped_call)
1266     emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
1267                                       result, result_vector (1, result)));
1268   else
1269 #endif
1270 #ifdef HAVE_call_value
1271   if (HAVE_call_value)
1272     {
1273       rtx valreg = 0;
1274
1275       /* Locate the unique return register.  It is not possible to
1276          express a call that sets more than one return register using
1277          call_value; use untyped_call for that.  In fact, untyped_call
1278          only needs to save the return registers in the given block.  */
1279       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1280         if ((mode = apply_result_mode[regno]) != VOIDmode)
1281           {
1282             if (valreg)
1283               abort (); /* HAVE_untyped_call required.  */
1284             valreg = gen_rtx_REG (mode, regno);
1285           }
1286
1287       emit_call_insn (GEN_CALL_VALUE (valreg,
1288                                       gen_rtx_MEM (FUNCTION_MODE, function),
1289                                       const0_rtx, NULL_RTX, const0_rtx));
1290
1291       emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1292     }
1293   else
1294 #endif
1295     abort ();
1296
1297   /* Find the CALL insn we just emitted.  */
1298   for (call_insn = get_last_insn ();
1299        call_insn && GET_CODE (call_insn) != CALL_INSN;
1300        call_insn = PREV_INSN (call_insn))
1301     ;
1302
1303   if (! call_insn)
1304     abort ();
1305
1306   /* Put the register usage information on the CALL.  If there is already
1307      some usage information, put ours at the end.  */
1308   if (CALL_INSN_FUNCTION_USAGE (call_insn))
1309     {
1310       rtx link;
1311
1312       for (link = CALL_INSN_FUNCTION_USAGE (call_insn); XEXP (link, 1) != 0;
1313            link = XEXP (link, 1))
1314         ;
1315
1316       XEXP (link, 1) = call_fusage;
1317     }
1318   else
1319     CALL_INSN_FUNCTION_USAGE (call_insn) = call_fusage;
1320
1321   /* Restore the stack.  */
1322 #ifdef HAVE_save_stack_nonlocal
1323   if (HAVE_save_stack_nonlocal)
1324     emit_stack_restore (SAVE_NONLOCAL, old_stack_level, NULL_RTX);
1325   else
1326 #endif
1327     emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1328
1329   OK_DEFER_POP;
1330
1331   /* Return the address of the result block.  */
1332   return copy_addr_to_reg (XEXP (result, 0));
1333 }
1334
1335 /* Perform an untyped return.  */
1336
1337 static void
1338 expand_builtin_return (result)
1339      rtx result;
1340 {
1341   int size, align, regno;
1342   enum machine_mode mode;
1343   rtx reg;
1344   rtx call_fusage = 0;
1345
1346 #ifdef POINTERS_EXTEND_UNSIGNED
1347   if (GET_MODE (result) != Pmode)
1348     result = convert_memory_address (Pmode, result);
1349 #endif
1350
1351   apply_result_size ();
1352   result = gen_rtx_MEM (BLKmode, result);
1353
1354 #ifdef HAVE_untyped_return
1355   if (HAVE_untyped_return)
1356     {
1357       emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1358       emit_barrier ();
1359       return;
1360     }
1361 #endif
1362
1363   /* Restore the return value and note that each value is used.  */
1364   size = 0;
1365   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1366     if ((mode = apply_result_mode[regno]) != VOIDmode)
1367       {
1368         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1369         if (size % align != 0)
1370           size = CEIL (size, align) * align;
1371         reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1372         emit_move_insn (reg, adjust_address (result, mode, size));
1373
1374         push_to_sequence (call_fusage);
1375         emit_insn (gen_rtx_USE (VOIDmode, reg));
1376         call_fusage = get_insns ();
1377         end_sequence ();
1378         size += GET_MODE_SIZE (mode);
1379       }
1380
1381   /* Put the USE insns before the return.  */
1382   emit_insns (call_fusage);
1383
1384   /* Return whatever values was restored by jumping directly to the end
1385      of the function.  */
1386   expand_null_return ();
1387 }
1388
1389 /* Used by expand_builtin_classify_type and fold_builtin_classify_type.  */
1390
1391 static enum type_class
1392 type_to_class (type)
1393      tree type;
1394 {
1395   switch (TREE_CODE (type))
1396     {
1397     case VOID_TYPE:        return void_type_class;
1398     case INTEGER_TYPE:     return integer_type_class;
1399     case CHAR_TYPE:        return char_type_class;
1400     case ENUMERAL_TYPE:    return enumeral_type_class;
1401     case BOOLEAN_TYPE:     return boolean_type_class;
1402     case POINTER_TYPE:     return pointer_type_class;
1403     case REFERENCE_TYPE:   return reference_type_class;
1404     case OFFSET_TYPE:      return offset_type_class;
1405     case REAL_TYPE:        return real_type_class;
1406     case COMPLEX_TYPE:     return complex_type_class;
1407     case FUNCTION_TYPE:    return function_type_class;
1408     case METHOD_TYPE:      return method_type_class;
1409     case RECORD_TYPE:      return record_type_class;
1410     case UNION_TYPE:
1411     case QUAL_UNION_TYPE:  return union_type_class;
1412     case ARRAY_TYPE:       return (TYPE_STRING_FLAG (type)
1413                                    ? string_type_class : array_type_class);
1414     case SET_TYPE:         return set_type_class;
1415     case FILE_TYPE:        return file_type_class;
1416     case LANG_TYPE:        return lang_type_class;
1417     default:               return no_type_class;
1418     }
1419 }
1420
1421 /* Expand a call to __builtin_classify_type with arguments found in
1422    ARGLIST.  */
1423
1424 static rtx
1425 expand_builtin_classify_type (arglist)
1426      tree arglist;
1427 {
1428   if (arglist != 0)
1429     return GEN_INT (type_to_class (TREE_TYPE (TREE_VALUE (arglist))));
1430   return GEN_INT (no_type_class);
1431 }
1432
1433 /* Expand expression EXP, which is a call to __builtin_constant_p.  */
1434
1435 static rtx
1436 expand_builtin_constant_p (exp)
1437      tree exp;
1438 {
1439   tree arglist = TREE_OPERAND (exp, 1);
1440   enum machine_mode value_mode = TYPE_MODE (TREE_TYPE (exp));
1441   rtx tmp;
1442
1443   if (arglist == 0)
1444     return const0_rtx;
1445   arglist = TREE_VALUE (arglist);
1446
1447   /* We have taken care of the easy cases during constant folding.  This
1448      case is not obvious, so emit (constant_p_rtx (ARGLIST)) and let CSE get a
1449      chance to see if it can deduce whether ARGLIST is constant.  */
1450
1451   tmp = expand_expr (arglist, NULL_RTX, VOIDmode, 0);
1452   tmp = gen_rtx_CONSTANT_P_RTX (value_mode, tmp);
1453   return tmp;
1454 }
1455
1456 /* Expand a call to one of the builtin math functions (sin, cos, or sqrt).
1457    Return 0 if a normal call should be emitted rather than expanding the
1458    function in-line.  EXP is the expression that is a call to the builtin
1459    function; if convenient, the result should be placed in TARGET.
1460    SUBTARGET may be used as the target for computing one of EXP's operands.  */
1461
1462 static rtx
1463 expand_builtin_mathfn (exp, target, subtarget)
1464      tree exp;
1465      rtx target, subtarget;
1466 {
1467   optab builtin_optab;
1468   rtx op0, insns;
1469   tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
1470   tree arglist = TREE_OPERAND (exp, 1);
1471
1472   if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
1473     return 0;
1474
1475   /* Stabilize and compute the argument.  */
1476   if (TREE_CODE (TREE_VALUE (arglist)) != VAR_DECL
1477       && TREE_CODE (TREE_VALUE (arglist)) != PARM_DECL)
1478     {
1479       exp = copy_node (exp);
1480       TREE_OPERAND (exp, 1) = arglist;
1481       /* Wrap the computation of the argument in a SAVE_EXPR.  That
1482          way, if we need to expand the argument again (as in the
1483          flag_errno_math case below where we cannot directly set
1484          errno), we will not perform side-effects more than once.
1485          Note that here we're mutating the original EXP as well as the
1486          copy; that's the right thing to do in case the original EXP
1487          is expanded later.  */
1488       TREE_VALUE (arglist) = save_expr (TREE_VALUE (arglist));
1489       arglist = copy_node (arglist);
1490     }
1491   op0 = expand_expr (TREE_VALUE (arglist), subtarget, VOIDmode, 0);
1492
1493   /* Make a suitable register to place result in.  */
1494   target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
1495
1496   emit_queue ();
1497   start_sequence ();
1498
1499   switch (DECL_FUNCTION_CODE (fndecl))
1500     {
1501     case BUILT_IN_SIN:
1502     case BUILT_IN_SINF:
1503     case BUILT_IN_SINL:
1504       builtin_optab = sin_optab; break;
1505     case BUILT_IN_COS:
1506     case BUILT_IN_COSF:
1507     case BUILT_IN_COSL:
1508       builtin_optab = cos_optab; break;
1509     case BUILT_IN_SQRT:
1510     case BUILT_IN_SQRTF:
1511     case BUILT_IN_SQRTL:
1512       builtin_optab = sqrt_optab; break;
1513      default:
1514       abort ();
1515     }
1516
1517   /* Compute into TARGET.
1518      Set TARGET to wherever the result comes back.  */
1519   target = expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist))),
1520                         builtin_optab, op0, target, 0);
1521
1522   /* If we were unable to expand via the builtin, stop the
1523      sequence (without outputting the insns) and return 0, causing
1524      a call to the library function.  */
1525   if (target == 0)
1526     {
1527       end_sequence ();
1528       return 0;
1529     }
1530
1531   /* If errno must be maintained and if we are not allowing unsafe
1532      math optimizations, check the result.  */
1533
1534   if (flag_errno_math && ! flag_unsafe_math_optimizations)
1535     {
1536       rtx lab1;
1537
1538       /* Don't define the builtin FP instructions
1539          if your machine is not IEEE.  */
1540       if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT)
1541         abort ();
1542
1543       lab1 = gen_label_rtx ();
1544
1545       /* Test the result; if it is NaN, set errno=EDOM because
1546          the argument was not in the domain.  */
1547       emit_cmp_and_jump_insns (target, target, EQ, 0, GET_MODE (target),
1548                                0, lab1);
1549
1550 #ifdef TARGET_EDOM
1551         {
1552 #ifdef GEN_ERRNO_RTX
1553           rtx errno_rtx = GEN_ERRNO_RTX;
1554 #else
1555           rtx errno_rtx
1556             = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1557 #endif
1558
1559           emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1560         }
1561 #else
1562       /* We can't set errno=EDOM directly; let the library call do it.
1563          Pop the arguments right away in case the call gets deleted.  */
1564       NO_DEFER_POP;
1565       expand_call (exp, target, 0);
1566       OK_DEFER_POP;
1567 #endif
1568
1569       emit_label (lab1);
1570     }
1571
1572   /* Output the entire sequence.  */
1573   insns = get_insns ();
1574   end_sequence ();
1575   emit_insns (insns);
1576
1577   return target;
1578 }
1579
1580 /* Expand expression EXP which is a call to the strlen builtin.  Return 0
1581    if we failed the caller should emit a normal call, otherwise
1582    try to get the result in TARGET, if convenient.  */
1583
1584 static rtx
1585 expand_builtin_strlen (exp, target)
1586      tree exp;
1587      rtx target;
1588 {
1589   tree arglist = TREE_OPERAND (exp, 1);
1590   enum machine_mode value_mode = TYPE_MODE (TREE_TYPE (exp));
1591
1592   if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
1593     return 0;
1594   else
1595     {
1596       rtx pat;
1597       tree src = TREE_VALUE (arglist);
1598
1599       int align
1600         = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
1601
1602       rtx result, src_reg, char_rtx, before_strlen;
1603       enum machine_mode insn_mode = value_mode, char_mode;
1604       enum insn_code icode = CODE_FOR_nothing;
1605
1606       /* If SRC is not a pointer type, don't do this operation inline.  */
1607       if (align == 0)
1608         return 0;
1609
1610       /* Bail out if we can't compute strlen in the right mode.  */
1611       while (insn_mode != VOIDmode)
1612         {
1613           icode = strlen_optab->handlers[(int) insn_mode].insn_code;
1614           if (icode != CODE_FOR_nothing)
1615             break;
1616
1617           insn_mode = GET_MODE_WIDER_MODE (insn_mode);
1618         }
1619       if (insn_mode == VOIDmode)
1620         return 0;
1621
1622       /* Make a place to write the result of the instruction.  */
1623       result = target;
1624       if (! (result != 0
1625              && GET_CODE (result) == REG
1626              && GET_MODE (result) == insn_mode
1627              && REGNO (result) >= FIRST_PSEUDO_REGISTER))
1628         result = gen_reg_rtx (insn_mode);
1629
1630       /* Make a place to hold the source address.  We will not expand
1631          the actual source until we are sure that the expansion will
1632          not fail -- there are trees that cannot be expanded twice.  */
1633       src_reg = gen_reg_rtx (Pmode);
1634
1635       /* Mark the beginning of the strlen sequence so we can emit the
1636          source operand later.  */
1637       before_strlen = get_last_insn();
1638
1639       char_rtx = const0_rtx;
1640       char_mode = insn_data[(int) icode].operand[2].mode;
1641       if (! (*insn_data[(int) icode].operand[2].predicate) (char_rtx,
1642                                                             char_mode))
1643         char_rtx = copy_to_mode_reg (char_mode, char_rtx);
1644
1645       pat = GEN_FCN (icode) (result, gen_rtx_MEM (BLKmode, src_reg),
1646                              char_rtx, GEN_INT (align));
1647       if (! pat)
1648         return 0;
1649       emit_insn (pat);
1650
1651       /* Now that we are assured of success, expand the source.  */
1652       start_sequence ();
1653       pat = memory_address (BLKmode,
1654                             expand_expr (src, src_reg, ptr_mode, EXPAND_SUM));
1655       if (pat != src_reg)
1656         emit_move_insn (src_reg, pat);
1657       pat = gen_sequence ();
1658       end_sequence ();
1659
1660       if (before_strlen)
1661         emit_insn_after (pat, before_strlen);
1662       else
1663         emit_insn_before (pat, get_insns ());
1664
1665       /* Return the value in the proper mode for this function.  */
1666       if (GET_MODE (result) == value_mode)
1667         target = result;
1668       else if (target != 0)
1669         convert_move (target, result, 0);
1670       else
1671         target = convert_to_mode (value_mode, result, 0);
1672
1673       return target;
1674     }
1675 }
1676
1677 /* Expand a call to the strstr builtin.  Return 0 if we failed the
1678    caller should emit a normal call, otherwise try to get the result
1679    in TARGET, if convenient (and in mode MODE if that's convenient).  */
1680
1681 static rtx
1682 expand_builtin_strstr (arglist, target, mode)
1683      tree arglist;
1684      rtx target;
1685      enum machine_mode mode;
1686 {
1687   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
1688     return 0;
1689   else
1690     {
1691       tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
1692       tree fn;
1693       const char *p1, *p2;
1694
1695       p2 = c_getstr (s2);
1696       if (p2 == NULL)
1697         return 0;
1698
1699       p1 = c_getstr (s1);
1700       if (p1 != NULL)
1701         {
1702           const char *r = strstr (p1, p2);
1703
1704           if (r == NULL)
1705             return const0_rtx;
1706
1707           /* Return an offset into the constant string argument.  */
1708           return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
1709                                            s1, ssize_int (r - p1))),
1710                               target, mode, EXPAND_NORMAL);
1711         }
1712
1713       if (p2[0] == '\0')
1714         return expand_expr (s1, target, mode, EXPAND_NORMAL);
1715
1716       if (p2[1] != '\0')
1717         return 0;
1718
1719       fn = built_in_decls[BUILT_IN_STRCHR];
1720       if (!fn)
1721         return 0;
1722
1723       /* New argument list transforming strstr(s1, s2) to
1724          strchr(s1, s2[0]).  */
1725       arglist =
1726         build_tree_list (NULL_TREE, build_int_2 (p2[0], 0));
1727       arglist = tree_cons (NULL_TREE, s1, arglist);
1728       return expand_expr (build_function_call_expr (fn, arglist),
1729                           target, mode, EXPAND_NORMAL);
1730     }
1731 }
1732
1733 /* Expand a call to the strchr builtin.  Return 0 if we failed the
1734    caller should emit a normal call, otherwise try to get the result
1735    in TARGET, if convenient (and in mode MODE if that's convenient).  */
1736
1737 static rtx
1738 expand_builtin_strchr (arglist, target, mode)
1739      tree arglist;
1740      rtx target;
1741      enum machine_mode mode;
1742 {
1743   if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
1744     return 0;
1745   else
1746     {
1747       tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
1748       const char *p1;
1749
1750       if (TREE_CODE (s2) != INTEGER_CST)
1751         return 0;
1752
1753       p1 = c_getstr (s1);
1754       if (p1 != NULL)
1755         {
1756           char c;
1757           const char *r;
1758
1759           if (target_char_cast (s2, &c))
1760             return 0;
1761
1762           r = strchr (p1, c);
1763
1764           if (r == NULL)
1765             return const0_rtx;
1766
1767           /* Return an offset into the constant string argument.  */
1768           return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
1769                                            s1, ssize_int (r - p1))),
1770                               target, mode, EXPAND_NORMAL);
1771         }
1772
1773       /* FIXME: Should use here strchrM optab so that ports can optimize
1774          this.  */
1775       return 0;
1776     }
1777 }
1778
1779 /* Expand a call to the strrchr builtin.  Return 0 if we failed the
1780    caller should emit a normal call, otherwise try to get the result
1781    in TARGET, if convenient (and in mode MODE if that's convenient).  */
1782
1783 static rtx
1784 expand_builtin_strrchr (arglist, target, mode)
1785      tree arglist;
1786      rtx target;
1787      enum machine_mode mode;
1788 {
1789   if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
1790     return 0;
1791   else
1792     {
1793       tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
1794       tree fn;
1795       const char *p1;
1796
1797       if (TREE_CODE (s2) != INTEGER_CST)
1798         return 0;
1799
1800       p1 = c_getstr (s1);
1801       if (p1 != NULL)
1802         {
1803           char c;
1804           const char *r;
1805
1806           if (target_char_cast (s2, &c))
1807             return 0;
1808
1809           r = strrchr (p1, c);
1810
1811           if (r == NULL)
1812             return const0_rtx;
1813
1814           /* Return an offset into the constant string argument.  */
1815           return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
1816                                            s1, ssize_int (r - p1))),
1817                               target, mode, EXPAND_NORMAL);
1818         }
1819
1820       if (! integer_zerop (s2))
1821         return 0;
1822
1823       fn = built_in_decls[BUILT_IN_STRCHR];
1824       if (!fn)
1825         return 0;
1826
1827       /* Transform strrchr(s1, '\0') to strchr(s1, '\0').  */
1828       return expand_expr (build_function_call_expr (fn, arglist),
1829                           target, mode, EXPAND_NORMAL);
1830     }
1831 }
1832
1833 /* Expand a call to the strpbrk builtin.  Return 0 if we failed the
1834    caller should emit a normal call, otherwise try to get the result
1835    in TARGET, if convenient (and in mode MODE if that's convenient).  */
1836
1837 static rtx
1838 expand_builtin_strpbrk (arglist, target, mode)
1839      tree arglist;
1840      rtx target;
1841      enum machine_mode mode;
1842 {
1843   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
1844     return 0;
1845   else
1846     {
1847       tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
1848       tree fn;
1849       const char *p1, *p2;
1850
1851       p2 = c_getstr (s2);
1852       if (p2 == NULL)
1853         return 0;
1854
1855       p1 = c_getstr (s1);
1856       if (p1 != NULL)
1857         {
1858           const char *r = strpbrk (p1, p2);
1859
1860           if (r == NULL)
1861             return const0_rtx;
1862
1863           /* Return an offset into the constant string argument.  */
1864           return expand_expr (fold (build (PLUS_EXPR, TREE_TYPE (s1),
1865                                            s1, ssize_int (r - p1))),
1866                               target, mode, EXPAND_NORMAL);
1867         }
1868
1869       if (p2[0] == '\0')
1870         {
1871           /* strpbrk(x, "") == NULL.
1872              Evaluate and ignore the arguments in case they had
1873              side-effects.  */
1874           expand_expr (s1, const0_rtx, VOIDmode, EXPAND_NORMAL);
1875           return const0_rtx;
1876         }
1877
1878       if (p2[1] != '\0')
1879         return 0;  /* Really call strpbrk.  */
1880
1881       fn = built_in_decls[BUILT_IN_STRCHR];
1882       if (!fn)
1883         return 0;
1884
1885       /* New argument list transforming strpbrk(s1, s2) to
1886          strchr(s1, s2[0]).  */
1887       arglist =
1888         build_tree_list (NULL_TREE, build_int_2 (p2[0], 0));
1889       arglist = tree_cons (NULL_TREE, s1, arglist);
1890       return expand_expr (build_function_call_expr (fn, arglist),
1891                           target, mode, EXPAND_NORMAL);
1892     }
1893 }
1894
1895 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
1896    bytes from constant string DATA + OFFSET and return it as target
1897    constant.  */
1898
1899 static rtx
1900 builtin_memcpy_read_str (data, offset, mode)
1901      PTR data;
1902      HOST_WIDE_INT offset;
1903      enum machine_mode mode;
1904 {
1905   const char *str = (const char *) data;
1906
1907   if (offset < 0
1908       || ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
1909           > strlen (str) + 1))
1910     abort ();  /* Attempt to read past the end of constant string.  */
1911
1912   return c_readstr (str + offset, mode);
1913 }
1914
1915 /* Expand a call to the memcpy builtin, with arguments in ARGLIST.
1916    Return 0 if we failed, the caller should emit a normal call, otherwise
1917    try to get the result in TARGET, if convenient (and in mode MODE if
1918    that's convenient).  */
1919
1920 static rtx
1921 expand_builtin_memcpy (arglist, target, mode)
1922      tree arglist;
1923      rtx target;
1924      enum machine_mode mode;
1925 {
1926   if (!validate_arglist (arglist,
1927                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
1928     return 0;
1929   else
1930     {
1931       tree dest = TREE_VALUE (arglist);
1932       tree src = TREE_VALUE (TREE_CHAIN (arglist));
1933       tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
1934       const char *src_str;
1935
1936       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
1937       unsigned int dest_align
1938         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
1939       rtx dest_mem, src_mem, dest_addr, len_rtx;
1940
1941       /* If DEST is not a pointer type, call the normal function.  */
1942       if (dest_align == 0)
1943         return 0;
1944
1945       /* If the LEN parameter is zero, return DEST.  */
1946       if (host_integerp (len, 1) && tree_low_cst (len, 1) == 0)
1947         {
1948           /* Evaluate and ignore SRC in case it has side-effects.  */
1949           expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
1950           return expand_expr (dest, target, mode, EXPAND_NORMAL);
1951         }
1952
1953       /* If either SRC is not a pointer type, don't do this
1954          operation in-line.  */
1955       if (src_align == 0)
1956         return 0;
1957
1958       dest_mem = get_memory_rtx (dest);
1959       set_mem_align (dest_mem, dest_align);
1960       len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
1961       src_str = c_getstr (src);
1962
1963       /* If SRC is a string constant and block move would be done
1964          by pieces, we can avoid loading the string from memory
1965          and only stored the computed constants.  */
1966       if (src_str
1967           && GET_CODE (len_rtx) == CONST_INT
1968           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
1969           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
1970                                   (PTR) src_str, dest_align))
1971         {
1972           store_by_pieces (dest_mem, INTVAL (len_rtx),
1973                            builtin_memcpy_read_str,
1974                            (PTR) src_str, dest_align);
1975           return force_operand (XEXP (dest_mem, 0), NULL_RTX);
1976         }
1977
1978       src_mem = get_memory_rtx (src);
1979       set_mem_align (src_mem, src_align);
1980
1981       /* Copy word part most expediently.  */
1982       dest_addr = emit_block_move (dest_mem, src_mem, len_rtx);
1983
1984       if (dest_addr == 0)
1985         dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
1986
1987       return dest_addr;
1988     }
1989 }
1990
1991 /* Expand expression EXP, which is a call to the strcpy builtin.  Return 0
1992    if we failed the caller should emit a normal call, otherwise try to get
1993    the result in TARGET, if convenient (and in mode MODE if that's
1994    convenient).  */
1995
1996 static rtx
1997 expand_builtin_strcpy (exp, target, mode)
1998      tree exp;
1999      rtx target;
2000      enum machine_mode mode;
2001 {
2002   tree arglist = TREE_OPERAND (exp, 1);
2003   tree fn, len;
2004
2005   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2006     return 0;
2007
2008   fn = built_in_decls[BUILT_IN_MEMCPY];
2009   if (!fn)
2010     return 0;
2011
2012   len = c_strlen (TREE_VALUE (TREE_CHAIN (arglist)));
2013   if (len == 0)
2014     return 0;
2015
2016   len = size_binop (PLUS_EXPR, len, ssize_int (1));
2017   chainon (arglist, build_tree_list (NULL_TREE, len));
2018   return expand_expr (build_function_call_expr (fn, arglist),
2019                       target, mode, EXPAND_NORMAL);
2020 }
2021
2022 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
2023    bytes from constant string DATA + OFFSET and return it as target
2024    constant.  */
2025
2026 static rtx
2027 builtin_strncpy_read_str (data, offset, mode)
2028      PTR data;
2029      HOST_WIDE_INT offset;
2030      enum machine_mode mode;
2031 {
2032   const char *str = (const char *) data;
2033
2034   if ((unsigned HOST_WIDE_INT) offset > strlen (str))
2035     return const0_rtx;
2036
2037   return c_readstr (str + offset, mode);
2038 }
2039
2040 /* Expand expression EXP, which is a call to the strncpy builtin.  Return 0
2041    if we failed the caller should emit a normal call.  */
2042
2043 static rtx
2044 expand_builtin_strncpy (arglist, target, mode)
2045      tree arglist;
2046      rtx target;
2047      enum machine_mode mode;
2048 {
2049   if (!validate_arglist (arglist,
2050                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2051     return 0;
2052   else
2053     {
2054       tree slen = c_strlen (TREE_VALUE (TREE_CHAIN (arglist)));
2055       tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2056       tree fn;
2057
2058       /* We must be passed a constant len parameter.  */
2059       if (TREE_CODE (len) != INTEGER_CST)
2060         return 0;
2061
2062       /* If the len parameter is zero, return the dst parameter.  */
2063       if (compare_tree_int (len, 0) == 0)
2064         {
2065         /* Evaluate and ignore the src argument in case it has
2066            side-effects.  */
2067           expand_expr (TREE_VALUE (TREE_CHAIN (arglist)), const0_rtx,
2068                        VOIDmode, EXPAND_NORMAL);
2069           /* Return the dst parameter.  */
2070           return expand_expr (TREE_VALUE (arglist), target, mode,
2071                               EXPAND_NORMAL);
2072         }
2073
2074       /* Now, we must be passed a constant src ptr parameter.  */
2075       if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
2076         return 0;
2077
2078       slen = size_binop (PLUS_EXPR, slen, ssize_int (1));
2079
2080       /* We're required to pad with trailing zeros if the requested
2081          len is greater than strlen(s2)+1.  In that case try to
2082          use store_by_pieces, if it fails, punt.  */
2083       if (tree_int_cst_lt (slen, len))
2084         {
2085           tree dest = TREE_VALUE (arglist);
2086           unsigned int dest_align
2087             = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
2088           const char *p = c_getstr (TREE_VALUE (TREE_CHAIN (arglist)));
2089           rtx dest_mem;
2090
2091           if (!p || dest_align == 0 || !host_integerp (len, 1)
2092               || !can_store_by_pieces (tree_low_cst (len, 1),
2093                                        builtin_strncpy_read_str,
2094                                        (PTR) p, dest_align))
2095             return 0;
2096
2097           dest_mem = get_memory_rtx (dest);
2098           store_by_pieces (dest_mem, tree_low_cst (len, 1),
2099                            builtin_strncpy_read_str,
2100                            (PTR) p, dest_align);
2101           return force_operand (XEXP (dest_mem, 0), NULL_RTX);
2102         }
2103
2104       /* OK transform into builtin memcpy.  */
2105       fn = built_in_decls[BUILT_IN_MEMCPY];
2106       if (!fn)
2107         return 0;
2108       return expand_expr (build_function_call_expr (fn, arglist),
2109                           target, mode, EXPAND_NORMAL);
2110     }
2111 }
2112
2113 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
2114    bytes from constant string DATA + OFFSET and return it as target
2115    constant.  */
2116
2117 static rtx
2118 builtin_memset_read_str (data, offset, mode)
2119      PTR data;
2120      HOST_WIDE_INT offset ATTRIBUTE_UNUSED;
2121      enum machine_mode mode;
2122 {
2123   const char *c = (const char *) data;
2124   char *p = alloca (GET_MODE_SIZE (mode));
2125
2126   memset (p, *c, GET_MODE_SIZE (mode));
2127
2128   return c_readstr (p, mode);
2129 }
2130
2131 /* Expand expression EXP, which is a call to the memset builtin.  Return 0
2132    if we failed the caller should emit a normal call, otherwise try to get
2133    the result in TARGET, if convenient (and in mode MODE if that's
2134    convenient).  */
2135
2136 static rtx
2137 expand_builtin_memset (exp, target, mode)
2138      tree exp;
2139      rtx target;
2140      enum machine_mode mode;
2141 {
2142   tree arglist = TREE_OPERAND (exp, 1);
2143
2144   if (!validate_arglist (arglist,
2145                          POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
2146     return 0;
2147   else
2148     {
2149       tree dest = TREE_VALUE (arglist);
2150       tree val = TREE_VALUE (TREE_CHAIN (arglist));
2151       tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2152       char c;
2153
2154       unsigned int dest_align
2155         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
2156       rtx dest_mem, dest_addr, len_rtx;
2157
2158       /* If DEST is not a pointer type, don't do this
2159          operation in-line.  */
2160       if (dest_align == 0)
2161         return 0;
2162
2163       /* If the LEN parameter is zero, return DEST.  */
2164       if (host_integerp (len, 1) && tree_low_cst (len, 1) == 0)
2165         {
2166           /* Evaluate and ignore VAL in case it has side-effects.  */
2167           expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
2168           return expand_expr (dest, target, mode, EXPAND_NORMAL);
2169         }
2170
2171       if (TREE_CODE (val) != INTEGER_CST)
2172         return 0;
2173
2174       if (target_char_cast (val, &c))
2175         return 0;
2176
2177       if (c)
2178         {
2179           if (!host_integerp (len, 1))
2180             return 0;
2181           if (!can_store_by_pieces (tree_low_cst (len, 1),
2182                                     builtin_memset_read_str, (PTR) &c,
2183                                     dest_align))
2184             return 0;
2185
2186           dest_mem = get_memory_rtx (dest);
2187           store_by_pieces (dest_mem, tree_low_cst (len, 1),
2188                            builtin_memset_read_str,
2189                            (PTR) &c, dest_align);
2190           return force_operand (XEXP (dest_mem, 0), NULL_RTX);
2191         }
2192
2193       len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
2194
2195       dest_mem = get_memory_rtx (dest);
2196       set_mem_align (dest_mem, dest_align);
2197       dest_addr = clear_storage (dest_mem, len_rtx);
2198
2199       if (dest_addr == 0)
2200         dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2201
2202       return dest_addr;
2203     }
2204 }
2205
2206 /* Expand expression EXP, which is a call to the bzero builtin.  Return 0
2207    if we failed the caller should emit a normal call.  */
2208
2209 static rtx
2210 expand_builtin_bzero (exp)
2211      tree exp;
2212 {
2213   tree arglist = TREE_OPERAND (exp, 1);
2214   tree dest, size, newarglist;
2215   rtx result;
2216
2217   if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2218     return NULL_RTX;
2219
2220   dest = TREE_VALUE (arglist);
2221   size = TREE_VALUE (TREE_CHAIN (arglist));
2222
2223   /* New argument list transforming bzero(ptr x, int y) to
2224      memset(ptr x, int 0, size_t y).   This is done this way
2225      so that if it isn't expanded inline, we fallback to
2226      calling bzero instead of memset.  */
2227
2228   newarglist = build_tree_list (NULL_TREE, convert (sizetype, size));
2229   newarglist = tree_cons (NULL_TREE, integer_zero_node, newarglist);
2230   newarglist = tree_cons (NULL_TREE, dest, newarglist);
2231
2232   TREE_OPERAND (exp, 1) = newarglist;
2233   result = expand_builtin_memset (exp, const0_rtx, VOIDmode);
2234
2235   /* Always restore the original arguments.  */
2236   TREE_OPERAND (exp, 1) = arglist;
2237
2238   return result;
2239 }
2240
2241 /* Expand expression EXP, which is a call to the memcmp or the strcmp builtin.
2242    ARGLIST is the argument list for this call.  Return 0 if we failed and the
2243    caller should emit a normal call, otherwise try to get the result in
2244    TARGET, if convenient (and in mode MODE, if that's convenient).  */
2245
2246 static rtx
2247 expand_builtin_memcmp (exp, arglist, target, mode)
2248      tree exp;
2249      tree arglist;
2250      rtx target;
2251      enum machine_mode mode;
2252 {
2253   tree arg1, arg2, len;
2254
2255   if (!validate_arglist (arglist,
2256                       POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2257     return 0;
2258
2259   arg1 = TREE_VALUE (arglist);
2260   arg2 = TREE_VALUE (TREE_CHAIN (arglist));
2261   len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2262
2263   /* If the len parameter is zero, return zero.  */
2264   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 0)
2265     {
2266       /* Evaluate and ignore arg1 and arg2 in case they have
2267          side-effects.  */
2268       expand_expr (arg1, const0_rtx, VOIDmode, EXPAND_NORMAL);
2269       expand_expr (arg2, const0_rtx, VOIDmode, EXPAND_NORMAL);
2270       return const0_rtx;
2271     }
2272
2273   /* If len parameter is one, return an expression corresponding to
2274      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
2275   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
2276     {
2277       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
2278       tree cst_uchar_ptr_node = build_pointer_type (cst_uchar_node);
2279       tree ind1 =
2280       fold (build1 (CONVERT_EXPR, integer_type_node,
2281                     build1 (INDIRECT_REF, cst_uchar_node,
2282                             build1 (NOP_EXPR, cst_uchar_ptr_node, arg1))));
2283       tree ind2 =
2284       fold (build1 (CONVERT_EXPR, integer_type_node,
2285                     build1 (INDIRECT_REF, cst_uchar_node,
2286                             build1 (NOP_EXPR, cst_uchar_ptr_node, arg2))));
2287       tree result = fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
2288       return expand_expr (result, target, mode, EXPAND_NORMAL);
2289     }
2290
2291 #ifdef HAVE_cmpstrsi
2292   {
2293     rtx arg1_rtx, arg2_rtx, arg3_rtx;
2294     rtx result;
2295     rtx insn;
2296
2297     int arg1_align
2298       = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
2299     int arg2_align
2300       = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
2301     enum machine_mode insn_mode
2302       = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
2303
2304     /* If we don't have POINTER_TYPE, call the function.  */
2305     if (arg1_align == 0 || arg2_align == 0)
2306       return 0;
2307
2308     /* Make a place to write the result of the instruction.  */
2309     result = target;
2310     if (! (result != 0
2311            && GET_CODE (result) == REG && GET_MODE (result) == insn_mode
2312            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
2313       result = gen_reg_rtx (insn_mode);
2314
2315     arg1_rtx = get_memory_rtx (arg1);
2316     arg2_rtx = get_memory_rtx (arg2);
2317     arg3_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
2318     if (!HAVE_cmpstrsi)
2319       insn = NULL_RTX;
2320     else
2321       insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
2322                            GEN_INT (MIN (arg1_align, arg2_align)));
2323
2324     if (insn)
2325       emit_insn (insn);
2326     else
2327       emit_library_call_value (memcmp_libfunc, result, LCT_PURE_MAKE_BLOCK,
2328                                TYPE_MODE (integer_type_node), 3,
2329                                XEXP (arg1_rtx, 0), Pmode,
2330                                XEXP (arg2_rtx, 0), Pmode,
2331                                convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
2332                                                 TREE_UNSIGNED (sizetype)),
2333                                TYPE_MODE (sizetype));
2334
2335     /* Return the value in the proper mode for this function.  */
2336     mode = TYPE_MODE (TREE_TYPE (exp));
2337     if (GET_MODE (result) == mode)
2338       return result;
2339     else if (target != 0)
2340       {
2341         convert_move (target, result, 0);
2342         return target;
2343       }
2344     else
2345       return convert_to_mode (mode, result, 0);
2346   }
2347 #endif
2348
2349   return 0;
2350 }
2351
2352 /* Expand expression EXP, which is a call to the strcmp builtin.  Return 0
2353    if we failed the caller should emit a normal call, otherwise try to get
2354    the result in TARGET, if convenient.  */
2355
2356 static rtx
2357 expand_builtin_strcmp (exp, target, mode)
2358      tree exp;
2359      rtx target;
2360      enum machine_mode mode;
2361 {
2362   tree arglist = TREE_OPERAND (exp, 1);
2363   tree arg1, arg2, len, len2, fn;
2364   const char *p1, *p2;
2365
2366   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2367     return 0;
2368
2369   arg1 = TREE_VALUE (arglist);
2370   arg2 = TREE_VALUE (TREE_CHAIN (arglist));
2371
2372   p1 = c_getstr (arg1);
2373   p2 = c_getstr (arg2);
2374
2375   if (p1 && p2)
2376     {
2377       const int i = strcmp (p1, p2);
2378       return (i < 0 ? constm1_rtx : (i > 0 ? const1_rtx : const0_rtx));
2379     }
2380
2381   /* If either arg is "", return an expression corresponding to
2382      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
2383   if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
2384     {
2385       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
2386       tree cst_uchar_ptr_node = build_pointer_type (cst_uchar_node);
2387       tree ind1 =
2388         fold (build1 (CONVERT_EXPR, integer_type_node,
2389                       build1 (INDIRECT_REF, cst_uchar_node,
2390                               build1 (NOP_EXPR, cst_uchar_ptr_node, arg1))));
2391       tree ind2 =
2392         fold (build1 (CONVERT_EXPR, integer_type_node,
2393                       build1 (INDIRECT_REF, cst_uchar_node,
2394                               build1 (NOP_EXPR, cst_uchar_ptr_node, arg2))));
2395       tree result = fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
2396       return expand_expr (result, target, mode, EXPAND_NORMAL);
2397     }
2398
2399   len = c_strlen (arg1);
2400   len2 = c_strlen (arg2);
2401
2402   if (len)
2403     len = size_binop (PLUS_EXPR, ssize_int (1), len);
2404
2405   if (len2)
2406     len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
2407
2408   /* If we don't have a constant length for the first, use the length
2409      of the second, if we know it.  We don't require a constant for
2410      this case; some cost analysis could be done if both are available
2411      but neither is constant.  For now, assume they're equally cheap
2412      unless one has side effects.
2413
2414      If both strings have constant lengths, use the smaller.  This
2415      could arise if optimization results in strcpy being called with
2416      two fixed strings, or if the code was machine-generated.  We should
2417      add some code to the `memcmp' handler below to deal with such
2418      situations, someday.  */
2419
2420   if (!len || TREE_CODE (len) != INTEGER_CST)
2421     {
2422       if (len2 && !TREE_SIDE_EFFECTS (len2))
2423         len = len2;
2424       else if (len == 0)
2425         return 0;
2426     }
2427   else if (len2 && TREE_CODE (len2) == INTEGER_CST
2428            && tree_int_cst_lt (len2, len))
2429     len = len2;
2430
2431   /* If both arguments have side effects, we cannot optimize.  */
2432   if (TREE_SIDE_EFFECTS (len))
2433     return 0;
2434
2435   fn = built_in_decls[BUILT_IN_MEMCMP];
2436   if (!fn)
2437     return 0;
2438
2439   chainon (arglist, build_tree_list (NULL_TREE, len));
2440   return expand_expr (build_function_call_expr (fn, arglist),
2441                       target, mode, EXPAND_NORMAL);
2442 }
2443
2444 /* Expand expression EXP, which is a call to the strncmp builtin.  Return 0
2445    if we failed the caller should emit a normal call, otherwise try to get
2446    the result in TARGET, if convenient.  */
2447
2448 static rtx
2449 expand_builtin_strncmp (exp, target, mode)
2450      tree exp;
2451      rtx target;
2452      enum machine_mode mode;
2453 {
2454   tree arglist = TREE_OPERAND (exp, 1);
2455   tree fn, newarglist, len = 0;
2456   tree arg1, arg2, arg3;
2457   const char *p1, *p2;
2458
2459   if (!validate_arglist (arglist,
2460                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2461     return 0;
2462
2463   arg1 = TREE_VALUE (arglist);
2464   arg2 = TREE_VALUE (TREE_CHAIN (arglist));
2465   arg3 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2466
2467   /* If the len parameter is zero, return zero.  */
2468   if (host_integerp (arg3, 1) && tree_low_cst (arg3, 1) == 0)
2469   {
2470     /* Evaluate and ignore arg1 and arg2 in case they have
2471        side-effects.  */
2472     expand_expr (arg1, const0_rtx, VOIDmode, EXPAND_NORMAL);
2473     expand_expr (arg2, const0_rtx, VOIDmode, EXPAND_NORMAL);
2474     return const0_rtx;
2475   }
2476
2477   p1 = c_getstr (arg1);
2478   p2 = c_getstr (arg2);
2479
2480   /* If all arguments are constant, evaluate at compile-time.  */
2481   if (host_integerp (arg3, 1) && p1 && p2)
2482   {
2483     const int r = strncmp (p1, p2, tree_low_cst (arg3, 1));
2484     return (r < 0 ? constm1_rtx : (r > 0 ? const1_rtx : const0_rtx));
2485   }
2486
2487   /* If len == 1 or (either string parameter is "" and (len >= 1)),
2488       return (*(const u_char*)arg1 - *(const u_char*)arg2).  */
2489   if (host_integerp (arg3, 1)
2490       && (tree_low_cst (arg3, 1) == 1
2491           || (tree_low_cst (arg3, 1) > 1
2492               && ((p1 && *p1 == '\0') || (p2 && *p2 == '\0')))))
2493     {
2494       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
2495       tree cst_uchar_ptr_node = build_pointer_type (cst_uchar_node);
2496       tree ind1 =
2497         fold (build1 (CONVERT_EXPR, integer_type_node,
2498                       build1 (INDIRECT_REF, cst_uchar_node,
2499                               build1 (NOP_EXPR, cst_uchar_ptr_node, arg1))));
2500       tree ind2 =
2501         fold (build1 (CONVERT_EXPR, integer_type_node,
2502                       build1 (INDIRECT_REF, cst_uchar_node,
2503                               build1 (NOP_EXPR, cst_uchar_ptr_node, arg2))));
2504       tree result = fold (build (MINUS_EXPR, integer_type_node, ind1, ind2));
2505       return expand_expr (result, target, mode, EXPAND_NORMAL);
2506     }
2507
2508   /* If c_strlen can determine an expression for one of the string
2509      lengths, and it doesn't have side effects, then call
2510      expand_builtin_memcmp() using length MIN(strlen(string)+1, arg3).  */
2511
2512   /* Perhaps one of the strings is really constant, if so prefer
2513      that constant length over the other string's length.  */
2514   if (p1)
2515     len = c_strlen (arg1);
2516   else if (p2)
2517     len = c_strlen (arg2);
2518
2519   /* If we still don't have a len, try either string arg as long
2520      as they don't have side effects.  */
2521   if (!len && !TREE_SIDE_EFFECTS (arg1))
2522     len = c_strlen (arg1);
2523   if (!len && !TREE_SIDE_EFFECTS (arg2))
2524     len = c_strlen (arg2);
2525   /* If we still don't have a length, punt.  */
2526   if (!len)
2527     return 0;
2528
2529   fn = built_in_decls[BUILT_IN_MEMCMP];
2530   if (!fn)
2531     return 0;
2532
2533   /* Add one to the string length.  */
2534   len = fold (size_binop (PLUS_EXPR, len, ssize_int (1)));
2535
2536   /* The actual new length parameter is MIN(len,arg3).  */
2537   len = fold (build (MIN_EXPR, TREE_TYPE (len), len, arg3));
2538
2539   newarglist = build_tree_list (NULL_TREE, len);
2540   newarglist = tree_cons (NULL_TREE, arg2, newarglist);
2541   newarglist = tree_cons (NULL_TREE, arg1, newarglist);
2542   return expand_expr (build_function_call_expr (fn, newarglist),
2543                       target, mode, EXPAND_NORMAL);
2544 }
2545
2546 /* Expand expression EXP, which is a call to the strcat builtin.
2547    Return 0 if we failed the caller should emit a normal call,
2548    otherwise try to get the result in TARGET, if convenient.  */
2549
2550 static rtx
2551 expand_builtin_strcat (arglist, target, mode)
2552      tree arglist;
2553      rtx target;
2554      enum machine_mode mode;
2555 {
2556   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2557     return 0;
2558   else
2559     {
2560       tree dst = TREE_VALUE (arglist),
2561         src = TREE_VALUE (TREE_CHAIN (arglist));
2562       const char *p = c_getstr (src);
2563
2564       /* If the string length is zero, return the dst parameter.  */
2565       if (p && *p == '\0')
2566         return expand_expr (dst, target, mode, EXPAND_NORMAL);
2567
2568       return 0;
2569     }
2570 }
2571
2572 /* Expand expression EXP, which is a call to the strncat builtin.
2573    Return 0 if we failed the caller should emit a normal call,
2574    otherwise try to get the result in TARGET, if convenient.  */
2575
2576 static rtx
2577 expand_builtin_strncat (arglist, target, mode)
2578      tree arglist;
2579      rtx target;
2580      enum machine_mode mode;
2581 {
2582   if (!validate_arglist (arglist,
2583                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2584     return 0;
2585   else
2586     {
2587       tree dst = TREE_VALUE (arglist),
2588         src = TREE_VALUE (TREE_CHAIN (arglist)),
2589         len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2590       const char *p = c_getstr (src);
2591
2592       /* If the requested length is zero, or the src parameter string
2593           length is zero, return the dst parameter.  */
2594       if ((TREE_CODE (len) == INTEGER_CST && compare_tree_int (len, 0) == 0)
2595           || (p && *p == '\0'))
2596         {
2597           /* Evaluate and ignore the src and len parameters in case
2598              they have side-effects.  */
2599           expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
2600           expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
2601           return expand_expr (dst, target, mode, EXPAND_NORMAL);
2602         }
2603
2604       /* If the requested len is greater than or equal to the string
2605          length, call strcat.  */
2606       if (TREE_CODE (len) == INTEGER_CST && p
2607           && compare_tree_int (len, strlen (p)) >= 0)
2608         {
2609           tree newarglist =
2610             tree_cons (NULL_TREE, dst, build_tree_list (NULL_TREE, src)),
2611             fn = built_in_decls[BUILT_IN_STRCAT];
2612
2613           /* If the replacement _DECL isn't initialized, don't do the
2614              transformation.  */
2615           if (!fn)
2616             return 0;
2617
2618           return expand_expr (build_function_call_expr (fn, newarglist),
2619                               target, mode, EXPAND_NORMAL);
2620         }
2621       return 0;
2622     }
2623 }
2624
2625 /* Expand expression EXP, which is a call to the strspn builtin.
2626    Return 0 if we failed the caller should emit a normal call,
2627    otherwise try to get the result in TARGET, if convenient.  */
2628
2629 static rtx
2630 expand_builtin_strspn (arglist, target, mode)
2631      tree arglist;
2632      rtx target;
2633      enum machine_mode mode;
2634 {
2635   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2636     return 0;
2637   else
2638     {
2639       tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
2640       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
2641
2642       /* If both arguments are constants, evaluate at compile-time.  */
2643       if (p1 && p2)
2644         {
2645           const size_t r = strspn (p1, p2);
2646           return expand_expr (size_int (r), target, mode, EXPAND_NORMAL);
2647         }
2648
2649       /* If either argument is "", return 0.  */
2650       if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
2651         {
2652           /* Evaluate and ignore both arguments in case either one has
2653              side-effects.  */
2654           expand_expr (s1, const0_rtx, VOIDmode, EXPAND_NORMAL);
2655           expand_expr (s2, const0_rtx, VOIDmode, EXPAND_NORMAL);
2656           return const0_rtx;
2657         }
2658       return 0;
2659     }
2660 }
2661
2662 /* Expand expression EXP, which is a call to the strcspn builtin.
2663    Return 0 if we failed the caller should emit a normal call,
2664    otherwise try to get the result in TARGET, if convenient.  */
2665
2666 static rtx
2667 expand_builtin_strcspn (arglist, target, mode)
2668      tree arglist;
2669      rtx target;
2670      enum machine_mode mode;
2671 {
2672   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2673     return 0;
2674   else
2675     {
2676       tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
2677       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
2678
2679       /* If both arguments are constants, evaluate at compile-time.  */
2680       if (p1 && p2)
2681         {
2682           const size_t r = strcspn (p1, p2);
2683           return expand_expr (size_int (r), target, mode, EXPAND_NORMAL);
2684         }
2685
2686       /* If the first argument is "", return 0.  */
2687       if (p1 && *p1 == '\0')
2688         {
2689           /* Evaluate and ignore argument s2 in case it has
2690              side-effects.  */
2691           expand_expr (s2, const0_rtx, VOIDmode, EXPAND_NORMAL);
2692           return const0_rtx;
2693         }
2694
2695       /* If the second argument is "", return __builtin_strlen(s1).  */
2696       if (p2 && *p2 == '\0')
2697         {
2698           tree newarglist = build_tree_list (NULL_TREE, s1),
2699             fn = built_in_decls[BUILT_IN_STRLEN];
2700
2701           /* If the replacement _DECL isn't initialized, don't do the
2702              transformation.  */
2703           if (!fn)
2704             return 0;
2705
2706           return expand_expr (build_function_call_expr (fn, newarglist),
2707                               target, mode, EXPAND_NORMAL);
2708         }
2709       return 0;
2710     }
2711 }
2712
2713 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
2714    if that's convenient.  */
2715
2716 rtx
2717 expand_builtin_saveregs ()
2718 {
2719   rtx val, seq;
2720
2721   /* Don't do __builtin_saveregs more than once in a function.
2722      Save the result of the first call and reuse it.  */
2723   if (saveregs_value != 0)
2724     return saveregs_value;
2725
2726   /* When this function is called, it means that registers must be
2727      saved on entry to this function.  So we migrate the call to the
2728      first insn of this function.  */
2729
2730   start_sequence ();
2731
2732 #ifdef EXPAND_BUILTIN_SAVEREGS
2733   /* Do whatever the machine needs done in this case.  */
2734   val = EXPAND_BUILTIN_SAVEREGS ();
2735 #else
2736   /* ??? We used to try and build up a call to the out of line function,
2737      guessing about what registers needed saving etc.  This became much
2738      harder with __builtin_va_start, since we don't have a tree for a
2739      call to __builtin_saveregs to fall back on.  There was exactly one
2740      port (i860) that used this code, and I'm unconvinced it could actually
2741      handle the general case.  So we no longer try to handle anything
2742      weird and make the backend absorb the evil.  */
2743
2744   error ("__builtin_saveregs not supported by this target");
2745   val = const0_rtx;
2746 #endif
2747
2748   seq = get_insns ();
2749   end_sequence ();
2750
2751   saveregs_value = val;
2752
2753   /* Put the sequence after the NOTE that starts the function.  If this
2754      is inside a SEQUENCE, make the outer-level insn chain current, so
2755      the code is placed at the start of the function.  */
2756   push_topmost_sequence ();
2757   emit_insns_after (seq, get_insns ());
2758   pop_topmost_sequence ();
2759
2760   return val;
2761 }
2762
2763 /* __builtin_args_info (N) returns word N of the arg space info
2764    for the current function.  The number and meanings of words
2765    is controlled by the definition of CUMULATIVE_ARGS.  */
2766
2767 static rtx
2768 expand_builtin_args_info (exp)
2769      tree exp;
2770 {
2771   tree arglist = TREE_OPERAND (exp, 1);
2772   int nwords = sizeof (CUMULATIVE_ARGS) / sizeof (int);
2773   int *word_ptr = (int *) &current_function_args_info;
2774 #if 0
2775   /* These are used by the code below that is if 0'ed away */
2776   int i;
2777   tree type, elts, result;
2778 #endif
2779
2780   if (sizeof (CUMULATIVE_ARGS) % sizeof (int) != 0)
2781     abort ();
2782
2783   if (arglist != 0)
2784     {
2785       if (!host_integerp (TREE_VALUE (arglist), 0))
2786         error ("argument of `__builtin_args_info' must be constant");
2787       else
2788         {
2789           HOST_WIDE_INT wordnum = tree_low_cst (TREE_VALUE (arglist), 0);
2790
2791           if (wordnum < 0 || wordnum >= nwords)
2792             error ("argument of `__builtin_args_info' out of range");
2793           else
2794             return GEN_INT (word_ptr[wordnum]);
2795         }
2796     }
2797   else
2798     error ("missing argument in `__builtin_args_info'");
2799
2800   return const0_rtx;
2801
2802 #if 0
2803   for (i = 0; i < nwords; i++)
2804     elts = tree_cons (NULL_TREE, build_int_2 (word_ptr[i], 0));
2805
2806   type = build_array_type (integer_type_node,
2807                            build_index_type (build_int_2 (nwords, 0)));
2808   result = build (CONSTRUCTOR, type, NULL_TREE, nreverse (elts));
2809   TREE_CONSTANT (result) = 1;
2810   TREE_STATIC (result) = 1;
2811   result = build1 (INDIRECT_REF, build_pointer_type (type), result);
2812   TREE_CONSTANT (result) = 1;
2813   return expand_expr (result, NULL_RTX, VOIDmode, 0);
2814 #endif
2815 }
2816
2817 /* Expand ARGLIST, from a call to __builtin_next_arg.  */
2818
2819 static rtx
2820 expand_builtin_next_arg (arglist)
2821      tree arglist;
2822 {
2823   tree fntype = TREE_TYPE (current_function_decl);
2824
2825   if ((TYPE_ARG_TYPES (fntype) == 0
2826        || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
2827            == void_type_node))
2828       && ! current_function_varargs)
2829     {
2830       error ("`va_start' used in function with fixed args");
2831       return const0_rtx;
2832     }
2833
2834   if (arglist)
2835     {
2836       tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
2837       tree arg = TREE_VALUE (arglist);
2838
2839       /* Strip off all nops for the sake of the comparison.  This
2840          is not quite the same as STRIP_NOPS.  It does more.
2841          We must also strip off INDIRECT_EXPR for C++ reference
2842          parameters.  */
2843       while (TREE_CODE (arg) == NOP_EXPR
2844              || TREE_CODE (arg) == CONVERT_EXPR
2845              || TREE_CODE (arg) == NON_LVALUE_EXPR
2846              || TREE_CODE (arg) == INDIRECT_REF)
2847         arg = TREE_OPERAND (arg, 0);
2848       if (arg != last_parm)
2849         warning ("second parameter of `va_start' not last named argument");
2850     }
2851   else if (! current_function_varargs)
2852     /* Evidently an out of date version of <stdarg.h>; can't validate
2853        va_start's second argument, but can still work as intended.  */
2854     warning ("`__builtin_next_arg' called without an argument");
2855
2856   return expand_binop (Pmode, add_optab,
2857                        current_function_internal_arg_pointer,
2858                        current_function_arg_offset_rtx,
2859                        NULL_RTX, 0, OPTAB_LIB_WIDEN);
2860 }
2861
2862 /* Make it easier for the backends by protecting the valist argument
2863    from multiple evaluations.  */
2864
2865 static tree
2866 stabilize_va_list (valist, needs_lvalue)
2867      tree valist;
2868      int needs_lvalue;
2869 {
2870   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
2871     {
2872       if (TREE_SIDE_EFFECTS (valist))
2873         valist = save_expr (valist);
2874
2875       /* For this case, the backends will be expecting a pointer to
2876          TREE_TYPE (va_list_type_node), but it's possible we've
2877          actually been given an array (an actual va_list_type_node).
2878          So fix it.  */
2879       if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
2880         {
2881           tree p1 = build_pointer_type (TREE_TYPE (va_list_type_node));
2882           tree p2 = build_pointer_type (va_list_type_node);
2883
2884           valist = build1 (ADDR_EXPR, p2, valist);
2885           valist = fold (build1 (NOP_EXPR, p1, valist));
2886         }
2887     }
2888   else
2889     {
2890       tree pt;
2891
2892       if (! needs_lvalue)
2893         {
2894           if (! TREE_SIDE_EFFECTS (valist))
2895             return valist;
2896
2897           pt = build_pointer_type (va_list_type_node);
2898           valist = fold (build1 (ADDR_EXPR, pt, valist));
2899           TREE_SIDE_EFFECTS (valist) = 1;
2900         }
2901
2902       if (TREE_SIDE_EFFECTS (valist))
2903         valist = save_expr (valist);
2904       valist = fold (build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (valist)),
2905                              valist));
2906     }
2907
2908   return valist;
2909 }
2910
2911 /* The "standard" implementation of va_start: just assign `nextarg' to
2912    the variable.  */
2913
2914 void
2915 std_expand_builtin_va_start (stdarg_p, valist, nextarg)
2916      int stdarg_p;
2917      tree valist;
2918      rtx nextarg;
2919 {
2920   tree t;
2921
2922   if (! stdarg_p)
2923     {
2924       /* The dummy named parameter is declared as a 'word' sized
2925          object, but if a 'word' is smaller than an 'int', it would
2926          have been promoted to int when it was added to the arglist.  */
2927       int align = PARM_BOUNDARY / BITS_PER_UNIT;
2928       int size = MAX (UNITS_PER_WORD,
2929                       GET_MODE_SIZE (TYPE_MODE (integer_type_node)));
2930       int offset = ((size + align - 1) / align) * align;
2931       nextarg = plus_constant (nextarg, -offset);
2932     }
2933
2934   t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
2935              make_tree (ptr_type_node, nextarg));
2936   TREE_SIDE_EFFECTS (t) = 1;
2937
2938   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
2939 }
2940
2941 /* Expand ARGLIST, which from a call to __builtin_stdarg_va_start or
2942    __builtin_varargs_va_start, depending on STDARG_P.  */
2943
2944 static rtx
2945 expand_builtin_va_start (stdarg_p, arglist)
2946      int stdarg_p;
2947      tree arglist;
2948 {
2949   rtx nextarg;
2950   tree chain = arglist, valist;
2951
2952   if (stdarg_p)
2953     nextarg = expand_builtin_next_arg (chain = TREE_CHAIN (arglist));
2954   else
2955     nextarg = expand_builtin_next_arg (NULL_TREE);
2956
2957   if (TREE_CHAIN (chain))
2958     error ("too many arguments to function `va_start'");
2959
2960   valist = stabilize_va_list (TREE_VALUE (arglist), 1);
2961
2962 #ifdef EXPAND_BUILTIN_VA_START
2963   EXPAND_BUILTIN_VA_START (stdarg_p, valist, nextarg);
2964 #else
2965   std_expand_builtin_va_start (stdarg_p, valist, nextarg);
2966 #endif
2967
2968   return const0_rtx;
2969 }
2970
2971 /* The "standard" implementation of va_arg: read the value from the
2972    current (padded) address and increment by the (padded) size.  */
2973
2974 rtx
2975 std_expand_builtin_va_arg (valist, type)
2976      tree valist, type;
2977 {
2978   tree addr_tree, t;
2979   HOST_WIDE_INT align;
2980   HOST_WIDE_INT rounded_size;
2981   rtx addr;
2982
2983   /* Compute the rounded size of the type.  */
2984   align = PARM_BOUNDARY / BITS_PER_UNIT;
2985   rounded_size = (((int_size_in_bytes (type) + align - 1) / align) * align);
2986
2987   /* Get AP.  */
2988   addr_tree = valist;
2989   if (PAD_VARARGS_DOWN)
2990     {
2991       /* Small args are padded downward.  */
2992
2993       HOST_WIDE_INT adj
2994         = rounded_size > align ? rounded_size : int_size_in_bytes (type);
2995
2996       addr_tree = build (PLUS_EXPR, TREE_TYPE (addr_tree), addr_tree,
2997                          build_int_2 (rounded_size - adj, 0));
2998     }
2999
3000   addr = expand_expr (addr_tree, NULL_RTX, Pmode, EXPAND_NORMAL);
3001   addr = copy_to_reg (addr);
3002
3003   /* Compute new value for AP.  */
3004   t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
3005              build (PLUS_EXPR, TREE_TYPE (valist), valist,
3006                     build_int_2 (rounded_size, 0)));
3007   TREE_SIDE_EFFECTS (t) = 1;
3008   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
3009
3010   return addr;
3011 }
3012
3013 /* Expand __builtin_va_arg, which is not really a builtin function, but
3014    a very special sort of operator.  */
3015
3016 rtx
3017 expand_builtin_va_arg (valist, type)
3018      tree valist, type;
3019 {
3020   rtx addr, result;
3021   tree promoted_type, want_va_type, have_va_type;
3022
3023   /* Verify that valist is of the proper type.  */
3024
3025   want_va_type = va_list_type_node;
3026   have_va_type = TREE_TYPE (valist);
3027   if (TREE_CODE (want_va_type) == ARRAY_TYPE)
3028     {
3029       /* If va_list is an array type, the argument may have decayed
3030          to a pointer type, e.g. by being passed to another function.
3031          In that case, unwrap both types so that we can compare the
3032          underlying records.  */
3033       if (TREE_CODE (have_va_type) == ARRAY_TYPE
3034           || TREE_CODE (have_va_type) == POINTER_TYPE)
3035         {
3036           want_va_type = TREE_TYPE (want_va_type);
3037           have_va_type = TREE_TYPE (have_va_type);
3038         }
3039     }
3040   if (TYPE_MAIN_VARIANT (want_va_type) != TYPE_MAIN_VARIANT (have_va_type))
3041     {
3042       error ("first argument to `va_arg' not of type `va_list'");
3043       addr = const0_rtx;
3044     }
3045
3046   /* Generate a diagnostic for requesting data of a type that cannot
3047      be passed through `...' due to type promotion at the call site.  */
3048   else if ((promoted_type = (*lang_type_promotes_to) (type)) != NULL_TREE)
3049     {
3050       const char *name = "<anonymous type>", *pname = 0;
3051       static int gave_help;
3052
3053       if (TYPE_NAME (type))
3054         {
3055           if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
3056             name = IDENTIFIER_POINTER (TYPE_NAME (type));
3057           else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
3058                    && DECL_NAME (TYPE_NAME (type)))
3059             name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
3060         }
3061       if (TYPE_NAME (promoted_type))
3062         {
3063           if (TREE_CODE (TYPE_NAME (promoted_type)) == IDENTIFIER_NODE)
3064             pname = IDENTIFIER_POINTER (TYPE_NAME (promoted_type));
3065           else if (TREE_CODE (TYPE_NAME (promoted_type)) == TYPE_DECL
3066                    && DECL_NAME (TYPE_NAME (promoted_type)))
3067             pname = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (promoted_type)));
3068         }
3069
3070       error ("`%s' is promoted to `%s' when passed through `...'", name, pname);
3071       if (! gave_help)
3072         {
3073           gave_help = 1;
3074           error ("(so you should pass `%s' not `%s' to `va_arg')", pname, name);
3075         }
3076
3077       addr = const0_rtx;
3078     }
3079   else
3080     {
3081       /* Make it easier for the backends by protecting the valist argument
3082          from multiple evaluations.  */
3083       valist = stabilize_va_list (valist, 0);
3084
3085 #ifdef EXPAND_BUILTIN_VA_ARG
3086       addr = EXPAND_BUILTIN_VA_ARG (valist, type);
3087 #else
3088       addr = std_expand_builtin_va_arg (valist, type);
3089 #endif
3090     }
3091
3092 #ifdef POINTERS_EXTEND_UNSIGNED
3093   if (GET_MODE (addr) != Pmode)
3094     addr = convert_memory_address (Pmode, addr);
3095 #endif
3096
3097   result = gen_rtx_MEM (TYPE_MODE (type), addr);
3098   set_mem_alias_set (result, get_varargs_alias_set ());
3099
3100   return result;
3101 }
3102
3103 /* Expand ARGLIST, from a call to __builtin_va_end.  */
3104
3105 static rtx
3106 expand_builtin_va_end (arglist)
3107      tree arglist;
3108 {
3109   tree valist = TREE_VALUE (arglist);
3110
3111 #ifdef EXPAND_BUILTIN_VA_END
3112   valist = stabilize_va_list (valist, 0);
3113   EXPAND_BUILTIN_VA_END(arglist);
3114 #else
3115   /* Evaluate for side effects, if needed.  I hate macros that don't
3116      do that.  */
3117   if (TREE_SIDE_EFFECTS (valist))
3118     expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
3119 #endif
3120
3121   return const0_rtx;
3122 }
3123
3124 /* Expand ARGLIST, from a call to __builtin_va_copy.  We do this as a
3125    builtin rather than just as an assignment in stdarg.h because of the
3126    nastiness of array-type va_list types.  */
3127
3128 static rtx
3129 expand_builtin_va_copy (arglist)
3130      tree arglist;
3131 {
3132   tree dst, src, t;
3133
3134   dst = TREE_VALUE (arglist);
3135   src = TREE_VALUE (TREE_CHAIN (arglist));
3136
3137   dst = stabilize_va_list (dst, 1);
3138   src = stabilize_va_list (src, 0);
3139
3140   if (TREE_CODE (va_list_type_node) != ARRAY_TYPE)
3141     {
3142       t = build (MODIFY_EXPR, va_list_type_node, dst, src);
3143       TREE_SIDE_EFFECTS (t) = 1;
3144       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
3145     }
3146   else
3147     {
3148       rtx dstb, srcb, size;
3149
3150       /* Evaluate to pointers.  */
3151       dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
3152       srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
3153       size = expand_expr (TYPE_SIZE_UNIT (va_list_type_node), NULL_RTX,
3154                           VOIDmode, EXPAND_NORMAL);
3155
3156 #ifdef POINTERS_EXTEND_UNSIGNED
3157       if (GET_MODE (dstb) != Pmode)
3158         dstb = convert_memory_address (Pmode, dstb);
3159
3160       if (GET_MODE (srcb) != Pmode)
3161         srcb = convert_memory_address (Pmode, srcb);
3162 #endif
3163
3164       /* "Dereference" to BLKmode memories.  */
3165       dstb = gen_rtx_MEM (BLKmode, dstb);
3166       set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
3167       set_mem_align (dstb, TYPE_ALIGN (va_list_type_node));
3168       srcb = gen_rtx_MEM (BLKmode, srcb);
3169       set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
3170       set_mem_align (srcb, TYPE_ALIGN (va_list_type_node));
3171
3172       /* Copy.  */
3173       emit_block_move (dstb, srcb, size);
3174     }
3175
3176   return const0_rtx;
3177 }
3178
3179 /* Expand a call to one of the builtin functions __builtin_frame_address or
3180    __builtin_return_address.  */
3181
3182 static rtx
3183 expand_builtin_frame_address (exp)
3184      tree exp;
3185 {
3186   tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
3187   tree arglist = TREE_OPERAND (exp, 1);
3188
3189   /* The argument must be a nonnegative integer constant.
3190      It counts the number of frames to scan up the stack.
3191      The value is the return address saved in that frame.  */
3192   if (arglist == 0)
3193     /* Warning about missing arg was already issued.  */
3194     return const0_rtx;
3195   else if (! host_integerp (TREE_VALUE (arglist), 1))
3196     {
3197       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
3198         error ("invalid arg to `__builtin_frame_address'");
3199       else
3200         error ("invalid arg to `__builtin_return_address'");
3201       return const0_rtx;
3202     }
3203   else
3204     {
3205       rtx tem
3206         = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
3207                                       tree_low_cst (TREE_VALUE (arglist), 1),
3208                                       hard_frame_pointer_rtx);
3209
3210       /* Some ports cannot access arbitrary stack frames.  */
3211       if (tem == NULL)
3212         {
3213           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
3214             warning ("unsupported arg to `__builtin_frame_address'");
3215           else
3216             warning ("unsupported arg to `__builtin_return_address'");
3217           return const0_rtx;
3218         }
3219
3220       /* For __builtin_frame_address, return what we've got.  */
3221       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
3222         return tem;
3223
3224       if (GET_CODE (tem) != REG
3225           && ! CONSTANT_P (tem))
3226         tem = copy_to_mode_reg (Pmode, tem);
3227       return tem;
3228     }
3229 }
3230
3231 /* Expand a call to the alloca builtin, with arguments ARGLIST.  Return 0 if
3232    we failed and the caller should emit a normal call, otherwise try to get
3233    the result in TARGET, if convenient.  */
3234
3235 static rtx
3236 expand_builtin_alloca (arglist, target)
3237      tree arglist;
3238      rtx target;
3239 {
3240   rtx op0;
3241   rtx result;
3242
3243   if (!validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
3244     return 0;
3245
3246   /* Compute the argument.  */
3247   op0 = expand_expr (TREE_VALUE (arglist), NULL_RTX, VOIDmode, 0);
3248
3249   /* Allocate the desired space.  */
3250   result = allocate_dynamic_stack_space (op0, target, BITS_PER_UNIT);
3251
3252 #ifdef POINTERS_EXTEND_UNSIGNED
3253   if (GET_MODE (result) != ptr_mode)
3254     result = convert_memory_address (ptr_mode, result);
3255 #endif
3256
3257   return result;
3258 }
3259
3260 /* Expand a call to the ffs builtin.  The arguments are in ARGLIST.
3261    Return 0 if a normal call should be emitted rather than expanding the
3262    function in-line.  If convenient, the result should be placed in TARGET.
3263    SUBTARGET may be used as the target for computing one of EXP's operands.  */
3264
3265 static rtx
3266 expand_builtin_ffs (arglist, target, subtarget)
3267      tree arglist;
3268      rtx target, subtarget;
3269 {
3270   rtx op0;
3271   if (!validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
3272     return 0;
3273
3274   /* Compute the argument.  */
3275   op0 = expand_expr (TREE_VALUE (arglist), subtarget, VOIDmode, 0);
3276   /* Compute ffs, into TARGET if possible.
3277      Set TARGET to wherever the result comes back.  */
3278   target = expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist))),
3279                         ffs_optab, op0, target, 1);
3280   if (target == 0)
3281     abort ();
3282   return target;
3283 }
3284
3285 /* If the string passed to fputs is a constant and is one character
3286    long, we attempt to transform this call into __builtin_fputc().  */
3287
3288 static rtx
3289 expand_builtin_fputs (arglist, ignore)
3290      tree arglist;
3291      int ignore;
3292 {
3293   tree len, fn, fn_fputc = built_in_decls[BUILT_IN_FPUTC],
3294     fn_fwrite = built_in_decls[BUILT_IN_FWRITE];
3295
3296   /* If the return value is used, or the replacement _DECL isn't
3297      initialized, don't do the transformation.  */
3298   if (!ignore || !fn_fputc || !fn_fwrite)
3299     return 0;
3300
3301   /* Verify the arguments in the original call.  */
3302   if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3303     return 0;
3304
3305   /* Get the length of the string passed to fputs.  If the length
3306      can't be determined, punt.  */
3307   if (!(len = c_strlen (TREE_VALUE (arglist)))
3308       || TREE_CODE (len) != INTEGER_CST)
3309     return 0;
3310
3311   switch (compare_tree_int (len, 1))
3312     {
3313     case -1: /* length is 0, delete the call entirely .  */
3314       {
3315         /* Evaluate and ignore the argument in case it has
3316            side-effects.  */
3317         expand_expr (TREE_VALUE (TREE_CHAIN (arglist)), const0_rtx,
3318                      VOIDmode, EXPAND_NORMAL);
3319         return const0_rtx;
3320       }
3321     case 0: /* length is 1, call fputc.  */
3322       {
3323         const char *p = c_getstr (TREE_VALUE (arglist));
3324
3325         if (p != NULL)
3326           {
3327             /* New argument list transforming fputs(string, stream) to
3328                fputc(string[0], stream).  */
3329             arglist =
3330               build_tree_list (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)));
3331             arglist =
3332               tree_cons (NULL_TREE, build_int_2 (p[0], 0), arglist);
3333             fn = fn_fputc;
3334             break;
3335           }
3336       }
3337       /* FALLTHROUGH */
3338     case 1: /* length is greater than 1, call fwrite.  */
3339       {
3340         tree string_arg = TREE_VALUE (arglist);
3341
3342         /* New argument list transforming fputs(string, stream) to
3343            fwrite(string, 1, len, stream).  */
3344         arglist = build_tree_list (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)));
3345         arglist = tree_cons (NULL_TREE, len, arglist);
3346         arglist = tree_cons (NULL_TREE, size_one_node, arglist);
3347         arglist = tree_cons (NULL_TREE, string_arg, arglist);
3348         fn = fn_fwrite;
3349         break;
3350       }
3351     default:
3352       abort();
3353     }
3354
3355   return expand_expr (build_function_call_expr (fn, arglist),
3356                       (ignore ? const0_rtx : NULL_RTX),
3357                       VOIDmode, EXPAND_NORMAL);
3358 }
3359
3360 /* Expand a call to __builtin_expect.  We return our argument and emit a
3361    NOTE_INSN_EXPECTED_VALUE note.  This is the expansion of __builtin_expect in
3362    a non-jump context.  */
3363
3364 static rtx
3365 expand_builtin_expect (arglist, target)
3366      tree arglist;
3367      rtx target;
3368 {
3369   tree exp, c;
3370   rtx note, rtx_c;
3371
3372   if (arglist == NULL_TREE
3373       || TREE_CHAIN (arglist) == NULL_TREE)
3374     return const0_rtx;
3375   exp = TREE_VALUE (arglist);
3376   c = TREE_VALUE (TREE_CHAIN (arglist));
3377
3378   if (TREE_CODE (c) != INTEGER_CST)
3379     {
3380       error ("second arg to `__builtin_expect' must be a constant");
3381       c = integer_zero_node;
3382     }
3383
3384   target = expand_expr (exp, target, VOIDmode, EXPAND_NORMAL);
3385
3386   /* Don't bother with expected value notes for integral constants.  */
3387   if (GET_CODE (target) != CONST_INT)
3388     {
3389       /* We do need to force this into a register so that we can be
3390          moderately sure to be able to correctly interpret the branch
3391          condition later.  */
3392       target = force_reg (GET_MODE (target), target);
3393
3394       rtx_c = expand_expr (c, NULL_RTX, GET_MODE (target), EXPAND_NORMAL);
3395
3396       note = emit_note (NULL, NOTE_INSN_EXPECTED_VALUE);
3397       NOTE_EXPECTED_VALUE (note) = gen_rtx_EQ (VOIDmode, target, rtx_c);
3398     }
3399
3400   return target;
3401 }
3402
3403 /* Like expand_builtin_expect, except do this in a jump context.  This is
3404    called from do_jump if the conditional is a __builtin_expect.  Return either
3405    a SEQUENCE of insns to emit the jump or NULL if we cannot optimize
3406    __builtin_expect.  We need to optimize this at jump time so that machines
3407    like the PowerPC don't turn the test into a SCC operation, and then jump
3408    based on the test being 0/1.  */
3409
3410 rtx
3411 expand_builtin_expect_jump (exp, if_false_label, if_true_label)
3412      tree exp;
3413      rtx if_false_label;
3414      rtx if_true_label;
3415 {
3416   tree arglist = TREE_OPERAND (exp, 1);
3417   tree arg0 = TREE_VALUE (arglist);
3418   tree arg1 = TREE_VALUE (TREE_CHAIN (arglist));
3419   rtx ret = NULL_RTX;
3420
3421   /* Only handle __builtin_expect (test, 0) and
3422      __builtin_expect (test, 1).  */
3423   if (TREE_CODE (TREE_TYPE (arg1)) == INTEGER_TYPE
3424       && (integer_zerop (arg1) || integer_onep (arg1)))
3425     {
3426       int j;
3427       int num_jumps = 0;
3428
3429       /* If we fail to locate an appropriate conditional jump, we'll
3430          fall back to normal evaluation.  Ensure that the expression
3431          can be re-evaluated.  */
3432       switch (unsafe_for_reeval (arg0))
3433         {
3434         case 0: /* Safe.  */
3435           break;
3436
3437         case 1: /* Mildly unsafe.  */
3438           arg0 = unsave_expr (arg0);
3439           break;
3440
3441         case 2: /* Wildly unsafe.  */
3442           return NULL_RTX;
3443         }
3444
3445       /* Expand the jump insns.  */
3446       start_sequence ();
3447       do_jump (arg0, if_false_label, if_true_label);
3448       ret = gen_sequence ();
3449       end_sequence ();
3450
3451       /* Now that the __builtin_expect has been validated, go through and add
3452          the expect's to each of the conditional jumps.  If we run into an
3453          error, just give up and generate the 'safe' code of doing a SCC
3454          operation and then doing a branch on that.  */
3455       for (j = 0; j < XVECLEN (ret, 0); j++)
3456         {
3457           rtx insn = XVECEXP (ret, 0, j);
3458           rtx pattern;
3459
3460           if (GET_CODE (insn) == JUMP_INSN && any_condjump_p (insn)
3461               && (pattern = pc_set (insn)) != NULL_RTX)
3462             {
3463               rtx ifelse = SET_SRC (pattern);
3464               rtx label;
3465               int taken;
3466
3467               if (GET_CODE (ifelse) != IF_THEN_ELSE)
3468                 continue;
3469
3470               if (GET_CODE (XEXP (ifelse, 1)) == LABEL_REF)
3471                 {
3472                   taken = 1;
3473                   label = XEXP (XEXP (ifelse, 1), 0);
3474                 }
3475               /* An inverted jump reverses the probabilities.  */
3476               else if (GET_CODE (XEXP (ifelse, 2)) == LABEL_REF)
3477                 {
3478                   taken = 0;
3479                   label = XEXP (XEXP (ifelse, 2), 0);
3480                 }
3481               /* We shouldn't have to worry about conditional returns during
3482                  the expansion stage, but handle it gracefully anyway.  */
3483               else if (GET_CODE (XEXP (ifelse, 1)) == RETURN)
3484                 {
3485                   taken = 1;
3486                   label = NULL_RTX;
3487                 }
3488               /* An inverted return reverses the probabilities.  */
3489               else if (GET_CODE (XEXP (ifelse, 2)) == RETURN)
3490                 {
3491                   taken = 0;
3492                   label = NULL_RTX;
3493                 }
3494               else
3495                 continue;
3496
3497               /* If the test is expected to fail, reverse the
3498                  probabilities.  */
3499               if (integer_zerop (arg1))
3500                 taken = 1 - taken;
3501
3502               /* If we are jumping to the false label, reverse the
3503                  probabilities.  */
3504               if (label == NULL_RTX)
3505                 ;               /* conditional return */
3506               else if (label == if_false_label)
3507                 taken = 1 - taken;
3508               else if (label != if_true_label)
3509                 continue;
3510
3511               num_jumps++;
3512               predict_insn_def (insn, PRED_BUILTIN_EXPECT, taken);
3513             }
3514         }
3515
3516       /* If no jumps were modified, fail and do __builtin_expect the normal
3517          way.  */
3518       if (num_jumps == 0)
3519         ret = NULL_RTX;
3520     }
3521
3522   return ret;
3523 }
3524 \f
3525 /* Expand an expression EXP that calls a built-in function,
3526    with result going to TARGET if that's convenient
3527    (and in mode MODE if that's convenient).
3528    SUBTARGET may be used as the target for computing one of EXP's operands.
3529    IGNORE is nonzero if the value is to be ignored.  */
3530
3531 rtx
3532 expand_builtin (exp, target, subtarget, mode, ignore)
3533      tree exp;
3534      rtx target;
3535      rtx subtarget;
3536      enum machine_mode mode;
3537      int ignore;
3538 {
3539   tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
3540   tree arglist = TREE_OPERAND (exp, 1);
3541   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
3542
3543   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
3544     return (*targetm.expand_builtin) (exp, target, subtarget, mode, ignore);
3545
3546   /* When not optimizing, generate calls to library functions for a certain
3547      set of builtins.  */
3548   if (!optimize && !CALLED_AS_BUILT_IN (fndecl))
3549     switch (fcode)
3550       {
3551       case BUILT_IN_SIN:
3552       case BUILT_IN_COS:
3553       case BUILT_IN_SQRT:
3554       case BUILT_IN_SQRTF:
3555       case BUILT_IN_SQRTL:
3556       case BUILT_IN_MEMSET:
3557       case BUILT_IN_MEMCPY:
3558       case BUILT_IN_MEMCMP:
3559       case BUILT_IN_BCMP:
3560       case BUILT_IN_BZERO:
3561       case BUILT_IN_INDEX:
3562       case BUILT_IN_RINDEX:
3563       case BUILT_IN_STRCHR:
3564       case BUILT_IN_STRRCHR:
3565       case BUILT_IN_STRLEN:
3566       case BUILT_IN_STRCPY:
3567       case BUILT_IN_STRNCPY:
3568       case BUILT_IN_STRNCMP:
3569       case BUILT_IN_STRSTR:
3570       case BUILT_IN_STRPBRK:
3571       case BUILT_IN_STRCAT:
3572       case BUILT_IN_STRNCAT:
3573       case BUILT_IN_STRSPN:
3574       case BUILT_IN_STRCSPN:
3575       case BUILT_IN_STRCMP:
3576       case BUILT_IN_FFS:
3577       case BUILT_IN_PUTCHAR:
3578       case BUILT_IN_PUTS:
3579       case BUILT_IN_PRINTF:
3580       case BUILT_IN_FPUTC:
3581       case BUILT_IN_FPUTS:
3582       case BUILT_IN_FWRITE:
3583         return expand_call (exp, target, ignore);
3584
3585       default:
3586         break;
3587     }
3588
3589   switch (fcode)
3590     {
3591     case BUILT_IN_ABS:
3592     case BUILT_IN_LABS:
3593     case BUILT_IN_LLABS:
3594     case BUILT_IN_IMAXABS:
3595     case BUILT_IN_FABS:
3596     case BUILT_IN_FABSF:
3597     case BUILT_IN_FABSL:
3598       /* build_function_call changes these into ABS_EXPR.  */
3599       abort ();
3600
3601     case BUILT_IN_CONJ:
3602     case BUILT_IN_CONJF:
3603     case BUILT_IN_CONJL:
3604     case BUILT_IN_CREAL:
3605     case BUILT_IN_CREALF:
3606     case BUILT_IN_CREALL:
3607     case BUILT_IN_CIMAG:
3608     case BUILT_IN_CIMAGF:
3609     case BUILT_IN_CIMAGL:
3610       /* expand_tree_builtin changes these into CONJ_EXPR, REALPART_EXPR
3611          and IMAGPART_EXPR.  */
3612       abort ();
3613
3614     case BUILT_IN_SIN:
3615     case BUILT_IN_SINF:
3616     case BUILT_IN_SINL:
3617     case BUILT_IN_COS:
3618     case BUILT_IN_COSF:
3619     case BUILT_IN_COSL:
3620       /* Treat these like sqrt only if unsafe math optimizations are allowed,
3621          because of possible accuracy problems.  */
3622       if (! flag_unsafe_math_optimizations)
3623         break;
3624     case BUILT_IN_SQRT:
3625     case BUILT_IN_SQRTF:
3626     case BUILT_IN_SQRTL:
3627       target = expand_builtin_mathfn (exp, target, subtarget);
3628       if (target)
3629         return target;
3630       break;
3631
3632     case BUILT_IN_FMOD:
3633       break;
3634
3635     case BUILT_IN_APPLY_ARGS:
3636       return expand_builtin_apply_args ();
3637
3638       /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
3639          FUNCTION with a copy of the parameters described by
3640          ARGUMENTS, and ARGSIZE.  It returns a block of memory
3641          allocated on the stack into which is stored all the registers
3642          that might possibly be used for returning the result of a
3643          function.  ARGUMENTS is the value returned by
3644          __builtin_apply_args.  ARGSIZE is the number of bytes of
3645          arguments that must be copied.  ??? How should this value be
3646          computed?  We'll also need a safe worst case value for varargs
3647          functions.  */
3648     case BUILT_IN_APPLY:
3649       if (!validate_arglist (arglist, POINTER_TYPE,
3650                              POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
3651           && !validate_arglist (arglist, REFERENCE_TYPE,
3652                                 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3653         return const0_rtx;
3654       else
3655         {
3656           int i;
3657           tree t;
3658           rtx ops[3];
3659
3660           for (t = arglist, i = 0; t; t = TREE_CHAIN (t), i++)
3661             ops[i] = expand_expr (TREE_VALUE (t), NULL_RTX, VOIDmode, 0);
3662
3663           return expand_builtin_apply (ops[0], ops[1], ops[2]);
3664         }
3665
3666       /* __builtin_return (RESULT) causes the function to return the
3667          value described by RESULT.  RESULT is address of the block of
3668          memory returned by __builtin_apply.  */
3669     case BUILT_IN_RETURN:
3670       if (validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
3671         expand_builtin_return (expand_expr (TREE_VALUE (arglist),
3672                                             NULL_RTX, VOIDmode, 0));
3673       return const0_rtx;
3674
3675     case BUILT_IN_SAVEREGS:
3676       return expand_builtin_saveregs ();
3677
3678     case BUILT_IN_ARGS_INFO:
3679       return expand_builtin_args_info (exp);
3680
3681       /* Return the address of the first anonymous stack arg.  */
3682     case BUILT_IN_NEXT_ARG:
3683       return expand_builtin_next_arg (arglist);
3684
3685     case BUILT_IN_CLASSIFY_TYPE:
3686       return expand_builtin_classify_type (arglist);
3687
3688     case BUILT_IN_CONSTANT_P:
3689       return expand_builtin_constant_p (exp);
3690
3691     case BUILT_IN_FRAME_ADDRESS:
3692     case BUILT_IN_RETURN_ADDRESS:
3693       return expand_builtin_frame_address (exp);
3694
3695     /* Returns the address of the area where the structure is returned.
3696        0 otherwise.  */
3697     case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
3698       if (arglist != 0
3699           || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
3700           || GET_CODE (DECL_RTL (DECL_RESULT (current_function_decl))) != MEM)
3701         return const0_rtx;
3702       else
3703         return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
3704
3705     case BUILT_IN_ALLOCA:
3706       target = expand_builtin_alloca (arglist, target);
3707       if (target)
3708         return target;
3709       break;
3710
3711     case BUILT_IN_FFS:
3712       target = expand_builtin_ffs (arglist, target, subtarget);
3713       if (target)
3714         return target;
3715       break;
3716
3717     case BUILT_IN_STRLEN:
3718       target = expand_builtin_strlen (exp, target);
3719       if (target)
3720         return target;
3721       break;
3722
3723     case BUILT_IN_STRCPY:
3724       target = expand_builtin_strcpy (exp, target, mode);
3725       if (target)
3726         return target;
3727       break;
3728
3729     case BUILT_IN_STRNCPY:
3730       target = expand_builtin_strncpy (arglist, target, mode);
3731       if (target)
3732         return target;
3733       break;
3734
3735     case BUILT_IN_STRCAT:
3736       target = expand_builtin_strcat (arglist, target, mode);
3737       if (target)
3738         return target;
3739       break;
3740
3741     case BUILT_IN_STRNCAT:
3742       target = expand_builtin_strncat (arglist, target, mode);
3743       if (target)
3744         return target;
3745       break;
3746
3747     case BUILT_IN_STRSPN:
3748       target = expand_builtin_strspn (arglist, target, mode);
3749       if (target)
3750         return target;
3751       break;
3752
3753     case BUILT_IN_STRCSPN:
3754       target = expand_builtin_strcspn (arglist, target, mode);
3755       if (target)
3756         return target;
3757       break;
3758
3759     case BUILT_IN_STRSTR:
3760       target = expand_builtin_strstr (arglist, target, mode);
3761       if (target)
3762         return target;
3763       break;
3764
3765     case BUILT_IN_STRPBRK:
3766       target = expand_builtin_strpbrk (arglist, target, mode);
3767       if (target)
3768         return target;
3769       break;
3770
3771     case BUILT_IN_INDEX:
3772     case BUILT_IN_STRCHR:
3773       target = expand_builtin_strchr (arglist, target, mode);
3774       if (target)
3775         return target;
3776       break;
3777
3778     case BUILT_IN_RINDEX:
3779     case BUILT_IN_STRRCHR:
3780       target = expand_builtin_strrchr (arglist, target, mode);
3781       if (target)
3782         return target;
3783       break;
3784
3785     case BUILT_IN_MEMCPY:
3786       target = expand_builtin_memcpy (arglist, target, mode);
3787       if (target)
3788         return target;
3789       break;
3790
3791     case BUILT_IN_MEMSET:
3792       target = expand_builtin_memset (exp, target, mode);
3793       if (target)
3794         return target;
3795       break;
3796
3797     case BUILT_IN_BZERO:
3798       target = expand_builtin_bzero (exp);
3799       if (target)
3800         return target;
3801       break;
3802
3803     case BUILT_IN_STRCMP:
3804       target = expand_builtin_strcmp (exp, target, mode);
3805       if (target)
3806         return target;
3807       break;
3808
3809     case BUILT_IN_STRNCMP:
3810       target = expand_builtin_strncmp (exp, target, mode);
3811       if (target)
3812         return target;
3813       break;
3814
3815     case BUILT_IN_BCMP:
3816     case BUILT_IN_MEMCMP:
3817       target = expand_builtin_memcmp (exp, arglist, target, mode);
3818       if (target)
3819         return target;
3820       break;
3821
3822     case BUILT_IN_SETJMP:
3823       target = expand_builtin_setjmp (arglist, target);
3824       if (target)
3825         return target;
3826       break;
3827
3828       /* __builtin_longjmp is passed a pointer to an array of five words.
3829          It's similar to the C library longjmp function but works with
3830          __builtin_setjmp above.  */
3831     case BUILT_IN_LONGJMP:
3832       if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3833         break;
3834       else
3835         {
3836           rtx buf_addr = expand_expr (TREE_VALUE (arglist), subtarget,
3837                                       VOIDmode, 0);
3838           rtx value = expand_expr (TREE_VALUE (TREE_CHAIN (arglist)),
3839                                    NULL_RTX, VOIDmode, 0);
3840
3841           if (value != const1_rtx)
3842             {
3843               error ("__builtin_longjmp second argument must be 1");
3844               return const0_rtx;
3845             }
3846
3847           expand_builtin_longjmp (buf_addr, value);
3848           return const0_rtx;
3849         }
3850
3851     case BUILT_IN_TRAP:
3852 #ifdef HAVE_trap
3853       if (HAVE_trap)
3854         emit_insn (gen_trap ());
3855       else
3856 #endif
3857         error ("__builtin_trap not supported by this target");
3858       emit_barrier ();
3859       return const0_rtx;
3860
3861     case BUILT_IN_PUTCHAR:
3862     case BUILT_IN_PUTS:
3863     case BUILT_IN_FPUTC:
3864     case BUILT_IN_FWRITE:
3865       break;
3866     case BUILT_IN_FPUTS:
3867       target = expand_builtin_fputs (arglist, ignore);
3868       if (target)
3869         return target;
3870       break;
3871
3872       /* Various hooks for the DWARF 2 __throw routine.  */
3873     case BUILT_IN_UNWIND_INIT:
3874       expand_builtin_unwind_init ();
3875       return const0_rtx;
3876     case BUILT_IN_DWARF_CFA:
3877       return virtual_cfa_rtx;
3878 #ifdef DWARF2_UNWIND_INFO
3879     case BUILT_IN_DWARF_FP_REGNUM:
3880       return expand_builtin_dwarf_fp_regnum ();
3881     case BUILT_IN_INIT_DWARF_REG_SIZES:
3882       expand_builtin_init_dwarf_reg_sizes (TREE_VALUE (arglist));
3883       return const0_rtx;
3884 #endif
3885     case BUILT_IN_FROB_RETURN_ADDR:
3886       return expand_builtin_frob_return_addr (TREE_VALUE (arglist));
3887     case BUILT_IN_EXTRACT_RETURN_ADDR:
3888       return expand_builtin_extract_return_addr (TREE_VALUE (arglist));
3889     case BUILT_IN_EH_RETURN:
3890       expand_builtin_eh_return (TREE_VALUE (arglist),
3891                                 TREE_VALUE (TREE_CHAIN (arglist)));
3892       return const0_rtx;
3893 #ifdef EH_RETURN_DATA_REGNO
3894     case BUILT_IN_EH_RETURN_DATA_REGNO:
3895       return expand_builtin_eh_return_data_regno (arglist);
3896 #endif
3897     case BUILT_IN_VARARGS_START:
3898       return expand_builtin_va_start (0, arglist);
3899     case BUILT_IN_STDARG_START:
3900       return expand_builtin_va_start (1, arglist);
3901     case BUILT_IN_VA_END:
3902       return expand_builtin_va_end (arglist);
3903     case BUILT_IN_VA_COPY:
3904       return expand_builtin_va_copy (arglist);
3905     case BUILT_IN_EXPECT:
3906       return expand_builtin_expect (arglist, target);
3907     case BUILT_IN_PREFETCH:
3908       expand_builtin_prefetch (arglist);
3909       return const0_rtx;
3910
3911
3912     default:                    /* just do library call, if unknown builtin */
3913       error ("built-in function `%s' not currently supported",
3914              IDENTIFIER_POINTER (DECL_NAME (fndecl)));
3915     }
3916
3917   /* The switch statement above can drop through to cause the function
3918      to be called normally.  */
3919   return expand_call (exp, target, ignore);
3920 }
3921
3922 /* Fold a call to __builtin_constant_p, if we know it will evaluate to a
3923    constant.  ARGLIST is the argument list of the call.  */
3924
3925 static tree
3926 fold_builtin_constant_p (arglist)
3927      tree arglist;
3928 {
3929   if (arglist == 0)
3930     return 0;
3931
3932   arglist = TREE_VALUE (arglist);
3933
3934   /* We return 1 for a numeric type that's known to be a constant
3935      value at compile-time or for an aggregate type that's a
3936      literal constant.  */
3937   STRIP_NOPS (arglist);
3938
3939   /* If we know this is a constant, emit the constant of one.  */
3940   if (TREE_CODE_CLASS (TREE_CODE (arglist)) == 'c'
3941       || (TREE_CODE (arglist) == CONSTRUCTOR
3942           && TREE_CONSTANT (arglist))
3943       || (TREE_CODE (arglist) == ADDR_EXPR
3944           && TREE_CODE (TREE_OPERAND (arglist, 0)) == STRING_CST))
3945     return integer_one_node;
3946
3947   /* If we aren't going to be running CSE or this expression
3948      has side effects, show we don't know it to be a constant.
3949      Likewise if it's a pointer or aggregate type since in those
3950      case we only want literals, since those are only optimized
3951      when generating RTL, not later.
3952      And finally, if we are compiling an initializer, not code, we
3953      need to return a definite result now; there's not going to be any
3954      more optimization done.  */
3955   if (TREE_SIDE_EFFECTS (arglist) || cse_not_expected
3956       || AGGREGATE_TYPE_P (TREE_TYPE (arglist))
3957       || POINTER_TYPE_P (TREE_TYPE (arglist))
3958       || cfun == 0)
3959     return integer_zero_node;
3960
3961   return 0;
3962 }
3963
3964 /* Fold a call to __builtin_classify_type.  */
3965
3966 static tree
3967 fold_builtin_classify_type (arglist)
3968      tree arglist;
3969 {
3970   if (arglist == 0)
3971     return build_int_2 (no_type_class, 0);
3972
3973   return build_int_2 (type_to_class (TREE_TYPE (TREE_VALUE (arglist))), 0);
3974 }
3975
3976 /* Used by constant folding to eliminate some builtin calls early.  EXP is
3977    the CALL_EXPR of a call to a builtin function.  */
3978
3979 tree
3980 fold_builtin (exp)
3981      tree exp;
3982 {
3983   tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
3984   tree arglist = TREE_OPERAND (exp, 1);
3985   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
3986
3987   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
3988     return 0;
3989
3990   switch (fcode)
3991     {
3992     case BUILT_IN_CONSTANT_P:
3993       return fold_builtin_constant_p (arglist);
3994
3995     case BUILT_IN_CLASSIFY_TYPE:
3996       return fold_builtin_classify_type (arglist);
3997
3998     case BUILT_IN_STRLEN:
3999       if (validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
4000         {
4001           tree len = c_strlen (TREE_VALUE (arglist));
4002           if (len != 0)
4003             return len;
4004         }
4005       break;
4006
4007     default:
4008       break;
4009     }
4010
4011   return 0;
4012 }
4013
4014 static tree
4015 build_function_call_expr (fn, arglist)
4016      tree fn, arglist;
4017 {
4018   tree call_expr;
4019
4020   call_expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
4021   call_expr = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
4022                      call_expr, arglist);
4023   TREE_SIDE_EFFECTS (call_expr) = 1;
4024   return fold (call_expr);
4025 }
4026
4027 /* This function validates the types of a function call argument list
4028    represented as a tree chain of parameters against a specified list
4029    of tree_codes.  If the last specifier is a 0, that represents an
4030    ellipses, otherwise the last specifier must be a VOID_TYPE.  */
4031
4032 static int
4033 validate_arglist VPARAMS ((tree arglist, ...))
4034 {
4035   enum tree_code code;
4036   int res = 0;
4037
4038   VA_OPEN (ap, arglist);
4039   VA_FIXEDARG (ap, tree, arglist);
4040
4041   do {
4042     code = va_arg (ap, enum tree_code);
4043     switch (code)
4044     {
4045     case 0:
4046       /* This signifies an ellipses, any further arguments are all ok.  */
4047       res = 1;
4048       goto end;
4049     case VOID_TYPE:
4050       /* This signifies an endlink, if no arguments remain, return
4051          true, otherwise return false.  */
4052       res = arglist == 0;
4053       goto end;
4054     default:
4055       /* If no parameters remain or the parameter's code does not
4056          match the specified code, return false.  Otherwise continue
4057          checking any remaining arguments.  */
4058       if (arglist == 0 || code != TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))))
4059         goto end;
4060       break;
4061     }
4062     arglist = TREE_CHAIN (arglist);
4063   } while (1);
4064
4065   /* We need gotos here since we can only have one VA_CLOSE in a
4066      function.  */
4067  end: ;
4068   VA_CLOSE (ap);
4069
4070   return res;
4071 }
4072
4073 /* Default version of target-specific builtin setup that does nothing.  */
4074
4075 void
4076 default_init_builtins ()
4077 {
4078 }
4079
4080 /* Default target-specific builtin expander that does nothing.  */
4081
4082 rtx
4083 default_expand_builtin (exp, target, subtarget, mode, ignore)
4084      tree exp ATTRIBUTE_UNUSED;
4085      rtx target ATTRIBUTE_UNUSED;
4086      rtx subtarget ATTRIBUTE_UNUSED;
4087      enum machine_mode mode ATTRIBUTE_UNUSED;
4088      int ignore ATTRIBUTE_UNUSED;
4089 {
4090   return NULL_RTX;
4091 }