gcc/builtins.c

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