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