gcc/builtins.c

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