gcc/builtins.c

   1 /* Expand builtin functions.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  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 "gimple.h"
  31 #include "flags.h"
  32 #include "regs.h"
  33 #include "hard-reg-set.h"
  34 #include "except.h"
  35 #include "function.h"
  36 #include "insn-config.h"
  37 #include "expr.h"
  38 #include "optabs.h"
  39 #include "libfuncs.h"
  40 #include "recog.h"
  41 #include "output.h"
  42 #include "typeclass.h"
  43 #include "toplev.h"
  44 #include "predict.h"
  45 #include "tm_p.h"
  46 #include "target.h"
  47 #include "langhooks.h"
  48 #include "basic-block.h"
  49 #include "tree-mudflap.h"
  50 #include "tree-flow.h"
  51 #include "value-prof.h"
  52 #include "diagnostic.h"
  53
  54 #ifndef SLOW_UNALIGNED_ACCESS
  55 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT
  56 #endif
  57
  58 #ifndef PAD_VARARGS_DOWN
  59 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
  60 #endif
  61 static tree do_mpc_arg1 (tree, tree, int (*)(mpc_ptr, mpc_srcptr, mpc_rnd_t));
  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, COND) #X,
  68 const char * 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 const char *c_getstr (tree);
  83 static rtx c_readstr (const char *, enum machine_mode);
  84 static int target_char_cast (tree, char *);
  85 static rtx get_memory_rtx (tree, tree);
  86 static int apply_args_size (void);
  87 static int apply_result_size (void);
  88 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
  89 static rtx result_vector (int, rtx);
  90 #endif
  91 static void expand_builtin_update_setjmp_buf (rtx);
  92 static void expand_builtin_prefetch (tree);
  93 static rtx expand_builtin_apply_args (void);
  94 static rtx expand_builtin_apply_args_1 (void);
  95 static rtx expand_builtin_apply (rtx, rtx, rtx);
  96 static void expand_builtin_return (rtx);
  97 static enum type_class type_to_class (tree);
  98 static rtx expand_builtin_classify_type (tree);
  99 static void expand_errno_check (tree, rtx);
 100 static rtx expand_builtin_mathfn (tree, rtx, rtx);
 101 static rtx expand_builtin_mathfn_2 (tree, rtx, rtx);
 102 static rtx expand_builtin_mathfn_3 (tree, rtx, rtx);
 103 static rtx expand_builtin_interclass_mathfn (tree, rtx, rtx);
 104 static rtx expand_builtin_sincos (tree);
 105 static rtx expand_builtin_cexpi (tree, rtx, rtx);
 106 static rtx expand_builtin_int_roundingfn (tree, rtx);
 107 static rtx expand_builtin_int_roundingfn_2 (tree, rtx);
 108 static rtx expand_builtin_args_info (tree);
 109 static rtx expand_builtin_next_arg (void);
 110 static rtx expand_builtin_va_start (tree);
 111 static rtx expand_builtin_va_end (tree);
 112 static rtx expand_builtin_va_copy (tree);
 113 static rtx expand_builtin_memcmp (tree, rtx, enum machine_mode);
 114 static rtx expand_builtin_strcmp (tree, rtx);
 115 static rtx expand_builtin_strncmp (tree, rtx, enum machine_mode);
 116 static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
 117 static rtx expand_builtin_memcpy (tree, rtx);
 118 static rtx expand_builtin_mempcpy (tree, rtx, enum machine_mode);
 119 static rtx expand_builtin_mempcpy_args (tree, tree, tree, rtx,
 120                                         enum machine_mode, int);
 121 static rtx expand_builtin_strcpy (tree, rtx);
 122 static rtx expand_builtin_strcpy_args (tree, tree, rtx);
 123 static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode);
 124 static rtx expand_builtin_strncpy (tree, rtx);
 125 static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, enum machine_mode);
 126 static rtx expand_builtin_memset (tree, rtx, enum machine_mode);
 127 static rtx expand_builtin_memset_args (tree, tree, tree, rtx, enum machine_mode, tree);
 128 static rtx expand_builtin_bzero (tree);
 129 static rtx expand_builtin_strlen (tree, rtx, enum machine_mode);
 130 static rtx expand_builtin_alloca (tree, rtx);
 131 static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);
 132 static rtx expand_builtin_frame_address (tree, tree);
 133 static tree stabilize_va_list_loc (location_t, tree, int);
 134 static rtx expand_builtin_expect (tree, rtx);
 135 static tree fold_builtin_constant_p (tree);
 136 static tree fold_builtin_expect (location_t, tree, tree);
 137 static tree fold_builtin_classify_type (tree);
 138 static tree fold_builtin_strlen (location_t, tree, tree);
 139 static tree fold_builtin_inf (location_t, tree, int);
 140 static tree fold_builtin_nan (tree, tree, int);
 141 static tree rewrite_call_expr (location_t, tree, int, tree, int, ...);
 142 static bool validate_arg (const_tree, enum tree_code code);
 143 static bool integer_valued_real_p (tree);
 144 static tree fold_trunc_transparent_mathfn (location_t, tree, tree);
 145 static bool readonly_data_expr (tree);
 146 static rtx expand_builtin_fabs (tree, rtx, rtx);
 147 static rtx expand_builtin_signbit (tree, rtx);
 148 static tree fold_builtin_sqrt (location_t, tree, tree);
 149 static tree fold_builtin_cbrt (location_t, tree, tree);
 150 static tree fold_builtin_pow (location_t, tree, tree, tree, tree);
 151 static tree fold_builtin_powi (location_t, tree, tree, tree, tree);
 152 static tree fold_builtin_cos (location_t, tree, tree, tree);
 153 static tree fold_builtin_cosh (location_t, tree, tree, tree);
 154 static tree fold_builtin_tan (tree, tree);
 155 static tree fold_builtin_trunc (location_t, tree, tree);
 156 static tree fold_builtin_floor (location_t, tree, tree);
 157 static tree fold_builtin_ceil (location_t, tree, tree);
 158 static tree fold_builtin_round (location_t, tree, tree);
 159 static tree fold_builtin_int_roundingfn (location_t, tree, tree);
 160 static tree fold_builtin_bitop (tree, tree);
 161 static tree fold_builtin_memory_op (location_t, tree, tree, tree, tree, bool, int);
 162 static tree fold_builtin_strchr (location_t, tree, tree, tree);
 163 static tree fold_builtin_memchr (location_t, tree, tree, tree, tree);
 164 static tree fold_builtin_memcmp (location_t, tree, tree, tree);
 165 static tree fold_builtin_strcmp (location_t, tree, tree);
 166 static tree fold_builtin_strncmp (location_t, tree, tree, tree);
 167 static tree fold_builtin_signbit (location_t, tree, tree);
 168 static tree fold_builtin_copysign (location_t, tree, tree, tree, tree);
 169 static tree fold_builtin_isascii (location_t, tree);
 170 static tree fold_builtin_toascii (location_t, tree);
 171 static tree fold_builtin_isdigit (location_t, tree);
 172 static tree fold_builtin_fabs (location_t, tree, tree);
 173 static tree fold_builtin_abs (location_t, tree, tree);
 174 static tree fold_builtin_unordered_cmp (location_t, tree, tree, tree, enum tree_code,
 175                                         enum tree_code);
 176 static tree fold_builtin_n (location_t, tree, tree *, int, bool);
 177 static tree fold_builtin_0 (location_t, tree, bool);
 178 static tree fold_builtin_1 (location_t, tree, tree, bool);
 179 static tree fold_builtin_2 (location_t, tree, tree, tree, bool);
 180 static tree fold_builtin_3 (location_t, tree, tree, tree, tree, bool);
 181 static tree fold_builtin_4 (location_t, tree, tree, tree, tree, tree, bool);
 182 static tree fold_builtin_varargs (location_t, tree, tree, bool);
 183
 184 static tree fold_builtin_strpbrk (location_t, tree, tree, tree);
 185 static tree fold_builtin_strstr (location_t, tree, tree, tree);
 186 static tree fold_builtin_strrchr (location_t, tree, tree, tree);
 187 static tree fold_builtin_strcat (location_t, tree, tree);
 188 static tree fold_builtin_strncat (location_t, tree, tree, tree);
 189 static tree fold_builtin_strspn (location_t, tree, tree);
 190 static tree fold_builtin_strcspn (location_t, tree, tree);
 191 static tree fold_builtin_sprintf (location_t, tree, tree, tree, int);
 192
 193 static rtx expand_builtin_object_size (tree);
 194 static rtx expand_builtin_memory_chk (tree, rtx, enum machine_mode,
 195                                       enum built_in_function);
 196 static void maybe_emit_chk_warning (tree, enum built_in_function);
 197 static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
 198 static void maybe_emit_free_warning (tree);
 199 static tree fold_builtin_object_size (tree, tree);
 200 static tree fold_builtin_strcat_chk (location_t, tree, tree, tree, tree);
 201 static tree fold_builtin_strncat_chk (location_t, tree, tree, tree, tree, tree);
 202 static tree fold_builtin_sprintf_chk (location_t, tree, enum built_in_function);
 203 static tree fold_builtin_printf (location_t, tree, tree, tree, bool, enum built_in_function);
 204 static tree fold_builtin_fprintf (location_t, tree, tree, tree, tree, bool,
 205                                   enum built_in_function);
 206 static bool init_target_chars (void);
 207
 208 static unsigned HOST_WIDE_INT target_newline;
 209 static unsigned HOST_WIDE_INT target_percent;
 210 static unsigned HOST_WIDE_INT target_c;
 211 static unsigned HOST_WIDE_INT target_s;
 212 static char target_percent_c[3];
 213 static char target_percent_s[3];
 214 static char target_percent_s_newline[4];
 215 static tree do_mpfr_arg1 (tree, tree, int (*)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
 216                           const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, bool);
 217 static tree do_mpfr_arg2 (tree, tree, tree,
 218                           int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
 219 static tree do_mpfr_arg3 (tree, tree, tree, tree,
 220                           int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
 221 static tree do_mpfr_sincos (tree, tree, tree);
 222 static tree do_mpfr_bessel_n (tree, tree, tree,
 223                               int (*)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
 224                               const REAL_VALUE_TYPE *, bool);
 225 static tree do_mpfr_remquo (tree, tree, tree);
 226 static tree do_mpfr_lgamma_r (tree, tree, tree);
 227
 228 /* Return true if NAME starts with __builtin_ or __sync_.  */
 229
 230 bool
 231 is_builtin_name (const char *name)
 232 {
 233   if (strncmp (name, "__builtin_", 10) == 0)
 234     return true;
 235   if (strncmp (name, "__sync_", 7) == 0)
 236     return true;
 237   return false;
 238 }
 239
 240
 241 /* Return true if DECL is a function symbol representing a built-in.  */
 242
 243 bool
 244 is_builtin_fn (tree decl)
 245 {
 246   return TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl);
 247 }
 248
 249
 250 /* Return true if NODE should be considered for inline expansion regardless
 251    of the optimization level.  This means whenever a function is invoked with
 252    its "internal" name, which normally contains the prefix "__builtin".  */
 253
 254 static bool
 255 called_as_built_in (tree node)
 256 {
 257   /* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since
 258      we want the name used to call the function, not the name it
 259      will have. */
 260   const char *name = IDENTIFIER_POINTER (DECL_NAME (node));
 261   return is_builtin_name (name);
 262 }
 263
 264 /* Return the alignment in bits of EXP, an object.
 265    Don't return more than MAX_ALIGN no matter what, ALIGN is the inital
 266    guessed alignment e.g. from type alignment.  */
 267
 268 int
 269 get_object_alignment (tree exp, unsigned int align, unsigned int max_align)
 270 {
 271   unsigned int inner;
 272
 273   inner = max_align;
 274   if (handled_component_p (exp))
 275    {
 276       HOST_WIDE_INT bitsize, bitpos;
 277       tree offset;
 278       enum machine_mode mode;
 279       int unsignedp, volatilep;
 280
 281       exp = get_inner_reference (exp, &bitsize, &bitpos, &offset,
 282                                  &mode, &unsignedp, &volatilep, true);
 283       if (bitpos)
 284         inner = MIN (inner, (unsigned) (bitpos & -bitpos));
 285       while (offset)
 286         {
 287           tree next_offset;
 288
 289           if (TREE_CODE (offset) == PLUS_EXPR)
 290             {
 291               next_offset = TREE_OPERAND (offset, 0);
 292               offset = TREE_OPERAND (offset, 1);
 293             }
 294           else
 295             next_offset = NULL;
 296           if (host_integerp (offset, 1))
 297             {
 298               /* Any overflow in calculating offset_bits won't change
 299                  the alignment.  */
 300               unsigned offset_bits
 301                 = ((unsigned) tree_low_cst (offset, 1) * BITS_PER_UNIT);
 302
 303               if (offset_bits)
 304                 inner = MIN (inner, (offset_bits & -offset_bits));
 305             }
 306           else if (TREE_CODE (offset) == MULT_EXPR
 307                    && host_integerp (TREE_OPERAND (offset, 1), 1))
 308             {
 309               /* Any overflow in calculating offset_factor won't change
 310                  the alignment.  */
 311               unsigned offset_factor
 312                 = ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)
 313                    * BITS_PER_UNIT);
 314
 315               if (offset_factor)
 316                 inner = MIN (inner, (offset_factor & -offset_factor));
 317             }
 318           else
 319             {
 320               inner = MIN (inner, BITS_PER_UNIT);
 321               break;
 322             }
 323           offset = next_offset;
 324         }
 325     }
 326   if (TREE_CODE (exp) == CONST_DECL)
 327     exp = DECL_INITIAL (exp);
 328   if (DECL_P (exp)
 329       && TREE_CODE (exp) != LABEL_DECL)
 330     align = MIN (inner, DECL_ALIGN (exp));
 331 #ifdef CONSTANT_ALIGNMENT
 332   else if (CONSTANT_CLASS_P (exp))
 333     align = MIN (inner, (unsigned)CONSTANT_ALIGNMENT (exp, align));
 334 #endif
 335   else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR
 336            || TREE_CODE (exp) == INDIRECT_REF)
 337     align = MIN (TYPE_ALIGN (TREE_TYPE (exp)), inner);
 338   else
 339     align = MIN (align, inner);
 340   return MIN (align, max_align);
 341 }
 342
 343 /* Returns true iff we can trust that alignment information has been
 344    calculated properly.  */
 345
 346 bool
 347 can_trust_pointer_alignment (void)
 348 {
 349   /* We rely on TER to compute accurate alignment information.  */
 350   return (optimize && flag_tree_ter);
 351 }
 352
 353 /* Return the alignment in bits of EXP, a pointer valued expression.
 354    But don't return more than MAX_ALIGN no matter what.
 355    The alignment returned is, by default, the alignment of the thing that
 356    EXP points to.  If it is not a POINTER_TYPE, 0 is returned.
 357
 358    Otherwise, look at the expression to see if we can do better, i.e., if the
 359    expression is actually pointing at an object whose alignment is tighter.  */
 360
 361 int
 362 get_pointer_alignment (tree exp, unsigned int max_align)
 363 {
 364   unsigned int align, inner;
 365
 366   if (!can_trust_pointer_alignment ())
 367     return 0;
 368
 369   if (!POINTER_TYPE_P (TREE_TYPE (exp)))
 370     return 0;
 371
 372   align = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
 373   align = MIN (align, max_align);
 374
 375   while (1)
 376     {
 377       switch (TREE_CODE (exp))
 378         {
 379         CASE_CONVERT:
 380           exp = TREE_OPERAND (exp, 0);
 381           if (! POINTER_TYPE_P (TREE_TYPE (exp)))
 382             return align;
 383
 384           inner = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
 385           align = MIN (inner, max_align);
 386           break;
 387
 388         case POINTER_PLUS_EXPR:
 389           /* If sum of pointer + int, restrict our maximum alignment to that
 390              imposed by the integer.  If not, we can't do any better than
 391              ALIGN.  */
 392           if (! host_integerp (TREE_OPERAND (exp, 1), 1))
 393             return align;
 394
 395           while (((tree_low_cst (TREE_OPERAND (exp, 1), 1))
 396                   & (max_align / BITS_PER_UNIT - 1))
 397                  != 0)
 398             max_align >>= 1;
 399
 400           exp = TREE_OPERAND (exp, 0);
 401           break;
 402
 403         case ADDR_EXPR:
 404           /* See what we are pointing at and look at its alignment.  */
 405           return get_object_alignment (TREE_OPERAND (exp, 0), align, max_align);
 406
 407         default:
 408           return align;
 409         }
 410     }
 411 }
 412
 413 /* Compute the length of a C string.  TREE_STRING_LENGTH is not the right
 414    way, because it could contain a zero byte in the middle.
 415    TREE_STRING_LENGTH is the size of the character array, not the string.
 416
 417    ONLY_VALUE should be nonzero if the result is not going to be emitted
 418    into the instruction stream and zero if it is going to be expanded.
 419    E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
 420    is returned, otherwise NULL, since
 421    len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
 422    evaluate the side-effects.
 423
 424    The value returned is of type `ssizetype'.
 425
 426    Unfortunately, string_constant can't access the values of const char
 427    arrays with initializers, so neither can we do so here.  */
 428
 429 tree
 430 c_strlen (tree src, int only_value)
 431 {
 432   tree offset_node;
 433   HOST_WIDE_INT offset;
 434   int max;
 435   const char *ptr;
 436   location_t loc;
 437
 438   STRIP_NOPS (src);
 439   if (TREE_CODE (src) == COND_EXPR
 440       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 441     {
 442       tree len1, len2;
 443
 444       len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
 445       len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
 446       if (tree_int_cst_equal (len1, len2))
 447         return len1;
 448     }
 449
 450   if (TREE_CODE (src) == COMPOUND_EXPR
 451       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 452     return c_strlen (TREE_OPERAND (src, 1), only_value);
 453
 454   if (EXPR_HAS_LOCATION (src))
 455     loc = EXPR_LOCATION (src);
 456   else
 457     loc = input_location;
 458
 459   src = string_constant (src, &offset_node);
 460   if (src == 0)
 461     return NULL_TREE;
 462
 463   max = TREE_STRING_LENGTH (src) - 1;
 464   ptr = TREE_STRING_POINTER (src);
 465
 466   if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
 467     {
 468       /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
 469          compute the offset to the following null if we don't know where to
 470          start searching for it.  */
 471       int i;
 472
 473       for (i = 0; i < max; i++)
 474         if (ptr[i] == 0)
 475           return NULL_TREE;
 476
 477       /* We don't know the starting offset, but we do know that the string
 478          has no internal zero bytes.  We can assume that the offset falls
 479          within the bounds of the string; otherwise, the programmer deserves
 480          what he gets.  Subtract the offset from the length of the string,
 481          and return that.  This would perhaps not be valid if we were dealing
 482          with named arrays in addition to literal string constants.  */
 483
 484       return size_diffop_loc (loc, size_int (max), offset_node);
 485     }
 486
 487   /* We have a known offset into the string.  Start searching there for
 488      a null character if we can represent it as a single HOST_WIDE_INT.  */
 489   if (offset_node == 0)
 490     offset = 0;
 491   else if (! host_integerp (offset_node, 0))
 492     offset = -1;
 493   else
 494     offset = tree_low_cst (offset_node, 0);
 495
 496   /* If the offset is known to be out of bounds, warn, and call strlen at
 497      runtime.  */
 498   if (offset < 0 || offset > max)
 499     {
 500      /* Suppress multiple warnings for propagated constant strings.  */
 501       if (! TREE_NO_WARNING (src))
 502         {
 503           warning_at (loc, 0, "offset outside bounds of constant string");
 504           TREE_NO_WARNING (src) = 1;
 505         }
 506       return NULL_TREE;
 507     }
 508
 509   /* Use strlen to search for the first zero byte.  Since any strings
 510      constructed with build_string will have nulls appended, we win even
 511      if we get handed something like (char[4])"abcd".
 512
 513      Since OFFSET is our starting index into the string, no further
 514      calculation is needed.  */
 515   return ssize_int (strlen (ptr + offset));
 516 }
 517
 518 /* Return a char pointer for a C string if it is a string constant
 519    or sum of string constant and integer constant.  */
 520
 521 static const char *
 522 c_getstr (tree src)
 523 {
 524   tree offset_node;
 525
 526   src = string_constant (src, &offset_node);
 527   if (src == 0)
 528     return 0;
 529
 530   if (offset_node == 0)
 531     return TREE_STRING_POINTER (src);
 532   else if (!host_integerp (offset_node, 1)
 533            || compare_tree_int (offset_node, TREE_STRING_LENGTH (src) - 1) > 0)
 534     return 0;
 535
 536   return TREE_STRING_POINTER (src) + tree_low_cst (offset_node, 1);
 537 }
 538
 539 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
 540    GET_MODE_BITSIZE (MODE) bits from string constant STR.  */
 541
 542 static rtx
 543 c_readstr (const char *str, enum machine_mode mode)
 544 {
 545   HOST_WIDE_INT c[2];
 546   HOST_WIDE_INT ch;
 547   unsigned int i, j;
 548
 549   gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
 550
 551   c[0] = 0;
 552   c[1] = 0;
 553   ch = 1;
 554   for (i = 0; i < GET_MODE_SIZE (mode); i++)
 555     {
 556       j = i;
 557       if (WORDS_BIG_ENDIAN)
 558         j = GET_MODE_SIZE (mode) - i - 1;
 559       if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
 560           && GET_MODE_SIZE (mode) > UNITS_PER_WORD)
 561         j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
 562       j *= BITS_PER_UNIT;
 563       gcc_assert (j < 2 * HOST_BITS_PER_WIDE_INT);
 564
 565       if (ch)
 566         ch = (unsigned char) str[i];
 567       c[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
 568     }
 569   return immed_double_const (c[0], c[1], mode);
 570 }
 571
 572 /* Cast a target constant CST to target CHAR and if that value fits into
 573    host char type, return zero and put that value into variable pointed to by
 574    P.  */
 575
 576 static int
 577 target_char_cast (tree cst, char *p)
 578 {
 579   unsigned HOST_WIDE_INT val, hostval;
 580
 581   if (!host_integerp (cst, 1)
 582       || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
 583     return 1;
 584
 585   val = tree_low_cst (cst, 1);
 586   if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
 587     val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
 588
 589   hostval = val;
 590   if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
 591     hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
 592
 593   if (val != hostval)
 594     return 1;
 595
 596   *p = hostval;
 597   return 0;
 598 }
 599
 600 /* Similar to save_expr, but assumes that arbitrary code is not executed
 601    in between the multiple evaluations.  In particular, we assume that a
 602    non-addressable local variable will not be modified.  */
 603
 604 static tree
 605 builtin_save_expr (tree exp)
 606 {
 607   if (TREE_ADDRESSABLE (exp) == 0
 608       && (TREE_CODE (exp) == PARM_DECL
 609           || (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp))))
 610     return exp;
 611
 612   return save_expr (exp);
 613 }
 614
 615 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
 616    times to get the address of either a higher stack frame, or a return
 617    address located within it (depending on FNDECL_CODE).  */
 618
 619 static rtx
 620 expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
 621 {
 622   int i;
 623
 624 #ifdef INITIAL_FRAME_ADDRESS_RTX
 625   rtx tem = INITIAL_FRAME_ADDRESS_RTX;
 626 #else
 627   rtx tem;
 628
 629   /* For a zero count with __builtin_return_address, we don't care what
 630      frame address we return, because target-specific definitions will
 631      override us.  Therefore frame pointer elimination is OK, and using
 632      the soft frame pointer is OK.
 633
 634      For a nonzero count, or a zero count with __builtin_frame_address,
 635      we require a stable offset from the current frame pointer to the
 636      previous one, so we must use the hard frame pointer, and
 637      we must disable frame pointer elimination.  */
 638   if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)
 639     tem = frame_pointer_rtx;
 640   else
 641     {
 642       tem = hard_frame_pointer_rtx;
 643
 644       /* Tell reload not to eliminate the frame pointer.  */
 645       crtl->accesses_prior_frames = 1;
 646     }
 647 #endif
 648
 649   /* Some machines need special handling before we can access
 650      arbitrary frames.  For example, on the SPARC, we must first flush
 651      all register windows to the stack.  */
 652 #ifdef SETUP_FRAME_ADDRESSES
 653   if (count > 0)
 654     SETUP_FRAME_ADDRESSES ();
 655 #endif
 656
 657   /* On the SPARC, the return address is not in the frame, it is in a
 658      register.  There is no way to access it off of the current frame
 659      pointer, but it can be accessed off the previous frame pointer by
 660      reading the value from the register window save area.  */
 661 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
 662   if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
 663     count--;
 664 #endif
 665
 666   /* Scan back COUNT frames to the specified frame.  */
 667   for (i = 0; i < count; i++)
 668     {
 669       /* Assume the dynamic chain pointer is in the word that the
 670          frame address points to, unless otherwise specified.  */
 671 #ifdef DYNAMIC_CHAIN_ADDRESS
 672       tem = DYNAMIC_CHAIN_ADDRESS (tem);
 673 #endif
 674       tem = memory_address (Pmode, tem);
 675       tem = gen_frame_mem (Pmode, tem);
 676       tem = copy_to_reg (tem);
 677     }
 678
 679   /* For __builtin_frame_address, return what we've got.  But, on
 680      the SPARC for example, we may have to add a bias.  */
 681   if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
 682 #ifdef FRAME_ADDR_RTX
 683     return FRAME_ADDR_RTX (tem);
 684 #else
 685     return tem;
 686 #endif
 687
 688   /* For __builtin_return_address, get the return address from that frame.  */
 689 #ifdef RETURN_ADDR_RTX
 690   tem = RETURN_ADDR_RTX (count, tem);
 691 #else
 692   tem = memory_address (Pmode,
 693                         plus_constant (tem, GET_MODE_SIZE (Pmode)));
 694   tem = gen_frame_mem (Pmode, tem);
 695 #endif
 696   return tem;
 697 }
 698
 699 /* Alias set used for setjmp buffer.  */
 700 static alias_set_type setjmp_alias_set = -1;
 701
 702 /* Construct the leading half of a __builtin_setjmp call.  Control will
 703    return to RECEIVER_LABEL.  This is also called directly by the SJLJ
 704    exception handling code.  */
 705
 706 void
 707 expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
 708 {
 709   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 710   rtx stack_save;
 711   rtx mem;
 712
 713   if (setjmp_alias_set == -1)
 714     setjmp_alias_set = new_alias_set ();
 715
 716   buf_addr = convert_memory_address (Pmode, buf_addr);
 717
 718   buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
 719
 720   /* We store the frame pointer and the address of receiver_label in
 721      the buffer and use the rest of it for the stack save area, which
 722      is machine-dependent.  */
 723
 724   mem = gen_rtx_MEM (Pmode, buf_addr);
 725   set_mem_alias_set (mem, setjmp_alias_set);
 726   emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());
 727
 728   mem = gen_rtx_MEM (Pmode, plus_constant (buf_addr, GET_MODE_SIZE (Pmode))),
 729   set_mem_alias_set (mem, setjmp_alias_set);
 730
 731   emit_move_insn (validize_mem (mem),
 732                   force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
 733
 734   stack_save = gen_rtx_MEM (sa_mode,
 735                             plus_constant (buf_addr,
 736                                            2 * GET_MODE_SIZE (Pmode)));
 737   set_mem_alias_set (stack_save, setjmp_alias_set);
 738   emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
 739
 740   /* If there is further processing to do, do it.  */
 741 #ifdef HAVE_builtin_setjmp_setup
 742   if (HAVE_builtin_setjmp_setup)
 743     emit_insn (gen_builtin_setjmp_setup (buf_addr));
 744 #endif
 745
 746   /* Tell optimize_save_area_alloca that extra work is going to
 747      need to go on during alloca.  */
 748   cfun->calls_setjmp = 1;
 749
 750   /* We have a nonlocal label.   */
 751   cfun->has_nonlocal_label = 1;
 752 }
 753
 754 /* Construct the trailing part of a __builtin_setjmp call.  This is
 755    also called directly by the SJLJ exception handling code.  */
 756
 757 void
 758 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED)
 759 {
 760   rtx chain;
 761
 762   /* Clobber the FP when we get here, so we have to make sure it's
 763      marked as used by this function.  */
 764   emit_use (hard_frame_pointer_rtx);
 765
 766   /* Mark the static chain as clobbered here so life information
 767      doesn't get messed up for it.  */
 768   chain = targetm.calls.static_chain (current_function_decl, true);
 769   if (chain && REG_P (chain))
 770     emit_clobber (chain);
 771
 772   /* Now put in the code to restore the frame pointer, and argument
 773      pointer, if needed.  */
 774 #ifdef HAVE_nonlocal_goto
 775   if (! HAVE_nonlocal_goto)
 776 #endif
 777     {
 778       emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
 779       /* This might change the hard frame pointer in ways that aren't
 780          apparent to early optimization passes, so force a clobber.  */
 781       emit_clobber (hard_frame_pointer_rtx);
 782     }
 783
 784 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
 785   if (fixed_regs[ARG_POINTER_REGNUM])
 786     {
 787 #ifdef ELIMINABLE_REGS
 788       size_t i;
 789       static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
 790
 791       for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
 792         if (elim_regs[i].from == ARG_POINTER_REGNUM
 793             && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
 794           break;
 795
 796       if (i == ARRAY_SIZE (elim_regs))
 797 #endif
 798         {
 799           /* Now restore our arg pointer from the address at which it
 800              was saved in our stack frame.  */
 801           emit_move_insn (crtl->args.internal_arg_pointer,
 802                           copy_to_reg (get_arg_pointer_save_area ()));
 803         }
 804     }
 805 #endif
 806
 807 #ifdef HAVE_builtin_setjmp_receiver
 808   if (HAVE_builtin_setjmp_receiver)
 809     emit_insn (gen_builtin_setjmp_receiver (receiver_label));
 810   else
 811 #endif
 812 #ifdef HAVE_nonlocal_goto_receiver
 813     if (HAVE_nonlocal_goto_receiver)
 814       emit_insn (gen_nonlocal_goto_receiver ());
 815     else
 816 #endif
 817       { /* Nothing */ }
 818
 819   /* We must not allow the code we just generated to be reordered by
 820      scheduling.  Specifically, the update of the frame pointer must
 821      happen immediately, not later.  */
 822   emit_insn (gen_blockage ());
 823 }
 824
 825 /* __builtin_longjmp is passed a pointer to an array of five words (not
 826    all will be used on all machines).  It operates similarly to the C
 827    library function of the same name, but is more efficient.  Much of
 828    the code below is copied from the handling of non-local gotos.  */
 829
 830 static void
 831 expand_builtin_longjmp (rtx buf_addr, rtx value)
 832 {
 833   rtx fp, lab, stack, insn, last;
 834   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 835
 836   /* DRAP is needed for stack realign if longjmp is expanded to current
 837      function  */
 838   if (SUPPORTS_STACK_ALIGNMENT)
 839     crtl->need_drap = true;
 840
 841   if (setjmp_alias_set == -1)
 842     setjmp_alias_set = new_alias_set ();
 843
 844   buf_addr = convert_memory_address (Pmode, buf_addr);
 845
 846   buf_addr = force_reg (Pmode, buf_addr);
 847
 848   /* We require that the user must pass a second argument of 1, because
 849      that is what builtin_setjmp will return.  */
 850   gcc_assert (value == const1_rtx);
 851
 852   last = get_last_insn ();
 853 #ifdef HAVE_builtin_longjmp
 854   if (HAVE_builtin_longjmp)
 855     emit_insn (gen_builtin_longjmp (buf_addr));
 856   else
 857 #endif
 858     {
 859       fp = gen_rtx_MEM (Pmode, buf_addr);
 860       lab = gen_rtx_MEM (Pmode, plus_constant (buf_addr,
 861                                                GET_MODE_SIZE (Pmode)));
 862
 863       stack = gen_rtx_MEM (sa_mode, plus_constant (buf_addr,
 864                                                    2 * GET_MODE_SIZE (Pmode)));
 865       set_mem_alias_set (fp, setjmp_alias_set);
 866       set_mem_alias_set (lab, setjmp_alias_set);
 867       set_mem_alias_set (stack, setjmp_alias_set);
 868
 869       /* Pick up FP, label, and SP from the block and jump.  This code is
 870          from expand_goto in stmt.c; see there for detailed comments.  */
 871 #ifdef HAVE_nonlocal_goto
 872       if (HAVE_nonlocal_goto)
 873         /* We have to pass a value to the nonlocal_goto pattern that will
 874            get copied into the static_chain pointer, but it does not matter
 875            what that value is, because builtin_setjmp does not use it.  */
 876         emit_insn (gen_nonlocal_goto (value, lab, stack, fp));
 877       else
 878 #endif
 879         {
 880           lab = copy_to_reg (lab);
 881
 882           emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
 883           emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
 884
 885           emit_move_insn (hard_frame_pointer_rtx, fp);
 886           emit_stack_restore (SAVE_NONLOCAL, stack, NULL_RTX);
 887
 888           emit_use (hard_frame_pointer_rtx);
 889           emit_use (stack_pointer_rtx);
 890           emit_indirect_jump (lab);
 891         }
 892     }
 893
 894   /* Search backwards and mark the jump insn as a non-local goto.
 895      Note that this precludes the use of __builtin_longjmp to a
 896      __builtin_setjmp target in the same function.  However, we've
 897      already cautioned the user that these functions are for
 898      internal exception handling use only.  */
 899   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
 900     {
 901       gcc_assert (insn != last);
 902
 903       if (JUMP_P (insn))
 904         {
 905           add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
 906           break;
 907         }
 908       else if (CALL_P (insn))
 909         break;
 910     }
 911 }
 912
 913 /* Expand a call to __builtin_nonlocal_goto.  We're passed the target label
 914    and the address of the save area.  */
 915
 916 static rtx
 917 expand_builtin_nonlocal_goto (tree exp)
 918 {
 919   tree t_label, t_save_area;
 920   rtx r_label, r_save_area, r_fp, r_sp, insn;
 921
 922   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
 923     return NULL_RTX;
 924
 925   t_label = CALL_EXPR_ARG (exp, 0);
 926   t_save_area = CALL_EXPR_ARG (exp, 1);
 927
 928   r_label = expand_normal (t_label);
 929   r_label = convert_memory_address (Pmode, r_label);
 930   r_save_area = expand_normal (t_save_area);
 931   r_save_area = convert_memory_address (Pmode, r_save_area);
 932   /* Copy the address of the save location to a register just in case it was based
 933     on the frame pointer.   */
 934   r_save_area = copy_to_reg (r_save_area);
 935   r_fp = gen_rtx_MEM (Pmode, r_save_area);
 936   r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL),
 937                       plus_constant (r_save_area, GET_MODE_SIZE (Pmode)));
 938
 939   crtl->has_nonlocal_goto = 1;
 940
 941 #ifdef HAVE_nonlocal_goto
 942   /* ??? We no longer need to pass the static chain value, afaik.  */
 943   if (HAVE_nonlocal_goto)
 944     emit_insn (gen_nonlocal_goto (const0_rtx, r_label, r_sp, r_fp));
 945   else
 946 #endif
 947     {
 948       r_label = copy_to_reg (r_label);
 949
 950       emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
 951       emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
 952
 953       /* Restore frame pointer for containing function.
 954          This sets the actual hard register used for the frame pointer
 955          to the location of the function's incoming static chain info.
 956          The non-local goto handler will then adjust it to contain the
 957          proper value and reload the argument pointer, if needed.  */
 958       emit_move_insn (hard_frame_pointer_rtx, r_fp);
 959       emit_stack_restore (SAVE_NONLOCAL, r_sp, NULL_RTX);
 960
 961       /* USE of hard_frame_pointer_rtx added for consistency;
 962          not clear if really needed.  */
 963       emit_use (hard_frame_pointer_rtx);
 964       emit_use (stack_pointer_rtx);
 965
 966       /* If the architecture is using a GP register, we must
 967          conservatively assume that the target function makes use of it.
 968          The prologue of functions with nonlocal gotos must therefore
 969          initialize the GP register to the appropriate value, and we
 970          must then make sure that this value is live at the point
 971          of the jump.  (Note that this doesn't necessarily apply
 972          to targets with a nonlocal_goto pattern; they are free
 973          to implement it in their own way.  Note also that this is
 974          a no-op if the GP register is a global invariant.)  */
 975       if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
 976           && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
 977         emit_use (pic_offset_table_rtx);
 978
 979       emit_indirect_jump (r_label);
 980     }
 981
 982   /* Search backwards to the jump insn and mark it as a
 983      non-local goto.  */
 984   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
 985     {
 986       if (JUMP_P (insn))
 987         {
 988           add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
 989           break;
 990         }
 991       else if (CALL_P (insn))
 992         break;
 993     }
 994
 995   return const0_rtx;
 996 }
 997
 998 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
 999    (not all will be used on all machines) that was passed to __builtin_setjmp.
1000    It updates the stack pointer in that block to correspond to the current
1001    stack pointer.  */
1002
1003 static void
1004 expand_builtin_update_setjmp_buf (rtx buf_addr)
1005 {
1006   enum machine_mode sa_mode = Pmode;
1007   rtx stack_save;
1008
1009
1010 #ifdef HAVE_save_stack_nonlocal
1011   if (HAVE_save_stack_nonlocal)
1012     sa_mode = insn_data[(int) CODE_FOR_save_stack_nonlocal].operand[0].mode;
1013 #endif
1014 #ifdef STACK_SAVEAREA_MODE
1015   sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
1016 #endif
1017
1018   stack_save
1019     = gen_rtx_MEM (sa_mode,
1020                    memory_address
1021                    (sa_mode,
1022                     plus_constant (buf_addr, 2 * GET_MODE_SIZE (Pmode))));
1023
1024 #ifdef HAVE_setjmp
1025   if (HAVE_setjmp)
1026     emit_insn (gen_setjmp ());
1027 #endif
1028
1029   emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
1030 }
1031
1032 /* Expand a call to __builtin_prefetch.  For a target that does not support
1033    data prefetch, evaluate the memory address argument in case it has side
1034    effects.  */
1035
1036 static void
1037 expand_builtin_prefetch (tree exp)
1038 {
1039   tree arg0, arg1, arg2;
1040   int nargs;
1041   rtx op0, op1, op2;
1042
1043   if (!validate_arglist (exp, POINTER_TYPE, 0))
1044     return;
1045
1046   arg0 = CALL_EXPR_ARG (exp, 0);
1047
1048   /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1049      zero (read) and argument 2 (locality) defaults to 3 (high degree of
1050      locality).  */
1051   nargs = call_expr_nargs (exp);
1052   if (nargs > 1)
1053     arg1 = CALL_EXPR_ARG (exp, 1);
1054   else
1055     arg1 = integer_zero_node;
1056   if (nargs > 2)
1057     arg2 = CALL_EXPR_ARG (exp, 2);
1058   else
1059     arg2 = build_int_cst (NULL_TREE, 3);
1060
1061   /* Argument 0 is an address.  */
1062   op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
1063
1064   /* Argument 1 (read/write flag) must be a compile-time constant int.  */
1065   if (TREE_CODE (arg1) != INTEGER_CST)
1066     {
1067       error ("second argument to %<__builtin_prefetch%> must be a constant");
1068       arg1 = integer_zero_node;
1069     }
1070   op1 = expand_normal (arg1);
1071   /* Argument 1 must be either zero or one.  */
1072   if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
1073     {
1074       warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1075                " using zero");
1076       op1 = const0_rtx;
1077     }
1078
1079   /* Argument 2 (locality) must be a compile-time constant int.  */
1080   if (TREE_CODE (arg2) != INTEGER_CST)
1081     {
1082       error ("third argument to %<__builtin_prefetch%> must be a constant");
1083       arg2 = integer_zero_node;
1084     }
1085   op2 = expand_normal (arg2);
1086   /* Argument 2 must be 0, 1, 2, or 3.  */
1087   if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
1088     {
1089       warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1090       op2 = const0_rtx;
1091     }
1092
1093 #ifdef HAVE_prefetch
1094   if (HAVE_prefetch)
1095     {
1096       if ((! (*insn_data[(int) CODE_FOR_prefetch].operand[0].predicate)
1097              (op0,
1098               insn_data[(int) CODE_FOR_prefetch].operand[0].mode))
1099           || (GET_MODE (op0) != Pmode))
1100         {
1101           op0 = convert_memory_address (Pmode, op0);
1102           op0 = force_reg (Pmode, op0);
1103         }
1104       emit_insn (gen_prefetch (op0, op1, op2));
1105     }
1106 #endif
1107
1108   /* Don't do anything with direct references to volatile memory, but
1109      generate code to handle other side effects.  */
1110   if (!MEM_P (op0) && side_effects_p (op0))
1111     emit_insn (op0);
1112 }
1113
1114 /* Get a MEM rtx for expression EXP which is the address of an operand
1115    to be used in a string instruction (cmpstrsi, movmemsi, ..).  LEN is
1116    the maximum length of the block of memory that might be accessed or
1117    NULL if unknown.  */
1118
1119 static rtx
1120 get_memory_rtx (tree exp, tree len)
1121 {
1122   tree orig_exp = exp;
1123   rtx addr, mem;
1124   HOST_WIDE_INT off;
1125
1126   /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1127      from its expression, for expr->a.b only <variable>.a.b is recorded.  */
1128   if (TREE_CODE (exp) == SAVE_EXPR && !SAVE_EXPR_RESOLVED_P (exp))
1129     exp = TREE_OPERAND (exp, 0);
1130
1131   addr = expand_expr (orig_exp, NULL_RTX, ptr_mode, EXPAND_NORMAL);
1132   mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
1133
1134   /* Get an expression we can use to find the attributes to assign to MEM.
1135      If it is an ADDR_EXPR, use the operand.  Otherwise, dereference it if
1136      we can.  First remove any nops.  */
1137   while (CONVERT_EXPR_P (exp)
1138          && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
1139     exp = TREE_OPERAND (exp, 0);
1140
1141   off = 0;
1142   if (TREE_CODE (exp) == POINTER_PLUS_EXPR
1143       && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
1144       && host_integerp (TREE_OPERAND (exp, 1), 0)
1145       && (off = tree_low_cst (TREE_OPERAND (exp, 1), 0)) > 0)
1146     exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
1147   else if (TREE_CODE (exp) == ADDR_EXPR)
1148     exp = TREE_OPERAND (exp, 0);
1149   else if (POINTER_TYPE_P (TREE_TYPE (exp)))
1150     exp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (exp)), exp);
1151   else
1152     exp = NULL;
1153
1154   /* Honor attributes derived from exp, except for the alias set
1155      (as builtin stringops may alias with anything) and the size
1156      (as stringops may access multiple array elements).  */
1157   if (exp)
1158     {
1159       set_mem_attributes (mem, exp, 0);
1160
1161       if (off)
1162         mem = adjust_automodify_address_nv (mem, BLKmode, NULL, off);
1163
1164       /* Allow the string and memory builtins to overflow from one
1165          field into another, see http://gcc.gnu.org/PR23561.
1166          Thus avoid COMPONENT_REFs in MEM_EXPR unless we know the whole
1167          memory accessed by the string or memory builtin will fit
1168          within the field.  */
1169       if (MEM_EXPR (mem) && TREE_CODE (MEM_EXPR (mem)) == COMPONENT_REF)
1170         {
1171           tree mem_expr = MEM_EXPR (mem);
1172           HOST_WIDE_INT offset = -1, length = -1;
1173           tree inner = exp;
1174
1175           while (TREE_CODE (inner) == ARRAY_REF
1176                  || CONVERT_EXPR_P (inner)
1177                  || TREE_CODE (inner) == VIEW_CONVERT_EXPR
1178                  || TREE_CODE (inner) == SAVE_EXPR)
1179             inner = TREE_OPERAND (inner, 0);
1180
1181           gcc_assert (TREE_CODE (inner) == COMPONENT_REF);
1182
1183           if (MEM_OFFSET (mem)
1184               && CONST_INT_P (MEM_OFFSET (mem)))
1185             offset = INTVAL (MEM_OFFSET (mem));
1186
1187           if (offset >= 0 && len && host_integerp (len, 0))
1188             length = tree_low_cst (len, 0);
1189
1190           while (TREE_CODE (inner) == COMPONENT_REF)
1191             {
1192               tree field = TREE_OPERAND (inner, 1);
1193               gcc_assert (TREE_CODE (mem_expr) == COMPONENT_REF);
1194               gcc_assert (field == TREE_OPERAND (mem_expr, 1));
1195
1196               /* Bitfields are generally not byte-addressable.  */
1197               gcc_assert (!DECL_BIT_FIELD (field)
1198                           || ((tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1199                                % BITS_PER_UNIT) == 0
1200                               && host_integerp (DECL_SIZE (field), 0)
1201                               && (TREE_INT_CST_LOW (DECL_SIZE (field))
1202                                   % BITS_PER_UNIT) == 0));
1203
1204               /* If we can prove that the memory starting at XEXP (mem, 0) and
1205                  ending at XEXP (mem, 0) + LENGTH will fit into this field, we
1206                  can keep the COMPONENT_REF in MEM_EXPR.  But be careful with
1207                  fields without DECL_SIZE_UNIT like flexible array members.  */
1208               if (length >= 0
1209                   && DECL_SIZE_UNIT (field)
1210                   && host_integerp (DECL_SIZE_UNIT (field), 0))
1211                 {
1212                   HOST_WIDE_INT size
1213                     = TREE_INT_CST_LOW (DECL_SIZE_UNIT (field));
1214                   if (offset <= size
1215                       && length <= size
1216                       && offset + length <= size)
1217                     break;
1218                 }
1219
1220               if (offset >= 0
1221                   && host_integerp (DECL_FIELD_OFFSET (field), 0))
1222                 offset += TREE_INT_CST_LOW (DECL_FIELD_OFFSET (field))
1223                           + tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1224                             / BITS_PER_UNIT;
1225               else
1226                 {
1227                   offset = -1;
1228                   length = -1;
1229                 }
1230
1231               mem_expr = TREE_OPERAND (mem_expr, 0);
1232               inner = TREE_OPERAND (inner, 0);
1233             }
1234
1235           if (mem_expr == NULL)
1236             offset = -1;
1237           if (mem_expr != MEM_EXPR (mem))
1238             {
1239               set_mem_expr (mem, mem_expr);
1240               set_mem_offset (mem, offset >= 0 ? GEN_INT (offset) : NULL_RTX);
1241             }
1242         }
1243       set_mem_alias_set (mem, 0);
1244       set_mem_size (mem, NULL_RTX);
1245     }
1246
1247   return mem;
1248 }
1249 \f
1250 /* Built-in functions to perform an untyped call and return.  */
1251
1252 /* For each register that may be used for calling a function, this
1253    gives a mode used to copy the register's value.  VOIDmode indicates
1254    the register is not used for calling a function.  If the machine
1255    has register windows, this gives only the outbound registers.
1256    INCOMING_REGNO gives the corresponding inbound register.  */
1257 static enum machine_mode apply_args_mode[FIRST_PSEUDO_REGISTER];
1258
1259 /* For each register that may be used for returning values, this gives
1260    a mode used to copy the register's value.  VOIDmode indicates the
1261    register is not used for returning values.  If the machine has
1262    register windows, this gives only the outbound registers.
1263    INCOMING_REGNO gives the corresponding inbound register.  */
1264 static enum machine_mode apply_result_mode[FIRST_PSEUDO_REGISTER];
1265
1266 /* Return the size required for the block returned by __builtin_apply_args,
1267    and initialize apply_args_mode.  */
1268
1269 static int
1270 apply_args_size (void)
1271 {
1272   static int size = -1;
1273   int align;
1274   unsigned int regno;
1275   enum machine_mode mode;
1276
1277   /* The values computed by this function never change.  */
1278   if (size < 0)
1279     {
1280       /* The first value is the incoming arg-pointer.  */
1281       size = GET_MODE_SIZE (Pmode);
1282
1283       /* The second value is the structure value address unless this is
1284          passed as an "invisible" first argument.  */
1285       if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1286         size += GET_MODE_SIZE (Pmode);
1287
1288       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1289         if (FUNCTION_ARG_REGNO_P (regno))
1290           {
1291             mode = reg_raw_mode[regno];
1292
1293             gcc_assert (mode != VOIDmode);
1294
1295             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1296             if (size % align != 0)
1297               size = CEIL (size, align) * align;
1298             size += GET_MODE_SIZE (mode);
1299             apply_args_mode[regno] = mode;
1300           }
1301         else
1302           {
1303             apply_args_mode[regno] = VOIDmode;
1304           }
1305     }
1306   return size;
1307 }
1308
1309 /* Return the size required for the block returned by __builtin_apply,
1310    and initialize apply_result_mode.  */
1311
1312 static int
1313 apply_result_size (void)
1314 {
1315   static int size = -1;
1316   int align, regno;
1317   enum machine_mode mode;
1318
1319   /* The values computed by this function never change.  */
1320   if (size < 0)
1321     {
1322       size = 0;
1323
1324       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1325         if (FUNCTION_VALUE_REGNO_P (regno))
1326           {
1327             mode = reg_raw_mode[regno];
1328
1329             gcc_assert (mode != VOIDmode);
1330
1331             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1332             if (size % align != 0)
1333               size = CEIL (size, align) * align;
1334             size += GET_MODE_SIZE (mode);
1335             apply_result_mode[regno] = mode;
1336           }
1337         else
1338           apply_result_mode[regno] = VOIDmode;
1339
1340       /* Allow targets that use untyped_call and untyped_return to override
1341          the size so that machine-specific information can be stored here.  */
1342 #ifdef APPLY_RESULT_SIZE
1343       size = APPLY_RESULT_SIZE;
1344 #endif
1345     }
1346   return size;
1347 }
1348
1349 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1350 /* Create a vector describing the result block RESULT.  If SAVEP is true,
1351    the result block is used to save the values; otherwise it is used to
1352    restore the values.  */
1353
1354 static rtx
1355 result_vector (int savep, rtx result)
1356 {
1357   int regno, size, align, nelts;
1358   enum machine_mode mode;
1359   rtx reg, mem;
1360   rtx *savevec = XALLOCAVEC (rtx, FIRST_PSEUDO_REGISTER);
1361
1362   size = nelts = 0;
1363   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1364     if ((mode = apply_result_mode[regno]) != VOIDmode)
1365       {
1366         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1367         if (size % align != 0)
1368           size = CEIL (size, align) * align;
1369         reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1370         mem = adjust_address (result, mode, size);
1371         savevec[nelts++] = (savep
1372                             ? gen_rtx_SET (VOIDmode, mem, reg)
1373                             : gen_rtx_SET (VOIDmode, reg, mem));
1374         size += GET_MODE_SIZE (mode);
1375       }
1376   return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1377 }
1378 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1379
1380 /* Save the state required to perform an untyped call with the same
1381    arguments as were passed to the current function.  */
1382
1383 static rtx
1384 expand_builtin_apply_args_1 (void)
1385 {
1386   rtx registers, tem;
1387   int size, align, regno;
1388   enum machine_mode mode;
1389   rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1390
1391   /* Create a block where the arg-pointer, structure value address,
1392      and argument registers can be saved.  */
1393   registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1394
1395   /* Walk past the arg-pointer and structure value address.  */
1396   size = GET_MODE_SIZE (Pmode);
1397   if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1398     size += GET_MODE_SIZE (Pmode);
1399
1400   /* Save each register used in calling a function to the block.  */
1401   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1402     if ((mode = apply_args_mode[regno]) != VOIDmode)
1403       {
1404         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1405         if (size % align != 0)
1406           size = CEIL (size, align) * align;
1407
1408         tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1409
1410         emit_move_insn (adjust_address (registers, mode, size), tem);
1411         size += GET_MODE_SIZE (mode);
1412       }
1413
1414   /* Save the arg pointer to the block.  */
1415   tem = copy_to_reg (crtl->args.internal_arg_pointer);
1416 #ifdef STACK_GROWS_DOWNWARD
1417   /* We need the pointer as the caller actually passed them to us, not
1418      as we might have pretended they were passed.  Make sure it's a valid
1419      operand, as emit_move_insn isn't expected to handle a PLUS.  */
1420   tem
1421     = force_operand (plus_constant (tem, crtl->args.pretend_args_size),
1422                      NULL_RTX);
1423 #endif
1424   emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1425
1426   size = GET_MODE_SIZE (Pmode);
1427
1428   /* Save the structure value address unless this is passed as an
1429      "invisible" first argument.  */
1430   if (struct_incoming_value)
1431     {
1432       emit_move_insn (adjust_address (registers, Pmode, size),
1433                       copy_to_reg (struct_incoming_value));
1434       size += GET_MODE_SIZE (Pmode);
1435     }
1436
1437   /* Return the address of the block.  */
1438   return copy_addr_to_reg (XEXP (registers, 0));
1439 }
1440
1441 /* __builtin_apply_args returns block of memory allocated on
1442    the stack into which is stored the arg pointer, structure
1443    value address, static chain, and all the registers that might
1444    possibly be used in performing a function call.  The code is
1445    moved to the start of the function so the incoming values are
1446    saved.  */
1447
1448 static rtx
1449 expand_builtin_apply_args (void)
1450 {
1451   /* Don't do __builtin_apply_args more than once in a function.
1452      Save the result of the first call and reuse it.  */
1453   if (apply_args_value != 0)
1454     return apply_args_value;
1455   {
1456     /* When this function is called, it means that registers must be
1457        saved on entry to this function.  So we migrate the
1458        call to the first insn of this function.  */
1459     rtx temp;
1460     rtx seq;
1461
1462     start_sequence ();
1463     temp = expand_builtin_apply_args_1 ();
1464     seq = get_insns ();
1465     end_sequence ();
1466
1467     apply_args_value = temp;
1468
1469     /* Put the insns after the NOTE that starts the function.
1470        If this is inside a start_sequence, make the outer-level insn
1471        chain current, so the code is placed at the start of the
1472        function.  If internal_arg_pointer is a non-virtual pseudo,
1473        it needs to be placed after the function that initializes
1474        that pseudo.  */
1475     push_topmost_sequence ();
1476     if (REG_P (crtl->args.internal_arg_pointer)
1477         && REGNO (crtl->args.internal_arg_pointer) > LAST_VIRTUAL_REGISTER)
1478       emit_insn_before (seq, parm_birth_insn);
1479     else
1480       emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
1481     pop_topmost_sequence ();
1482     return temp;
1483   }
1484 }
1485
1486 /* Perform an untyped call and save the state required to perform an
1487    untyped return of whatever value was returned by the given function.  */
1488
1489 static rtx
1490 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1491 {
1492   int size, align, regno;
1493   enum machine_mode mode;
1494   rtx incoming_args, result, reg, dest, src, call_insn;
1495   rtx old_stack_level = 0;
1496   rtx call_fusage = 0;
1497   rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1498
1499   arguments = convert_memory_address (Pmode, arguments);
1500
1501   /* Create a block where the return registers can be saved.  */
1502   result = assign_stack_local (BLKmode, apply_result_size (), -1);
1503
1504   /* Fetch the arg pointer from the ARGUMENTS block.  */
1505   incoming_args = gen_reg_rtx (Pmode);
1506   emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1507 #ifndef STACK_GROWS_DOWNWARD
1508   incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1509                                        incoming_args, 0, OPTAB_LIB_WIDEN);
1510 #endif
1511
1512   /* Push a new argument block and copy the arguments.  Do not allow
1513      the (potential) memcpy call below to interfere with our stack
1514      manipulations.  */
1515   do_pending_stack_adjust ();
1516   NO_DEFER_POP;
1517
1518   /* Save the stack with nonlocal if available.  */
1519 #ifdef HAVE_save_stack_nonlocal
1520   if (HAVE_save_stack_nonlocal)
1521     emit_stack_save (SAVE_NONLOCAL, &old_stack_level, NULL_RTX);
1522   else
1523 #endif
1524     emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1525
1526   /* Allocate a block of memory onto the stack and copy the memory
1527      arguments to the outgoing arguments address.  */
1528   allocate_dynamic_stack_space (argsize, 0, BITS_PER_UNIT);
1529
1530   /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1531      may have already set current_function_calls_alloca to true.
1532      current_function_calls_alloca won't be set if argsize is zero,
1533      so we have to guarantee need_drap is true here.  */
1534   if (SUPPORTS_STACK_ALIGNMENT)
1535     crtl->need_drap = true;
1536
1537   dest = virtual_outgoing_args_rtx;
1538 #ifndef STACK_GROWS_DOWNWARD
1539   if (CONST_INT_P (argsize))
1540     dest = plus_constant (dest, -INTVAL (argsize));
1541   else
1542     dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1543 #endif
1544   dest = gen_rtx_MEM (BLKmode, dest);
1545   set_mem_align (dest, PARM_BOUNDARY);
1546   src = gen_rtx_MEM (BLKmode, incoming_args);
1547   set_mem_align (src, PARM_BOUNDARY);
1548   emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1549
1550   /* Refer to the argument block.  */
1551   apply_args_size ();
1552   arguments = gen_rtx_MEM (BLKmode, arguments);
1553   set_mem_align (arguments, PARM_BOUNDARY);
1554
1555   /* Walk past the arg-pointer and structure value address.  */
1556   size = GET_MODE_SIZE (Pmode);
1557   if (struct_value)
1558     size += GET_MODE_SIZE (Pmode);
1559
1560   /* Restore each of the registers previously saved.  Make USE insns
1561      for each of these registers for use in making the call.  */
1562   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1563     if ((mode = apply_args_mode[regno]) != VOIDmode)
1564       {
1565         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1566         if (size % align != 0)
1567           size = CEIL (size, align) * align;
1568         reg = gen_rtx_REG (mode, regno);
1569         emit_move_insn (reg, adjust_address (arguments, mode, size));
1570         use_reg (&call_fusage, reg);
1571         size += GET_MODE_SIZE (mode);
1572       }
1573
1574   /* Restore the structure value address unless this is passed as an
1575      "invisible" first argument.  */
1576   size = GET_MODE_SIZE (Pmode);
1577   if (struct_value)
1578     {
1579       rtx value = gen_reg_rtx (Pmode);
1580       emit_move_insn (value, adjust_address (arguments, Pmode, size));
1581       emit_move_insn (struct_value, value);
1582       if (REG_P (struct_value))
1583         use_reg (&call_fusage, struct_value);
1584       size += GET_MODE_SIZE (Pmode);
1585     }
1586
1587   /* All arguments and registers used for the call are set up by now!  */
1588   function = prepare_call_address (NULL, function, NULL, &call_fusage, 0, 0);
1589
1590   /* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
1591      and we don't want to load it into a register as an optimization,
1592      because prepare_call_address already did it if it should be done.  */
1593   if (GET_CODE (function) != SYMBOL_REF)
1594     function = memory_address (FUNCTION_MODE, function);
1595
1596   /* Generate the actual call instruction and save the return value.  */
1597 #ifdef HAVE_untyped_call
1598   if (HAVE_untyped_call)
1599     emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
1600                                       result, result_vector (1, result)));
1601   else
1602 #endif
1603 #ifdef HAVE_call_value
1604   if (HAVE_call_value)
1605     {
1606       rtx valreg = 0;
1607
1608       /* Locate the unique return register.  It is not possible to
1609          express a call that sets more than one return register using
1610          call_value; use untyped_call for that.  In fact, untyped_call
1611          only needs to save the return registers in the given block.  */
1612       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1613         if ((mode = apply_result_mode[regno]) != VOIDmode)
1614           {
1615             gcc_assert (!valreg); /* HAVE_untyped_call required.  */
1616
1617             valreg = gen_rtx_REG (mode, regno);
1618           }
1619
1620       emit_call_insn (GEN_CALL_VALUE (valreg,
1621                                       gen_rtx_MEM (FUNCTION_MODE, function),
1622                                       const0_rtx, NULL_RTX, const0_rtx));
1623
1624       emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1625     }
1626   else
1627 #endif
1628     gcc_unreachable ();
1629
1630   /* Find the CALL insn we just emitted, and attach the register usage
1631      information.  */
1632   call_insn = last_call_insn ();
1633   add_function_usage_to (call_insn, call_fusage);
1634
1635   /* Restore the stack.  */
1636 #ifdef HAVE_save_stack_nonlocal
1637   if (HAVE_save_stack_nonlocal)
1638     emit_stack_restore (SAVE_NONLOCAL, old_stack_level, NULL_RTX);
1639   else
1640 #endif
1641     emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1642
1643   OK_DEFER_POP;
1644
1645   /* Return the address of the result block.  */
1646   result = copy_addr_to_reg (XEXP (result, 0));
1647   return convert_memory_address (ptr_mode, result);
1648 }
1649
1650 /* Perform an untyped return.  */
1651
1652 static void
1653 expand_builtin_return (rtx result)
1654 {
1655   int size, align, regno;
1656   enum machine_mode mode;
1657   rtx reg;
1658   rtx call_fusage = 0;
1659
1660   result = convert_memory_address (Pmode, result);
1661
1662   apply_result_size ();
1663   result = gen_rtx_MEM (BLKmode, result);
1664
1665 #ifdef HAVE_untyped_return
1666   if (HAVE_untyped_return)
1667     {
1668       emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1669       emit_barrier ();
1670       return;
1671     }
1672 #endif
1673
1674   /* Restore the return value and note that each value is used.  */
1675   size = 0;
1676   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1677     if ((mode = apply_result_mode[regno]) != VOIDmode)
1678       {
1679         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1680         if (size % align != 0)
1681           size = CEIL (size, align) * align;
1682         reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1683         emit_move_insn (reg, adjust_address (result, mode, size));
1684
1685         push_to_sequence (call_fusage);
1686         emit_use (reg);
1687         call_fusage = get_insns ();
1688         end_sequence ();
1689         size += GET_MODE_SIZE (mode);
1690       }
1691
1692   /* Put the USE insns before the return.  */
1693   emit_insn (call_fusage);
1694
1695   /* Return whatever values was restored by jumping directly to the end
1696      of the function.  */
1697   expand_naked_return ();
1698 }
1699
1700 /* Used by expand_builtin_classify_type and fold_builtin_classify_type.  */
1701
1702 static enum type_class
1703 type_to_class (tree type)
1704 {
1705   switch (TREE_CODE (type))
1706     {
1707     case VOID_TYPE:        return void_type_class;
1708     case INTEGER_TYPE:     return integer_type_class;
1709     case ENUMERAL_TYPE:    return enumeral_type_class;
1710     case BOOLEAN_TYPE:     return boolean_type_class;
1711     case POINTER_TYPE:     return pointer_type_class;
1712     case REFERENCE_TYPE:   return reference_type_class;
1713     case OFFSET_TYPE:      return offset_type_class;
1714     case REAL_TYPE:        return real_type_class;
1715     case COMPLEX_TYPE:     return complex_type_class;
1716     case FUNCTION_TYPE:    return function_type_class;
1717     case METHOD_TYPE:      return method_type_class;
1718     case RECORD_TYPE:      return record_type_class;
1719     case UNION_TYPE:
1720     case QUAL_UNION_TYPE:  return union_type_class;
1721     case ARRAY_TYPE:       return (TYPE_STRING_FLAG (type)
1722                                    ? string_type_class : array_type_class);
1723     case LANG_TYPE:        return lang_type_class;
1724     default:               return no_type_class;
1725     }
1726 }
1727
1728 /* Expand a call EXP to __builtin_classify_type.  */
1729
1730 static rtx
1731 expand_builtin_classify_type (tree exp)
1732 {
1733   if (call_expr_nargs (exp))
1734     return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp, 0))));
1735   return GEN_INT (no_type_class);
1736 }
1737
1738 /* This helper macro, meant to be used in mathfn_built_in below,
1739    determines which among a set of three builtin math functions is
1740    appropriate for a given type mode.  The `F' and `L' cases are
1741    automatically generated from the `double' case.  */
1742 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1743   case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1744   fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1745   fcodel = BUILT_IN_MATHFN##L ; break;
1746 /* Similar to above, but appends _R after any F/L suffix.  */
1747 #define CASE_MATHFN_REENT(BUILT_IN_MATHFN) \
1748   case BUILT_IN_MATHFN##_R: case BUILT_IN_MATHFN##F_R: case BUILT_IN_MATHFN##L_R: \
1749   fcode = BUILT_IN_MATHFN##_R; fcodef = BUILT_IN_MATHFN##F_R ; \
1750   fcodel = BUILT_IN_MATHFN##L_R ; break;
1751
1752 /* Return mathematic function equivalent to FN but operating directly
1753    on TYPE, if available.  If IMPLICIT is true find the function in
1754    implicit_built_in_decls[], otherwise use built_in_decls[].  If we
1755    can't do the conversion, return zero.  */
1756
1757 static tree
1758 mathfn_built_in_1 (tree type, enum built_in_function fn, bool implicit)
1759 {
1760   tree const *const fn_arr
1761     = implicit ? implicit_built_in_decls : built_in_decls;
1762   enum built_in_function fcode, fcodef, fcodel;
1763
1764   switch (fn)
1765     {
1766       CASE_MATHFN (BUILT_IN_ACOS)
1767       CASE_MATHFN (BUILT_IN_ACOSH)
1768       CASE_MATHFN (BUILT_IN_ASIN)
1769       CASE_MATHFN (BUILT_IN_ASINH)
1770       CASE_MATHFN (BUILT_IN_ATAN)
1771       CASE_MATHFN (BUILT_IN_ATAN2)
1772       CASE_MATHFN (BUILT_IN_ATANH)
1773       CASE_MATHFN (BUILT_IN_CBRT)
1774       CASE_MATHFN (BUILT_IN_CEIL)
1775       CASE_MATHFN (BUILT_IN_CEXPI)
1776       CASE_MATHFN (BUILT_IN_COPYSIGN)
1777       CASE_MATHFN (BUILT_IN_COS)
1778       CASE_MATHFN (BUILT_IN_COSH)
1779       CASE_MATHFN (BUILT_IN_DREM)
1780       CASE_MATHFN (BUILT_IN_ERF)
1781       CASE_MATHFN (BUILT_IN_ERFC)
1782       CASE_MATHFN (BUILT_IN_EXP)
1783       CASE_MATHFN (BUILT_IN_EXP10)
1784       CASE_MATHFN (BUILT_IN_EXP2)
1785       CASE_MATHFN (BUILT_IN_EXPM1)
1786       CASE_MATHFN (BUILT_IN_FABS)
1787       CASE_MATHFN (BUILT_IN_FDIM)
1788       CASE_MATHFN (BUILT_IN_FLOOR)
1789       CASE_MATHFN (BUILT_IN_FMA)
1790       CASE_MATHFN (BUILT_IN_FMAX)
1791       CASE_MATHFN (BUILT_IN_FMIN)
1792       CASE_MATHFN (BUILT_IN_FMOD)
1793       CASE_MATHFN (BUILT_IN_FREXP)
1794       CASE_MATHFN (BUILT_IN_GAMMA)
1795       CASE_MATHFN_REENT (BUILT_IN_GAMMA) /* GAMMA_R */
1796       CASE_MATHFN (BUILT_IN_HUGE_VAL)
1797       CASE_MATHFN (BUILT_IN_HYPOT)
1798       CASE_MATHFN (BUILT_IN_ILOGB)
1799       CASE_MATHFN (BUILT_IN_INF)
1800       CASE_MATHFN (BUILT_IN_ISINF)
1801       CASE_MATHFN (BUILT_IN_J0)
1802       CASE_MATHFN (BUILT_IN_J1)
1803       CASE_MATHFN (BUILT_IN_JN)
1804       CASE_MATHFN (BUILT_IN_LCEIL)
1805       CASE_MATHFN (BUILT_IN_LDEXP)
1806       CASE_MATHFN (BUILT_IN_LFLOOR)
1807       CASE_MATHFN (BUILT_IN_LGAMMA)
1808       CASE_MATHFN_REENT (BUILT_IN_LGAMMA) /* LGAMMA_R */
1809       CASE_MATHFN (BUILT_IN_LLCEIL)
1810       CASE_MATHFN (BUILT_IN_LLFLOOR)
1811       CASE_MATHFN (BUILT_IN_LLRINT)
1812       CASE_MATHFN (BUILT_IN_LLROUND)
1813       CASE_MATHFN (BUILT_IN_LOG)
1814       CASE_MATHFN (BUILT_IN_LOG10)
1815       CASE_MATHFN (BUILT_IN_LOG1P)
1816       CASE_MATHFN (BUILT_IN_LOG2)
1817       CASE_MATHFN (BUILT_IN_LOGB)
1818       CASE_MATHFN (BUILT_IN_LRINT)
1819       CASE_MATHFN (BUILT_IN_LROUND)
1820       CASE_MATHFN (BUILT_IN_MODF)
1821       CASE_MATHFN (BUILT_IN_NAN)
1822       CASE_MATHFN (BUILT_IN_NANS)
1823       CASE_MATHFN (BUILT_IN_NEARBYINT)
1824       CASE_MATHFN (BUILT_IN_NEXTAFTER)
1825       CASE_MATHFN (BUILT_IN_NEXTTOWARD)
1826       CASE_MATHFN (BUILT_IN_POW)
1827       CASE_MATHFN (BUILT_IN_POWI)
1828       CASE_MATHFN (BUILT_IN_POW10)
1829       CASE_MATHFN (BUILT_IN_REMAINDER)
1830       CASE_MATHFN (BUILT_IN_REMQUO)
1831       CASE_MATHFN (BUILT_IN_RINT)
1832       CASE_MATHFN (BUILT_IN_ROUND)
1833       CASE_MATHFN (BUILT_IN_SCALB)
1834       CASE_MATHFN (BUILT_IN_SCALBLN)
1835       CASE_MATHFN (BUILT_IN_SCALBN)
1836       CASE_MATHFN (BUILT_IN_SIGNBIT)
1837       CASE_MATHFN (BUILT_IN_SIGNIFICAND)
1838       CASE_MATHFN (BUILT_IN_SIN)
1839       CASE_MATHFN (BUILT_IN_SINCOS)
1840       CASE_MATHFN (BUILT_IN_SINH)
1841       CASE_MATHFN (BUILT_IN_SQRT)
1842       CASE_MATHFN (BUILT_IN_TAN)
1843       CASE_MATHFN (BUILT_IN_TANH)
1844       CASE_MATHFN (BUILT_IN_TGAMMA)
1845       CASE_MATHFN (BUILT_IN_TRUNC)
1846       CASE_MATHFN (BUILT_IN_Y0)
1847       CASE_MATHFN (BUILT_IN_Y1)
1848       CASE_MATHFN (BUILT_IN_YN)
1849
1850       default:
1851         return NULL_TREE;
1852       }
1853
1854   if (TYPE_MAIN_VARIANT (type) == double_type_node)
1855     return fn_arr[fcode];
1856   else if (TYPE_MAIN_VARIANT (type) == float_type_node)
1857     return fn_arr[fcodef];
1858   else if (TYPE_MAIN_VARIANT (type) == long_double_type_node)
1859     return fn_arr[fcodel];
1860   else
1861     return NULL_TREE;
1862 }
1863
1864 /* Like mathfn_built_in_1(), but always use the implicit array.  */
1865
1866 tree
1867 mathfn_built_in (tree type, enum built_in_function fn)
1868 {
1869   return mathfn_built_in_1 (type, fn, /*implicit=*/ 1);
1870 }
1871
1872 /* If errno must be maintained, expand the RTL to check if the result,
1873    TARGET, of a built-in function call, EXP, is NaN, and if so set
1874    errno to EDOM.  */
1875
1876 static void
1877 expand_errno_check (tree exp, rtx target)
1878 {
1879   rtx lab = gen_label_rtx ();
1880
1881   /* Test the result; if it is NaN, set errno=EDOM because
1882      the argument was not in the domain.  */
1883   do_compare_rtx_and_jump (target, target, EQ, 0, GET_MODE (target),
1884                            NULL_RTX, NULL_RTX, lab,
1885                            /* The jump is very likely.  */
1886                            REG_BR_PROB_BASE - (REG_BR_PROB_BASE / 2000 - 1));
1887
1888 #ifdef TARGET_EDOM
1889   /* If this built-in doesn't throw an exception, set errno directly.  */
1890   if (TREE_NOTHROW (TREE_OPERAND (CALL_EXPR_FN (exp), 0)))
1891     {
1892 #ifdef GEN_ERRNO_RTX
1893       rtx errno_rtx = GEN_ERRNO_RTX;
1894 #else
1895       rtx errno_rtx
1896           = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1897 #endif
1898       emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1899       emit_label (lab);
1900       return;
1901     }
1902 #endif
1903
1904   /* Make sure the library call isn't expanded as a tail call.  */
1905   CALL_EXPR_TAILCALL (exp) = 0;
1906
1907   /* We can't set errno=EDOM directly; let the library call do it.
1908      Pop the arguments right away in case the call gets deleted.  */
1909   NO_DEFER_POP;
1910   expand_call (exp, target, 0);
1911   OK_DEFER_POP;
1912   emit_label (lab);
1913 }
1914
1915 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1916    Return NULL_RTX if a normal call should be emitted rather than expanding
1917    the function in-line.  EXP is the expression that is a call to the builtin
1918    function; if convenient, the result should be placed in TARGET.
1919    SUBTARGET may be used as the target for computing one of EXP's operands.  */
1920
1921 static rtx
1922 expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
1923 {
1924   optab builtin_optab;
1925   rtx op0, insns;
1926   tree fndecl = get_callee_fndecl (exp);
1927   enum machine_mode mode;
1928   bool errno_set = false;
1929   tree arg;
1930
1931   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
1932     return NULL_RTX;
1933
1934   arg = CALL_EXPR_ARG (exp, 0);
1935
1936   switch (DECL_FUNCTION_CODE (fndecl))
1937     {
1938     CASE_FLT_FN (BUILT_IN_SQRT):
1939       errno_set = ! tree_expr_nonnegative_p (arg);
1940       builtin_optab = sqrt_optab;
1941       break;
1942     CASE_FLT_FN (BUILT_IN_EXP):
1943       errno_set = true; builtin_optab = exp_optab; break;
1944     CASE_FLT_FN (BUILT_IN_EXP10):
1945     CASE_FLT_FN (BUILT_IN_POW10):
1946       errno_set = true; builtin_optab = exp10_optab; break;
1947     CASE_FLT_FN (BUILT_IN_EXP2):
1948       errno_set = true; builtin_optab = exp2_optab; break;
1949     CASE_FLT_FN (BUILT_IN_EXPM1):
1950       errno_set = true; builtin_optab = expm1_optab; break;
1951     CASE_FLT_FN (BUILT_IN_LOGB):
1952       errno_set = true; builtin_optab = logb_optab; break;
1953     CASE_FLT_FN (BUILT_IN_LOG):
1954       errno_set = true; builtin_optab = log_optab; break;
1955     CASE_FLT_FN (BUILT_IN_LOG10):
1956       errno_set = true; builtin_optab = log10_optab; break;
1957     CASE_FLT_FN (BUILT_IN_LOG2):
1958       errno_set = true; builtin_optab = log2_optab; break;
1959     CASE_FLT_FN (BUILT_IN_LOG1P):
1960       errno_set = true; builtin_optab = log1p_optab; break;
1961     CASE_FLT_FN (BUILT_IN_ASIN):
1962       builtin_optab = asin_optab; break;
1963     CASE_FLT_FN (BUILT_IN_ACOS):
1964       builtin_optab = acos_optab; break;
1965     CASE_FLT_FN (BUILT_IN_TAN):
1966       builtin_optab = tan_optab; break;
1967     CASE_FLT_FN (BUILT_IN_ATAN):
1968       builtin_optab = atan_optab; break;
1969     CASE_FLT_FN (BUILT_IN_FLOOR):
1970       builtin_optab = floor_optab; break;
1971     CASE_FLT_FN (BUILT_IN_CEIL):
1972       builtin_optab = ceil_optab; break;
1973     CASE_FLT_FN (BUILT_IN_TRUNC):
1974       builtin_optab = btrunc_optab; break;
1975     CASE_FLT_FN (BUILT_IN_ROUND):
1976       builtin_optab = round_optab; break;
1977     CASE_FLT_FN (BUILT_IN_NEARBYINT):
1978       builtin_optab = nearbyint_optab;
1979       if (flag_trapping_math)
1980         break;
1981       /* Else fallthrough and expand as rint.  */
1982     CASE_FLT_FN (BUILT_IN_RINT):
1983       builtin_optab = rint_optab; break;
1984     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
1985       builtin_optab = significand_optab; break;
1986     default:
1987       gcc_unreachable ();
1988     }
1989
1990   /* Make a suitable register to place result in.  */
1991   mode = TYPE_MODE (TREE_TYPE (exp));
1992
1993   if (! flag_errno_math || ! HONOR_NANS (mode))
1994     errno_set = false;
1995
1996   /* Before working hard, check whether the instruction is available.  */
1997   if (optab_handler (builtin_optab, mode)->insn_code != CODE_FOR_nothing)
1998     {
1999       target = gen_reg_rtx (mode);
2000
2001       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2002          need to expand the argument again.  This way, we will not perform
2003          side-effects more the once.  */
2004       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2005
2006       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2007
2008       start_sequence ();
2009
2010       /* Compute into TARGET.
2011          Set TARGET to wherever the result comes back.  */
2012       target = expand_unop (mode, builtin_optab, op0, target, 0);
2013
2014       if (target != 0)
2015         {
2016           if (errno_set)
2017             expand_errno_check (exp, target);
2018
2019           /* Output the entire sequence.  */
2020           insns = get_insns ();
2021           end_sequence ();
2022           emit_insn (insns);
2023           return target;
2024         }
2025
2026       /* If we were unable to expand via the builtin, stop the sequence
2027          (without outputting the insns) and call to the library function
2028          with the stabilized argument list.  */
2029       end_sequence ();
2030     }
2031
2032   return expand_call (exp, target, target == const0_rtx);
2033 }
2034
2035 /* Expand a call to the builtin binary math functions (pow and atan2).
2036    Return NULL_RTX if a normal call should be emitted rather than expanding the
2037    function in-line.  EXP is the expression that is a call to the builtin
2038    function; if convenient, the result should be placed in TARGET.
2039    SUBTARGET may be used as the target for computing one of EXP's
2040    operands.  */
2041
2042 static rtx
2043 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
2044 {
2045   optab builtin_optab;
2046   rtx op0, op1, insns;
2047   int op1_type = REAL_TYPE;
2048   tree fndecl = get_callee_fndecl (exp);
2049   tree arg0, arg1;
2050   enum machine_mode mode;
2051   bool errno_set = true;
2052
2053   switch (DECL_FUNCTION_CODE (fndecl))
2054     {
2055     CASE_FLT_FN (BUILT_IN_SCALBN):
2056     CASE_FLT_FN (BUILT_IN_SCALBLN):
2057     CASE_FLT_FN (BUILT_IN_LDEXP):
2058       op1_type = INTEGER_TYPE;
2059     default:
2060       break;
2061     }
2062
2063   if (!validate_arglist (exp, REAL_TYPE, op1_type, VOID_TYPE))
2064     return NULL_RTX;
2065
2066   arg0 = CALL_EXPR_ARG (exp, 0);
2067   arg1 = CALL_EXPR_ARG (exp, 1);
2068
2069   switch (DECL_FUNCTION_CODE (fndecl))
2070     {
2071     CASE_FLT_FN (BUILT_IN_POW):
2072       builtin_optab = pow_optab; break;
2073     CASE_FLT_FN (BUILT_IN_ATAN2):
2074       builtin_optab = atan2_optab; break;
2075     CASE_FLT_FN (BUILT_IN_SCALB):
2076       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2077         return 0;
2078       builtin_optab = scalb_optab; break;
2079     CASE_FLT_FN (BUILT_IN_SCALBN):
2080     CASE_FLT_FN (BUILT_IN_SCALBLN):
2081       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2082         return 0;
2083     /* Fall through... */
2084     CASE_FLT_FN (BUILT_IN_LDEXP):
2085       builtin_optab = ldexp_optab; break;
2086     CASE_FLT_FN (BUILT_IN_FMOD):
2087       builtin_optab = fmod_optab; break;
2088     CASE_FLT_FN (BUILT_IN_REMAINDER):
2089     CASE_FLT_FN (BUILT_IN_DREM):
2090       builtin_optab = remainder_optab; break;
2091     default:
2092       gcc_unreachable ();
2093     }
2094
2095   /* Make a suitable register to place result in.  */
2096   mode = TYPE_MODE (TREE_TYPE (exp));
2097
2098   /* Before working hard, check whether the instruction is available.  */
2099   if (optab_handler (builtin_optab, mode)->insn_code == CODE_FOR_nothing)
2100     return NULL_RTX;
2101
2102   target = gen_reg_rtx (mode);
2103
2104   if (! flag_errno_math || ! HONOR_NANS (mode))
2105     errno_set = false;
2106
2107   /* Always stabilize the argument list.  */
2108   CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2109   CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2110
2111   op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2112   op1 = expand_normal (arg1);
2113
2114   start_sequence ();
2115
2116   /* Compute into TARGET.
2117      Set TARGET to wherever the result comes back.  */
2118   target = expand_binop (mode, builtin_optab, op0, op1,
2119                          target, 0, OPTAB_DIRECT);
2120
2121   /* If we were unable to expand via the builtin, stop the sequence
2122      (without outputting the insns) and call to the library function
2123      with the stabilized argument list.  */
2124   if (target == 0)
2125     {
2126       end_sequence ();
2127       return expand_call (exp, target, target == const0_rtx);
2128     }
2129
2130   if (errno_set)
2131     expand_errno_check (exp, target);
2132
2133   /* Output the entire sequence.  */
2134   insns = get_insns ();
2135   end_sequence ();
2136   emit_insn (insns);
2137
2138   return target;
2139 }
2140
2141 /* Expand a call to the builtin sin and cos math functions.
2142    Return NULL_RTX if a normal call should be emitted rather than expanding the
2143    function in-line.  EXP is the expression that is a call to the builtin
2144    function; if convenient, the result should be placed in TARGET.
2145    SUBTARGET may be used as the target for computing one of EXP's
2146    operands.  */
2147
2148 static rtx
2149 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2150 {
2151   optab builtin_optab;
2152   rtx op0, insns;
2153   tree fndecl = get_callee_fndecl (exp);
2154   enum machine_mode mode;
2155   tree arg;
2156
2157   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2158     return NULL_RTX;
2159
2160   arg = CALL_EXPR_ARG (exp, 0);
2161
2162   switch (DECL_FUNCTION_CODE (fndecl))
2163     {
2164     CASE_FLT_FN (BUILT_IN_SIN):
2165     CASE_FLT_FN (BUILT_IN_COS):
2166       builtin_optab = sincos_optab; break;
2167     default:
2168       gcc_unreachable ();
2169     }
2170
2171   /* Make a suitable register to place result in.  */
2172   mode = TYPE_MODE (TREE_TYPE (exp));
2173
2174   /* Check if sincos insn is available, otherwise fallback
2175      to sin or cos insn.  */
2176   if (optab_handler (builtin_optab, mode)->insn_code == CODE_FOR_nothing)
2177     switch (DECL_FUNCTION_CODE (fndecl))
2178       {
2179       CASE_FLT_FN (BUILT_IN_SIN):
2180         builtin_optab = sin_optab; break;
2181       CASE_FLT_FN (BUILT_IN_COS):
2182         builtin_optab = cos_optab; break;
2183       default:
2184         gcc_unreachable ();
2185       }
2186
2187   /* Before working hard, check whether the instruction is available.  */
2188   if (optab_handler (builtin_optab, mode)->insn_code != CODE_FOR_nothing)
2189     {
2190       target = gen_reg_rtx (mode);
2191
2192       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2193          need to expand the argument again.  This way, we will not perform
2194          side-effects more the once.  */
2195       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2196
2197       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2198
2199       start_sequence ();
2200
2201       /* Compute into TARGET.
2202          Set TARGET to wherever the result comes back.  */
2203       if (builtin_optab == sincos_optab)
2204         {
2205           int result;
2206
2207           switch (DECL_FUNCTION_CODE (fndecl))
2208             {
2209             CASE_FLT_FN (BUILT_IN_SIN):
2210               result = expand_twoval_unop (builtin_optab, op0, 0, target, 0);
2211               break;
2212             CASE_FLT_FN (BUILT_IN_COS):
2213               result = expand_twoval_unop (builtin_optab, op0, target, 0, 0);
2214               break;
2215             default:
2216               gcc_unreachable ();
2217             }
2218           gcc_assert (result);
2219         }
2220       else
2221         {
2222           target = expand_unop (mode, builtin_optab, op0, target, 0);
2223         }
2224
2225       if (target != 0)
2226         {
2227           /* Output the entire sequence.  */
2228           insns = get_insns ();
2229           end_sequence ();
2230           emit_insn (insns);
2231           return target;
2232         }
2233
2234       /* If we were unable to expand via the builtin, stop the sequence
2235          (without outputting the insns) and call to the library function
2236          with the stabilized argument list.  */
2237       end_sequence ();
2238     }
2239
2240   target = expand_call (exp, target, target == const0_rtx);
2241
2242   return target;
2243 }
2244
2245 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2246    return an RTL instruction code that implements the functionality.
2247    If that isn't possible or available return CODE_FOR_nothing.  */
2248
2249 static enum insn_code
2250 interclass_mathfn_icode (tree arg, tree fndecl)
2251 {
2252   bool errno_set = false;
2253   optab builtin_optab = 0;
2254   enum machine_mode mode;
2255
2256   switch (DECL_FUNCTION_CODE (fndecl))
2257     {
2258     CASE_FLT_FN (BUILT_IN_ILOGB):
2259       errno_set = true; builtin_optab = ilogb_optab; break;
2260     CASE_FLT_FN (BUILT_IN_ISINF):
2261       builtin_optab = isinf_optab; break;
2262     case BUILT_IN_ISNORMAL:
2263     case BUILT_IN_ISFINITE:
2264     CASE_FLT_FN (BUILT_IN_FINITE):
2265     case BUILT_IN_FINITED32:
2266     case BUILT_IN_FINITED64:
2267     case BUILT_IN_FINITED128:
2268     case BUILT_IN_ISINFD32:
2269     case BUILT_IN_ISINFD64:
2270     case BUILT_IN_ISINFD128:
2271       /* These builtins have no optabs (yet).  */
2272       break;
2273     default:
2274       gcc_unreachable ();
2275     }
2276
2277   /* There's no easy way to detect the case we need to set EDOM.  */
2278   if (flag_errno_math && errno_set)
2279     return CODE_FOR_nothing;
2280
2281   /* Optab mode depends on the mode of the input argument.  */
2282   mode = TYPE_MODE (TREE_TYPE (arg));
2283
2284   if (builtin_optab)
2285     return optab_handler (builtin_optab, mode)->insn_code;
2286   return CODE_FOR_nothing;
2287 }
2288
2289 /* Expand a call to one of the builtin math functions that operate on
2290    floating point argument and output an integer result (ilogb, isinf,
2291    isnan, etc).
2292    Return 0 if a normal call should be emitted rather than expanding the
2293    function in-line.  EXP is the expression that is a call to the builtin
2294    function; if convenient, the result should be placed in TARGET.
2295    SUBTARGET may be used as the target for computing one of EXP's operands.  */
2296
2297 static rtx
2298 expand_builtin_interclass_mathfn (tree exp, rtx target, rtx subtarget)
2299 {
2300   enum insn_code icode = CODE_FOR_nothing;
2301   rtx op0;
2302   tree fndecl = get_callee_fndecl (exp);
2303   enum machine_mode mode;
2304   tree arg;
2305
2306   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2307     return NULL_RTX;
2308
2309   arg = CALL_EXPR_ARG (exp, 0);
2310   icode = interclass_mathfn_icode (arg, fndecl);
2311   mode = TYPE_MODE (TREE_TYPE (arg));
2312
2313   if (icode != CODE_FOR_nothing)
2314     {
2315       rtx last = get_last_insn ();
2316       tree orig_arg = arg;
2317       /* Make a suitable register to place result in.  */
2318       if (!target
2319           || GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp))
2320           || !insn_data[icode].operand[0].predicate (target, GET_MODE (target)))
2321          target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
2322
2323       gcc_assert (insn_data[icode].operand[0].predicate
2324                   (target, GET_MODE (target)));
2325
2326       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2327          need to expand the argument again.  This way, we will not perform
2328          side-effects more the once.  */
2329       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2330
2331       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2332
2333       if (mode != GET_MODE (op0))
2334         op0 = convert_to_mode (mode, op0, 0);
2335
2336       /* Compute into TARGET.
2337          Set TARGET to wherever the result comes back.  */
2338       if (maybe_emit_unop_insn (icode, target, op0, UNKNOWN))
2339         return target;
2340       delete_insns_since (last);
2341       CALL_EXPR_ARG (exp, 0) = orig_arg;
2342     }
2343
2344   return NULL_RTX;
2345 }
2346
2347 /* Expand a call to the builtin sincos math function.
2348    Return NULL_RTX if a normal call should be emitted rather than expanding the
2349    function in-line.  EXP is the expression that is a call to the builtin
2350    function.  */
2351
2352 static rtx
2353 expand_builtin_sincos (tree exp)
2354 {
2355   rtx op0, op1, op2, target1, target2;
2356   enum machine_mode mode;
2357   tree arg, sinp, cosp;
2358   int result;
2359   location_t loc = EXPR_LOCATION (exp);
2360
2361   if (!validate_arglist (exp, REAL_TYPE,
2362                          POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2363     return NULL_RTX;
2364
2365   arg = CALL_EXPR_ARG (exp, 0);
2366   sinp = CALL_EXPR_ARG (exp, 1);
2367   cosp = CALL_EXPR_ARG (exp, 2);
2368
2369   /* Make a suitable register to place result in.  */
2370   mode = TYPE_MODE (TREE_TYPE (arg));
2371
2372   /* Check if sincos insn is available, otherwise emit the call.  */
2373   if (optab_handler (sincos_optab, mode)->insn_code == CODE_FOR_nothing)
2374     return NULL_RTX;
2375
2376   target1 = gen_reg_rtx (mode);
2377   target2 = gen_reg_rtx (mode);
2378
2379   op0 = expand_normal (arg);
2380   op1 = expand_normal (build_fold_indirect_ref_loc (loc, sinp));
2381   op2 = expand_normal (build_fold_indirect_ref_loc (loc, cosp));
2382
2383   /* Compute into target1 and target2.
2384      Set TARGET to wherever the result comes back.  */
2385   result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2386   gcc_assert (result);
2387
2388   /* Move target1 and target2 to the memory locations indicated
2389      by op1 and op2.  */
2390   emit_move_insn (op1, target1);
2391   emit_move_insn (op2, target2);
2392
2393   return const0_rtx;
2394 }
2395
2396 /* Expand a call to the internal cexpi builtin to the sincos math function.
2397    EXP is the expression that is a call to the builtin function; if convenient,
2398    the result should be placed in TARGET.  SUBTARGET may be used as the target
2399    for computing one of EXP's operands.  */
2400
2401 static rtx
2402 expand_builtin_cexpi (tree exp, rtx target, rtx subtarget)
2403 {
2404   tree fndecl = get_callee_fndecl (exp);
2405   tree arg, type;
2406   enum machine_mode mode;
2407   rtx op0, op1, op2;
2408   location_t loc = EXPR_LOCATION (exp);
2409
2410   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2411     return NULL_RTX;
2412
2413   arg = CALL_EXPR_ARG (exp, 0);
2414   type = TREE_TYPE (arg);
2415   mode = TYPE_MODE (TREE_TYPE (arg));
2416
2417   /* Try expanding via a sincos optab, fall back to emitting a libcall
2418      to sincos or cexp.  We are sure we have sincos or cexp because cexpi
2419      is only generated from sincos, cexp or if we have either of them.  */
2420   if (optab_handler (sincos_optab, mode)->insn_code != CODE_FOR_nothing)
2421     {
2422       op1 = gen_reg_rtx (mode);
2423       op2 = gen_reg_rtx (mode);
2424
2425       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2426
2427       /* Compute into op1 and op2.  */
2428       expand_twoval_unop (sincos_optab, op0, op2, op1, 0);
2429     }
2430   else if (TARGET_HAS_SINCOS)
2431     {
2432       tree call, fn = NULL_TREE;
2433       tree top1, top2;
2434       rtx op1a, op2a;
2435
2436       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2437         fn = built_in_decls[BUILT_IN_SINCOSF];
2438       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2439         fn = built_in_decls[BUILT_IN_SINCOS];
2440       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2441         fn = built_in_decls[BUILT_IN_SINCOSL];
2442       else
2443         gcc_unreachable ();
2444
2445       op1 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2446       op2 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2447       op1a = copy_to_mode_reg (Pmode, XEXP (op1, 0));
2448       op2a = copy_to_mode_reg (Pmode, XEXP (op2, 0));
2449       top1 = make_tree (build_pointer_type (TREE_TYPE (arg)), op1a);
2450       top2 = make_tree (build_pointer_type (TREE_TYPE (arg)), op2a);
2451
2452       /* Make sure not to fold the sincos call again.  */
2453       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2454       expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn)),
2455                                       call, 3, arg, top1, top2));
2456     }
2457   else
2458     {
2459       tree call, fn = NULL_TREE, narg;
2460       tree ctype = build_complex_type (type);
2461
2462       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2463         fn = built_in_decls[BUILT_IN_CEXPF];
2464       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2465         fn = built_in_decls[BUILT_IN_CEXP];
2466       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2467         fn = built_in_decls[BUILT_IN_CEXPL];
2468       else
2469         gcc_unreachable ();
2470
2471       /* If we don't have a decl for cexp create one.  This is the
2472          friendliest fallback if the user calls __builtin_cexpi
2473          without full target C99 function support.  */
2474       if (fn == NULL_TREE)
2475         {
2476           tree fntype;
2477           const char *name = NULL;
2478
2479           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2480             name = "cexpf";
2481           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2482             name = "cexp";
2483           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2484             name = "cexpl";
2485
2486           fntype = build_function_type_list (ctype, ctype, NULL_TREE);
2487           fn = build_fn_decl (name, fntype);
2488         }
2489
2490       narg = fold_build2_loc (loc, COMPLEX_EXPR, ctype,
2491                           build_real (type, dconst0), arg);
2492
2493       /* Make sure not to fold the cexp call again.  */
2494       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2495       return expand_expr (build_call_nary (ctype, call, 1, narg),
2496                           target, VOIDmode, EXPAND_NORMAL);
2497     }
2498
2499   /* Now build the proper return type.  */
2500   return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type),
2501                               make_tree (TREE_TYPE (arg), op2),
2502                               make_tree (TREE_TYPE (arg), op1)),
2503                       target, VOIDmode, EXPAND_NORMAL);
2504 }
2505
2506 /* Conveniently construct a function call expression.  FNDECL names the
2507    function to be called, N is the number of arguments, and the "..."
2508    parameters are the argument expressions.  Unlike build_call_exr
2509    this doesn't fold the call, hence it will always return a CALL_EXPR.  */
2510
2511 static tree
2512 build_call_nofold_loc (location_t loc, tree fndecl, int n, ...)
2513 {
2514   va_list ap;
2515   tree fntype = TREE_TYPE (fndecl);
2516   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
2517
2518   va_start (ap, n);
2519   fn = build_call_valist (TREE_TYPE (fntype), fn, n, ap);
2520   va_end (ap);
2521   SET_EXPR_LOCATION (fn, loc);
2522   return fn;
2523 }
2524 #define build_call_nofold(...) \
2525   build_call_nofold_loc (UNKNOWN_LOCATION, __VA_ARGS__)
2526
2527 /* Expand a call to one of the builtin rounding functions gcc defines
2528    as an extension (lfloor and lceil).  As these are gcc extensions we
2529    do not need to worry about setting errno to EDOM.
2530    If expanding via optab fails, lower expression to (int)(floor(x)).
2531    EXP is the expression that is a call to the builtin function;
2532    if convenient, the result should be placed in TARGET.  */
2533
2534 static rtx
2535 expand_builtin_int_roundingfn (tree exp, rtx target)
2536 {
2537   convert_optab builtin_optab;
2538   rtx op0, insns, tmp;
2539   tree fndecl = get_callee_fndecl (exp);
2540   enum built_in_function fallback_fn;
2541   tree fallback_fndecl;
2542   enum machine_mode mode;
2543   tree arg;
2544
2545   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2546     gcc_unreachable ();
2547
2548   arg = CALL_EXPR_ARG (exp, 0);
2549
2550   switch (DECL_FUNCTION_CODE (fndecl))
2551     {
2552     CASE_FLT_FN (BUILT_IN_LCEIL):
2553     CASE_FLT_FN (BUILT_IN_LLCEIL):
2554       builtin_optab = lceil_optab;
2555       fallback_fn = BUILT_IN_CEIL;
2556       break;
2557
2558     CASE_FLT_FN (BUILT_IN_LFLOOR):
2559     CASE_FLT_FN (BUILT_IN_LLFLOOR):
2560       builtin_optab = lfloor_optab;
2561       fallback_fn = BUILT_IN_FLOOR;
2562       break;
2563
2564     default:
2565       gcc_unreachable ();
2566     }
2567
2568   /* Make a suitable register to place result in.  */
2569   mode = TYPE_MODE (TREE_TYPE (exp));
2570
2571   target = gen_reg_rtx (mode);
2572
2573   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2574      need to expand the argument again.  This way, we will not perform
2575      side-effects more the once.  */
2576   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2577
2578   op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2579
2580   start_sequence ();
2581
2582   /* Compute into TARGET.  */
2583   if (expand_sfix_optab (target, op0, builtin_optab))
2584     {
2585       /* Output the entire sequence.  */
2586       insns = get_insns ();
2587       end_sequence ();
2588       emit_insn (insns);
2589       return target;
2590     }
2591
2592   /* If we were unable to expand via the builtin, stop the sequence
2593      (without outputting the insns).  */
2594   end_sequence ();
2595
2596   /* Fall back to floating point rounding optab.  */
2597   fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2598
2599   /* For non-C99 targets we may end up without a fallback fndecl here
2600      if the user called __builtin_lfloor directly.  In this case emit
2601      a call to the floor/ceil variants nevertheless.  This should result
2602      in the best user experience for not full C99 targets.  */
2603   if (fallback_fndecl == NULL_TREE)
2604     {
2605       tree fntype;
2606       const char *name = NULL;
2607
2608       switch (DECL_FUNCTION_CODE (fndecl))
2609         {
2610         case BUILT_IN_LCEIL:
2611         case BUILT_IN_LLCEIL:
2612           name = "ceil";
2613           break;
2614         case BUILT_IN_LCEILF:
2615         case BUILT_IN_LLCEILF:
2616           name = "ceilf";
2617           break;
2618         case BUILT_IN_LCEILL:
2619         case BUILT_IN_LLCEILL:
2620           name = "ceill";
2621           break;
2622         case BUILT_IN_LFLOOR:
2623         case BUILT_IN_LLFLOOR:
2624           name = "floor";
2625           break;
2626         case BUILT_IN_LFLOORF:
2627         case BUILT_IN_LLFLOORF:
2628           name = "floorf";
2629           break;
2630         case BUILT_IN_LFLOORL:
2631         case BUILT_IN_LLFLOORL:
2632           name = "floorl";
2633           break;
2634         default:
2635           gcc_unreachable ();
2636         }
2637
2638       fntype = build_function_type_list (TREE_TYPE (arg),
2639                                          TREE_TYPE (arg), NULL_TREE);
2640       fallback_fndecl = build_fn_decl (name, fntype);
2641     }
2642
2643   exp = build_call_nofold (fallback_fndecl, 1, arg);
2644
2645   tmp = expand_normal (exp);
2646
2647   /* Truncate the result of floating point optab to integer
2648      via expand_fix ().  */
2649   target = gen_reg_rtx (mode);
2650   expand_fix (target, tmp, 0);
2651
2652   return target;
2653 }
2654
2655 /* Expand a call to one of the builtin math functions doing integer
2656    conversion (lrint).
2657    Return 0 if a normal call should be emitted rather than expanding the
2658    function in-line.  EXP is the expression that is a call to the builtin
2659    function; if convenient, the result should be placed in TARGET.  */
2660
2661 static rtx
2662 expand_builtin_int_roundingfn_2 (tree exp, rtx target)
2663 {
2664   convert_optab builtin_optab;
2665   rtx op0, insns;
2666   tree fndecl = get_callee_fndecl (exp);
2667   tree arg;
2668   enum machine_mode mode;
2669
2670   /* There's no easy way to detect the case we need to set EDOM.  */
2671   if (flag_errno_math)
2672     return NULL_RTX;
2673
2674   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2675      gcc_unreachable ();
2676
2677   arg = CALL_EXPR_ARG (exp, 0);
2678
2679   switch (DECL_FUNCTION_CODE (fndecl))
2680     {
2681     CASE_FLT_FN (BUILT_IN_LRINT):
2682     CASE_FLT_FN (BUILT_IN_LLRINT):
2683       builtin_optab = lrint_optab; break;
2684     CASE_FLT_FN (BUILT_IN_LROUND):
2685     CASE_FLT_FN (BUILT_IN_LLROUND):
2686       builtin_optab = lround_optab; break;
2687     default:
2688       gcc_unreachable ();
2689     }
2690
2691   /* Make a suitable register to place result in.  */
2692   mode = TYPE_MODE (TREE_TYPE (exp));
2693
2694   target = gen_reg_rtx (mode);
2695
2696   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2697      need to expand the argument again.  This way, we will not perform
2698      side-effects more the once.  */
2699   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2700
2701   op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2702
2703   start_sequence ();
2704
2705   if (expand_sfix_optab (target, op0, builtin_optab))
2706     {
2707       /* Output the entire sequence.  */
2708       insns = get_insns ();
2709       end_sequence ();
2710       emit_insn (insns);
2711       return target;
2712     }
2713
2714   /* If we were unable to expand via the builtin, stop the sequence
2715      (without outputting the insns) and call to the library function
2716      with the stabilized argument list.  */
2717   end_sequence ();
2718
2719   target = expand_call (exp, target, target == const0_rtx);
2720
2721   return target;
2722 }
2723
2724 /* To evaluate powi(x,n), the floating point value x raised to the
2725    constant integer exponent n, we use a hybrid algorithm that
2726    combines the "window method" with look-up tables.  For an
2727    introduction to exponentiation algorithms and "addition chains",
2728    see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2729    "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2730    3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2731    Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998.  */
2732
2733 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2734    multiplications to inline before calling the system library's pow
2735    function.  powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2736    so this default never requires calling pow, powf or powl.  */
2737
2738 #ifndef POWI_MAX_MULTS
2739 #define POWI_MAX_MULTS  (2*HOST_BITS_PER_WIDE_INT-2)
2740 #endif
2741
2742 /* The size of the "optimal power tree" lookup table.  All
2743    exponents less than this value are simply looked up in the
2744    powi_table below.  This threshold is also used to size the
2745    cache of pseudo registers that hold intermediate results.  */
2746 #define POWI_TABLE_SIZE 256
2747
2748 /* The size, in bits of the window, used in the "window method"
2749    exponentiation algorithm.  This is equivalent to a radix of
2750    (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method".  */
2751 #define POWI_WINDOW_SIZE 3
2752
2753 /* The following table is an efficient representation of an
2754    "optimal power tree".  For each value, i, the corresponding
2755    value, j, in the table states than an optimal evaluation
2756    sequence for calculating pow(x,i) can be found by evaluating
2757    pow(x,j)*pow(x,i-j).  An optimal power tree for the first
2758    100 integers is given in Knuth's "Seminumerical algorithms".  */
2759
2760 static const unsigned char powi_table[POWI_TABLE_SIZE] =
2761   {
2762       0,   1,   1,   2,   2,   3,   3,   4,  /*   0 -   7 */
2763       4,   6,   5,   6,   6,  10,   7,   9,  /*   8 -  15 */
2764       8,  16,   9,  16,  10,  12,  11,  13,  /*  16 -  23 */
2765      12,  17,  13,  18,  14,  24,  15,  26,  /*  24 -  31 */
2766      16,  17,  17,  19,  18,  33,  19,  26,  /*  32 -  39 */
2767      20,  25,  21,  40,  22,  27,  23,  44,  /*  40 -  47 */
2768      24,  32,  25,  34,  26,  29,  27,  44,  /*  48 -  55 */
2769      28,  31,  29,  34,  30,  60,  31,  36,  /*  56 -  63 */
2770      32,  64,  33,  34,  34,  46,  35,  37,  /*  64 -  71 */
2771      36,  65,  37,  50,  38,  48,  39,  69,  /*  72 -  79 */
2772      40,  49,  41,  43,  42,  51,  43,  58,  /*  80 -  87 */
2773      44,  64,  45,  47,  46,  59,  47,  76,  /*  88 -  95 */
2774      48,  65,  49,  66,  50,  67,  51,  66,  /*  96 - 103 */
2775      52,  70,  53,  74,  54, 104,  55,  74,  /* 104 - 111 */
2776      56,  64,  57,  69,  58,  78,  59,  68,  /* 112 - 119 */
2777      60,  61,  61,  80,  62,  75,  63,  68,  /* 120 - 127 */
2778      64,  65,  65, 128,  66, 129,  67,  90,  /* 128 - 135 */
2779      68,  73,  69, 131,  70,  94,  71,  88,  /* 136 - 143 */
2780      72, 128,  73,  98,  74, 132,  75, 121,  /* 144 - 151 */
2781      76, 102,  77, 124,  78, 132,  79, 106,  /* 152 - 159 */
2782      80,  97,  81, 160,  82,  99,  83, 134,  /* 160 - 167 */
2783      84,  86,  85,  95,  86, 160,  87, 100,  /* 168 - 175 */
2784      88, 113,  89,  98,  90, 107,  91, 122,  /* 176 - 183 */
2785      92, 111,  93, 102,  94, 126,  95, 150,  /* 184 - 191 */
2786      96, 128,  97, 130,  98, 133,  99, 195,  /* 192 - 199 */
2787     100, 128, 101, 123, 102, 164, 103, 138,  /* 200 - 207 */
2788     104, 145, 105, 146, 106, 109, 107, 149,  /* 208 - 215 */
2789     108, 200, 109, 146, 110, 170, 111, 157,  /* 216 - 223 */
2790     112, 128, 113, 130, 114, 182, 115, 132,  /* 224 - 231 */
2791     116, 200, 117, 132, 118, 158, 119, 206,  /* 232 - 239 */
2792     120, 240, 121, 162, 122, 147, 123, 152,  /* 240 - 247 */
2793     124, 166, 125, 214, 126, 138, 127, 153,  /* 248 - 255 */
2794   };
2795
2796
2797 /* Return the number of multiplications required to calculate
2798    powi(x,n) where n is less than POWI_TABLE_SIZE.  This is a
2799    subroutine of powi_cost.  CACHE is an array indicating
2800    which exponents have already been calculated.  */
2801
2802 static int
2803 powi_lookup_cost (unsigned HOST_WIDE_INT n, bool *cache)
2804 {
2805   /* If we've already calculated this exponent, then this evaluation
2806      doesn't require any additional multiplications.  */
2807   if (cache[n])
2808     return 0;
2809
2810   cache[n] = true;
2811   return powi_lookup_cost (n - powi_table[n], cache)
2812          + powi_lookup_cost (powi_table[n], cache) + 1;
2813 }
2814
2815 /* Return the number of multiplications required to calculate
2816    powi(x,n) for an arbitrary x, given the exponent N.  This
2817    function needs to be kept in sync with expand_powi below.  */
2818
2819 static int
2820 powi_cost (HOST_WIDE_INT n)
2821 {
2822   bool cache[POWI_TABLE_SIZE];
2823   unsigned HOST_WIDE_INT digit;
2824   unsigned HOST_WIDE_INT val;
2825   int result;
2826
2827   if (n == 0)
2828     return 0;
2829
2830   /* Ignore the reciprocal when calculating the cost.  */
2831   val = (n < 0) ? -n : n;
2832
2833   /* Initialize the exponent cache.  */
2834   memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool));
2835   cache[1] = true;
2836
2837   result = 0;
2838
2839   while (val >= POWI_TABLE_SIZE)
2840     {
2841       if (val & 1)
2842         {
2843           digit = val & ((1 << POWI_WINDOW_SIZE) - 1);
2844           result += powi_lookup_cost (digit, cache)
2845                     + POWI_WINDOW_SIZE + 1;
2846           val >>= POWI_WINDOW_SIZE;
2847         }
2848       else
2849         {
2850           val >>= 1;
2851           result++;
2852         }
2853     }
2854
2855   return result + powi_lookup_cost (val, cache);
2856 }
2857
2858 /* Recursive subroutine of expand_powi.  This function takes the array,
2859    CACHE, of already calculated exponents and an exponent N and returns
2860    an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE.  */
2861
2862 static rtx
2863 expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
2864 {
2865   unsigned HOST_WIDE_INT digit;
2866   rtx target, result;
2867   rtx op0, op1;
2868
2869   if (n < POWI_TABLE_SIZE)
2870     {
2871       if (cache[n])
2872         return cache[n];
2873
2874       target = gen_reg_rtx (mode);
2875       cache[n] = target;
2876
2877       op0 = expand_powi_1 (mode, n - powi_table[n], cache);
2878       op1 = expand_powi_1 (mode, powi_table[n], cache);
2879     }
2880   else if (n & 1)
2881     {
2882       target = gen_reg_rtx (mode);
2883       digit = n & ((1 << POWI_WINDOW_SIZE) - 1);
2884       op0 = expand_powi_1 (mode, n - digit, cache);
2885       op1 = expand_powi_1 (mode, digit, cache);
2886     }
2887   else
2888     {
2889       target = gen_reg_rtx (mode);
2890       op0 = expand_powi_1 (mode, n >> 1, cache);
2891       op1 = op0;
2892     }
2893
2894   result = expand_mult (mode, op0, op1, target, 0);
2895   if (result != target)
2896     emit_move_insn (target, result);
2897   return target;
2898 }
2899
2900 /* Expand the RTL to evaluate powi(x,n) in mode MODE.  X is the
2901    floating point operand in mode MODE, and N is the exponent.  This
2902    function needs to be kept in sync with powi_cost above.  */
2903
2904 static rtx
2905 expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
2906 {
2907   rtx cache[POWI_TABLE_SIZE];
2908   rtx result;
2909
2910   if (n == 0)
2911     return CONST1_RTX (mode);
2912
2913   memset (cache, 0, sizeof (cache));
2914   cache[1] = x;
2915
2916   result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
2917
2918   /* If the original exponent was negative, reciprocate the result.  */
2919   if (n < 0)
2920     result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2921                            result, NULL_RTX, 0, OPTAB_LIB_WIDEN);
2922
2923   return result;
2924 }
2925
2926 /* Fold a builtin function call to pow, powf, or powl into a series of sqrts or
2927    cbrts.  Return NULL_RTX if no simplification can be made or expand the tree
2928    if we can simplify it.  */
2929 static rtx
2930 expand_builtin_pow_root (location_t loc, tree arg0, tree arg1, tree type,
2931                          rtx subtarget)
2932 {
2933   if (TREE_CODE (arg1) == REAL_CST
2934       && !TREE_OVERFLOW (arg1)
2935       && flag_unsafe_math_optimizations)
2936     {
2937       enum machine_mode mode = TYPE_MODE (type);
2938       tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
2939       tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
2940       REAL_VALUE_TYPE c = TREE_REAL_CST (arg1);
2941       tree op = NULL_TREE;
2942
2943       if (sqrtfn)
2944         {
2945           /* Optimize pow (x, 0.5) into sqrt.  */
2946           if (REAL_VALUES_EQUAL (c, dconsthalf))
2947             op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
2948
2949           else
2950             {
2951               REAL_VALUE_TYPE dconst1_4 = dconst1;
2952               REAL_VALUE_TYPE dconst3_4;
2953               SET_REAL_EXP (&dconst1_4, REAL_EXP (&dconst1_4) - 2);
2954
2955               real_from_integer (&dconst3_4, VOIDmode, 3, 0, 0);
2956               SET_REAL_EXP (&dconst3_4, REAL_EXP (&dconst3_4) - 2);
2957
2958               /* Optimize pow (x, 0.25) into sqrt (sqrt (x)).  Assume on most
2959                  machines that a builtin sqrt instruction is smaller than a
2960                  call to pow with 0.25, so do this optimization even if
2961                  -Os.  */
2962               if (REAL_VALUES_EQUAL (c, dconst1_4))
2963                 {
2964                   op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
2965                   op = build_call_nofold_loc (loc, sqrtfn, 1, op);
2966                 }
2967
2968               /* Optimize pow (x, 0.75) = sqrt (x) * sqrt (sqrt (x)) unless we
2969                  are optimizing for space.  */
2970               else if (optimize_insn_for_speed_p ()
2971                        && !TREE_SIDE_EFFECTS (arg0)
2972                        && REAL_VALUES_EQUAL (c, dconst3_4))
2973                 {
2974                   tree sqrt1 = build_call_expr_loc (loc, sqrtfn, 1, arg0);
2975                   tree sqrt2 = builtin_save_expr (sqrt1);
2976                   tree sqrt3 = build_call_expr_loc (loc, sqrtfn, 1, sqrt1);
2977                   op = fold_build2_loc (loc, MULT_EXPR, type, sqrt2, sqrt3);
2978                 }
2979             }
2980         }
2981
2982       /* Check whether we can do cbrt insstead of pow (x, 1./3.) and
2983          cbrt/sqrts instead of pow (x, 1./6.).  */
2984       if (cbrtfn && ! op
2985           && (tree_expr_nonnegative_p (arg0) || !HONOR_NANS (mode)))
2986         {
2987           /* First try 1/3.  */
2988           REAL_VALUE_TYPE dconst1_3
2989             = real_value_truncate (mode, dconst_third ());
2990
2991           if (REAL_VALUES_EQUAL (c, dconst1_3))
2992             op = build_call_nofold_loc (loc, cbrtfn, 1, arg0);
2993
2994               /* Now try 1/6.  */
2995           else if (optimize_insn_for_speed_p ())
2996             {
2997               REAL_VALUE_TYPE dconst1_6 = dconst1_3;
2998               SET_REAL_EXP (&dconst1_6, REAL_EXP (&dconst1_6) - 1);
2999
3000               if (REAL_VALUES_EQUAL (c, dconst1_6))
3001                 {
3002                   op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
3003                   op = build_call_nofold_loc (loc, cbrtfn, 1, op);
3004                 }
3005             }
3006         }
3007
3008       if (op)
3009         return expand_expr (op, subtarget, mode, EXPAND_NORMAL);
3010     }
3011
3012   return NULL_RTX;
3013 }
3014
3015 /* Expand a call to the pow built-in mathematical function.  Return NULL_RTX if
3016    a normal call should be emitted rather than expanding the function
3017    in-line.  EXP is the expression that is a call to the builtin
3018    function; if convenient, the result should be placed in TARGET.  */
3019
3020 static rtx
3021 expand_builtin_pow (tree exp, rtx target, rtx subtarget)
3022 {
3023   tree arg0, arg1;
3024   tree fn, narg0;
3025   tree type = TREE_TYPE (exp);
3026   REAL_VALUE_TYPE cint, c, c2;
3027   HOST_WIDE_INT n;
3028   rtx op, op2;
3029   enum machine_mode mode = TYPE_MODE (type);
3030
3031   if (! validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
3032     return NULL_RTX;
3033
3034   arg0 = CALL_EXPR_ARG (exp, 0);
3035   arg1 = CALL_EXPR_ARG (exp, 1);
3036
3037   if (TREE_CODE (arg1) != REAL_CST
3038       || TREE_OVERFLOW (arg1))
3039     return expand_builtin_mathfn_2 (exp, target, subtarget);
3040
3041   /* Handle constant exponents.  */
3042
3043   /* For integer valued exponents we can expand to an optimal multiplication
3044      sequence using expand_powi.  */
3045   c = TREE_REAL_CST (arg1);
3046   n = real_to_integer (&c);
3047   real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3048   if (real_identical (&c, &cint)
3049       && ((n >= -1 && n <= 2)
3050           || (flag_unsafe_math_optimizations
3051               && optimize_insn_for_speed_p ()
3052               && powi_cost (n) <= POWI_MAX_MULTS)))
3053     {
3054       op = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
3055       if (n != 1)
3056         {
3057           op = force_reg (mode, op);
3058           op = expand_powi (op, mode, n);
3059         }
3060       return op;
3061     }
3062
3063   narg0 = builtin_save_expr (arg0);
3064
3065   /* If the exponent is not integer valued, check if it is half of an integer.
3066      In this case we can expand to sqrt (x) * x**(n/2).  */
3067   fn = mathfn_built_in (type, BUILT_IN_SQRT);
3068   if (fn != NULL_TREE)
3069     {
3070       real_arithmetic (&c2, MULT_EXPR, &c, &dconst2);
3071       n = real_to_integer (&c2);
3072       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3073       if (real_identical (&c2, &cint)
3074           && ((flag_unsafe_math_optimizations
3075                && optimize_insn_for_speed_p ()
3076                && powi_cost (n/2) <= POWI_MAX_MULTS)
3077               /* Even the c == 0.5 case cannot be done unconditionally
3078                  when we need to preserve signed zeros, as
3079                  pow (-0, 0.5) is +0, while sqrt(-0) is -0.  */
3080               || (!HONOR_SIGNED_ZEROS (mode) && n == 1)
3081               /* For c == 1.5 we can assume that x * sqrt (x) is always
3082                  smaller than pow (x, 1.5) if sqrt will not be expanded
3083                  as a call.  */
3084               || (n == 3
3085                   && (optab_handler (sqrt_optab, mode)->insn_code
3086                       != CODE_FOR_nothing))))
3087         {
3088           tree call_expr = build_call_nofold (fn, 1, narg0);
3089           /* Use expand_expr in case the newly built call expression
3090              was folded to a non-call.  */
3091           op = expand_expr (call_expr, subtarget, mode, EXPAND_NORMAL);
3092           if (n != 1)
3093             {
3094               op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3095               op2 = force_reg (mode, op2);
3096               op2 = expand_powi (op2, mode, abs (n / 2));
3097               op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3098                                         0, OPTAB_LIB_WIDEN);
3099               /* If the original exponent was negative, reciprocate the
3100                  result.  */
3101               if (n < 0)
3102                 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3103                                    op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3104             }
3105           return op;
3106         }
3107     }
3108
3109   /* Check whether we can do a series of sqrt or cbrt's instead of the pow
3110      call.  */
3111   op = expand_builtin_pow_root (EXPR_LOCATION (exp), arg0, arg1, type,
3112                                 subtarget);
3113   if (op)
3114     return op;
3115
3116   /* Try if the exponent is a third of an integer.  In this case
3117      we can expand to x**(n/3) * cbrt(x)**(n%3).  As cbrt (x) is
3118      different from pow (x, 1./3.) due to rounding and behavior
3119      with negative x we need to constrain this transformation to
3120      unsafe math and positive x or finite math.  */
3121   fn = mathfn_built_in (type, BUILT_IN_CBRT);
3122   if (fn != NULL_TREE
3123       && flag_unsafe_math_optimizations
3124       && (tree_expr_nonnegative_p (arg0)
3125           || !HONOR_NANS (mode)))
3126     {
3127       REAL_VALUE_TYPE dconst3;
3128       real_from_integer (&dconst3, VOIDmode, 3, 0, 0);
3129       real_arithmetic (&c2, MULT_EXPR, &c, &dconst3);
3130       real_round (&c2, mode, &c2);
3131       n = real_to_integer (&c2);
3132       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3133       real_arithmetic (&c2, RDIV_EXPR, &cint, &dconst3);
3134       real_convert (&c2, mode, &c2);
3135       if (real_identical (&c2, &c)
3136           && ((optimize_insn_for_speed_p ()
3137                && powi_cost (n/3) <= POWI_MAX_MULTS)
3138               || n == 1))
3139         {
3140           tree call_expr = build_call_nofold (fn, 1,narg0);
3141           op = expand_builtin (call_expr, NULL_RTX, subtarget, mode, 0);
3142           if (abs (n) % 3 == 2)
3143             op = expand_simple_binop (mode, MULT, op, op, op,
3144                                       0, OPTAB_LIB_WIDEN);
3145           if (n != 1)
3146             {
3147               op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3148               op2 = force_reg (mode, op2);
3149               op2 = expand_powi (op2, mode, abs (n / 3));
3150               op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3151                                         0, OPTAB_LIB_WIDEN);
3152               /* If the original exponent was negative, reciprocate the
3153                  result.  */
3154               if (n < 0)
3155                 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3156                                    op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3157             }
3158           return op;
3159         }
3160     }
3161
3162   /* Fall back to optab expansion.  */
3163   return expand_builtin_mathfn_2 (exp, target, subtarget);
3164 }
3165
3166 /* Expand a call to the powi built-in mathematical function.  Return NULL_RTX if
3167    a normal call should be emitted rather than expanding the function
3168    in-line.  EXP is the expression that is a call to the builtin
3169    function; if convenient, the result should be placed in TARGET.  */
3170
3171 static rtx
3172 expand_builtin_powi (tree exp, rtx target, rtx subtarget)
3173 {
3174   tree arg0, arg1;
3175   rtx op0, op1;
3176   enum machine_mode mode;
3177   enum machine_mode mode2;
3178
3179   if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
3180     return NULL_RTX;
3181
3182   arg0 = CALL_EXPR_ARG (exp, 0);
3183   arg1 = CALL_EXPR_ARG (exp, 1);
3184   mode = TYPE_MODE (TREE_TYPE (exp));
3185
3186   /* Handle constant power.  */
3187
3188   if (TREE_CODE (arg1) == INTEGER_CST
3189       && !TREE_OVERFLOW (arg1))
3190     {
3191       HOST_WIDE_INT n = TREE_INT_CST_LOW (arg1);
3192
3193       /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
3194          Otherwise, check the number of multiplications required.  */
3195       if ((TREE_INT_CST_HIGH (arg1) == 0
3196            || TREE_INT_CST_HIGH (arg1) == -1)
3197           && ((n >= -1 && n <= 2)
3198               || (optimize_insn_for_speed_p ()
3199                   && powi_cost (n) <= POWI_MAX_MULTS)))
3200         {
3201           op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
3202           op0 = force_reg (mode, op0);
3203           return expand_powi (op0, mode, n);
3204         }
3205     }
3206
3207   /* Emit a libcall to libgcc.  */
3208
3209   /* Mode of the 2nd argument must match that of an int.  */
3210   mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
3211
3212   if (target == NULL_RTX)
3213     target = gen_reg_rtx (mode);
3214
3215   op0 = expand_expr (arg0, subtarget, mode, EXPAND_NORMAL);
3216   if (GET_MODE (op0) != mode)
3217     op0 = convert_to_mode (mode, op0, 0);
3218   op1 = expand_expr (arg1, NULL_RTX, mode2, EXPAND_NORMAL);
3219   if (GET_MODE (op1) != mode2)
3220     op1 = convert_to_mode (mode2, op1, 0);
3221
3222   target = emit_library_call_value (optab_libfunc (powi_optab, mode),
3223                                     target, LCT_CONST, mode, 2,
3224                                     op0, mode, op1, mode2);
3225
3226   return target;
3227 }
3228
3229 /* Expand expression EXP which is a call to the strlen builtin.  Return
3230    NULL_RTX if we failed the caller should emit a normal call, otherwise
3231    try to get the result in TARGET, if convenient.  */
3232
3233 static rtx
3234 expand_builtin_strlen (tree exp, rtx target,
3235                        enum machine_mode target_mode)
3236 {
3237   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
3238     return NULL_RTX;
3239   else
3240     {
3241       rtx pat;
3242       tree len;
3243       tree src = CALL_EXPR_ARG (exp, 0);
3244       rtx result, src_reg, char_rtx, before_strlen;
3245       enum machine_mode insn_mode = target_mode, char_mode;
3246       enum insn_code icode = CODE_FOR_nothing;
3247       int align;
3248
3249       /* If the length can be computed at compile-time, return it.  */
3250       len = c_strlen (src, 0);
3251       if (len)
3252         return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3253
3254       /* If the length can be computed at compile-time and is constant
3255          integer, but there are side-effects in src, evaluate
3256          src for side-effects, then return len.
3257          E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3258          can be optimized into: i++; x = 3;  */
3259       len = c_strlen (src, 1);
3260       if (len && TREE_CODE (len) == INTEGER_CST)
3261         {
3262           expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
3263           return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3264         }
3265
3266       align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3267
3268       /* If SRC is not a pointer type, don't do this operation inline.  */
3269       if (align == 0)
3270         return NULL_RTX;
3271
3272       /* Bail out if we can't compute strlen in the right mode.  */
3273       while (insn_mode != VOIDmode)
3274         {
3275           icode = optab_handler (strlen_optab, insn_mode)->insn_code;
3276           if (icode != CODE_FOR_nothing)
3277             break;
3278
3279           insn_mode = GET_MODE_WIDER_MODE (insn_mode);
3280         }
3281       if (insn_mode == VOIDmode)
3282         return NULL_RTX;
3283
3284       /* Make a place to write the result of the instruction.  */
3285       result = target;
3286       if (! (result != 0
3287              && REG_P (result)
3288              && GET_MODE (result) == insn_mode
3289              && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3290         result = gen_reg_rtx (insn_mode);
3291
3292       /* Make a place to hold the source address.  We will not expand
3293          the actual source until we are sure that the expansion will
3294          not fail -- there are trees that cannot be expanded twice.  */
3295       src_reg = gen_reg_rtx (Pmode);
3296
3297       /* Mark the beginning of the strlen sequence so we can emit the
3298          source operand later.  */
3299       before_strlen = get_last_insn ();
3300
3301       char_rtx = const0_rtx;
3302       char_mode = insn_data[(int) icode].operand[2].mode;
3303       if (! (*insn_data[(int) icode].operand[2].predicate) (char_rtx,
3304                                                             char_mode))
3305         char_rtx = copy_to_mode_reg (char_mode, char_rtx);
3306
3307       pat = GEN_FCN (icode) (result, gen_rtx_MEM (BLKmode, src_reg),
3308                              char_rtx, GEN_INT (align));
3309       if (! pat)
3310         return NULL_RTX;
3311       emit_insn (pat);
3312
3313       /* Now that we are assured of success, expand the source.  */
3314       start_sequence ();
3315       pat = expand_expr (src, src_reg, ptr_mode, EXPAND_NORMAL);
3316       if (pat != src_reg)
3317         emit_move_insn (src_reg, pat);
3318       pat = get_insns ();
3319       end_sequence ();
3320
3321       if (before_strlen)
3322         emit_insn_after (pat, before_strlen);
3323       else
3324         emit_insn_before (pat, get_insns ());
3325
3326       /* Return the value in the proper mode for this function.  */
3327       if (GET_MODE (result) == target_mode)
3328         target = result;
3329       else if (target != 0)
3330         convert_move (target, result, 0);
3331       else
3332         target = convert_to_mode (target_mode, result, 0);
3333
3334       return target;
3335     }
3336 }
3337
3338 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3339    bytes from constant string DATA + OFFSET and return it as target
3340    constant.  */
3341
3342 static rtx
3343 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
3344                          enum machine_mode mode)
3345 {
3346   const char *str = (const char *) data;
3347
3348   gcc_assert (offset >= 0
3349               && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
3350                   <= strlen (str) + 1));
3351
3352   return c_readstr (str + offset, mode);
3353 }
3354
3355 /* Expand a call EXP to the memcpy builtin.
3356    Return NULL_RTX if we failed, the caller should emit a normal call,
3357    otherwise try to get the result in TARGET, if convenient (and in
3358    mode MODE if that's convenient).  */
3359
3360 static rtx
3361 expand_builtin_memcpy (tree exp, rtx target)
3362 {
3363   if (!validate_arglist (exp,
3364                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3365     return NULL_RTX;
3366   else
3367     {
3368       tree dest = CALL_EXPR_ARG (exp, 0);
3369       tree src = CALL_EXPR_ARG (exp, 1);
3370       tree len = CALL_EXPR_ARG (exp, 2);
3371       const char *src_str;
3372       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3373       unsigned int dest_align
3374         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3375       rtx dest_mem, src_mem, dest_addr, len_rtx;
3376       HOST_WIDE_INT expected_size = -1;
3377       unsigned int expected_align = 0;
3378
3379       /* If DEST is not a pointer type, call the normal function.  */
3380       if (dest_align == 0)
3381         return NULL_RTX;
3382
3383       /* If either SRC is not a pointer type, don't do this
3384          operation in-line.  */
3385       if (src_align == 0)
3386         return NULL_RTX;
3387
3388       if (currently_expanding_gimple_stmt)
3389         stringop_block_profile (currently_expanding_gimple_stmt,
3390                                 &expected_align, &expected_size);
3391
3392       if (expected_align < dest_align)
3393         expected_align = dest_align;
3394       dest_mem = get_memory_rtx (dest, len);
3395       set_mem_align (dest_mem, dest_align);
3396       len_rtx = expand_normal (len);
3397       src_str = c_getstr (src);
3398
3399       /* If SRC is a string constant and block move would be done
3400          by pieces, we can avoid loading the string from memory
3401          and only stored the computed constants.  */
3402       if (src_str
3403           && CONST_INT_P (len_rtx)
3404           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3405           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3406                                   CONST_CAST (char *, src_str),
3407                                   dest_align, false))
3408         {
3409           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3410                                       builtin_memcpy_read_str,
3411                                       CONST_CAST (char *, src_str),
3412                                       dest_align, false, 0);
3413           dest_mem = force_operand (XEXP (dest_mem, 0), target);
3414           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3415           return dest_mem;
3416         }
3417
3418       src_mem = get_memory_rtx (src, len);
3419       set_mem_align (src_mem, src_align);
3420
3421       /* Copy word part most expediently.  */
3422       dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx,
3423                                          CALL_EXPR_TAILCALL (exp)
3424                                          ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3425                                          expected_align, expected_size);
3426
3427       if (dest_addr == 0)
3428         {
3429           dest_addr = force_operand (XEXP (dest_mem, 0), target);
3430           dest_addr = convert_memory_address (ptr_mode, dest_addr);
3431         }
3432       return dest_addr;
3433     }
3434 }
3435
3436 /* Expand a call EXP to the mempcpy builtin.
3437    Return NULL_RTX if we failed; the caller should emit a normal call,
3438    otherwise try to get the result in TARGET, if convenient (and in
3439    mode MODE if that's convenient).  If ENDP is 0 return the
3440    destination pointer, if ENDP is 1 return the end pointer ala
3441    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3442    stpcpy.  */
3443
3444 static rtx
3445 expand_builtin_mempcpy (tree exp, rtx target, enum machine_mode mode)
3446 {
3447   if (!validate_arglist (exp,
3448                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3449     return NULL_RTX;
3450   else
3451     {
3452       tree dest = CALL_EXPR_ARG (exp, 0);
3453       tree src = CALL_EXPR_ARG (exp, 1);
3454       tree len = CALL_EXPR_ARG (exp, 2);
3455       return expand_builtin_mempcpy_args (dest, src, len,
3456                                           target, mode, /*endp=*/ 1);
3457     }
3458 }
3459
3460 /* Helper function to do the actual work for expand_builtin_mempcpy.  The
3461    arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3462    so that this can also be called without constructing an actual CALL_EXPR.
3463    The other arguments and return value are the same as for
3464    expand_builtin_mempcpy.  */
3465
3466 static rtx
3467 expand_builtin_mempcpy_args (tree dest, tree src, tree len,
3468                              rtx target, enum machine_mode mode, int endp)
3469 {
3470     /* If return value is ignored, transform mempcpy into memcpy.  */
3471   if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_MEMCPY])
3472     {
3473       tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
3474       tree result = build_call_nofold (fn, 3, dest, src, len);
3475       return expand_expr (result, target, mode, EXPAND_NORMAL);
3476     }
3477   else
3478     {
3479       const char *src_str;
3480       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3481       unsigned int dest_align
3482         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3483       rtx dest_mem, src_mem, len_rtx;
3484
3485       /* If either SRC or DEST is not a pointer type, don't do this
3486          operation in-line.  */
3487       if (dest_align == 0 || src_align == 0)
3488         return NULL_RTX;
3489
3490       /* If LEN is not constant, call the normal function.  */
3491       if (! host_integerp (len, 1))
3492         return NULL_RTX;
3493
3494       len_rtx = expand_normal (len);
3495       src_str = c_getstr (src);
3496
3497       /* If SRC is a string constant and block move would be done
3498          by pieces, we can avoid loading the string from memory
3499          and only stored the computed constants.  */
3500       if (src_str
3501           && CONST_INT_P (len_rtx)
3502           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3503           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3504                                   CONST_CAST (char *, src_str),
3505                                   dest_align, false))
3506         {
3507           dest_mem = get_memory_rtx (dest, len);
3508           set_mem_align (dest_mem, dest_align);
3509           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3510                                       builtin_memcpy_read_str,
3511                                       CONST_CAST (char *, src_str),
3512                                       dest_align, false, endp);
3513           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3514           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3515           return dest_mem;
3516         }
3517
3518       if (CONST_INT_P (len_rtx)
3519           && can_move_by_pieces (INTVAL (len_rtx),
3520                                  MIN (dest_align, src_align)))
3521         {
3522           dest_mem = get_memory_rtx (dest, len);
3523           set_mem_align (dest_mem, dest_align);
3524           src_mem = get_memory_rtx (src, len);
3525           set_mem_align (src_mem, src_align);
3526           dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
3527                                      MIN (dest_align, src_align), endp);
3528           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3529           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3530           return dest_mem;
3531         }
3532
3533       return NULL_RTX;
3534     }
3535 }
3536
3537 #ifndef HAVE_movstr
3538 # define HAVE_movstr 0
3539 # define CODE_FOR_movstr CODE_FOR_nothing
3540 #endif
3541
3542 /* Expand into a movstr instruction, if one is available.  Return NULL_RTX if
3543    we failed, the caller should emit a normal call, otherwise try to
3544    get the result in TARGET, if convenient.  If ENDP is 0 return the
3545    destination pointer, if ENDP is 1 return the end pointer ala
3546    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3547    stpcpy.  */
3548
3549 static rtx
3550 expand_movstr (tree dest, tree src, rtx target, int endp)
3551 {
3552   rtx end;
3553   rtx dest_mem;
3554   rtx src_mem;
3555   rtx insn;
3556   const struct insn_data * data;
3557
3558   if (!HAVE_movstr)
3559     return NULL_RTX;
3560
3561   dest_mem = get_memory_rtx (dest, NULL);
3562   src_mem = get_memory_rtx (src, NULL);
3563   if (!endp)
3564     {
3565       target = force_reg (Pmode, XEXP (dest_mem, 0));
3566       dest_mem = replace_equiv_address (dest_mem, target);
3567       end = gen_reg_rtx (Pmode);
3568     }
3569   else
3570     {
3571       if (target == 0 || target == const0_rtx)
3572         {
3573           end = gen_reg_rtx (Pmode);
3574           if (target == 0)
3575             target = end;
3576         }
3577       else
3578         end = target;
3579     }
3580
3581   data = insn_data + CODE_FOR_movstr;
3582
3583   if (data->operand[0].mode != VOIDmode)
3584     end = gen_lowpart (data->operand[0].mode, end);
3585
3586   insn = data->genfun (end, dest_mem, src_mem);
3587
3588   gcc_assert (insn);
3589
3590   emit_insn (insn);
3591
3592   /* movstr is supposed to set end to the address of the NUL
3593      terminator.  If the caller requested a mempcpy-like return value,
3594      adjust it.  */
3595   if (endp == 1 && target != const0_rtx)
3596     {
3597       rtx tem = plus_constant (gen_lowpart (GET_MODE (target), end), 1);
3598       emit_move_insn (target, force_operand (tem, NULL_RTX));
3599     }
3600
3601   return target;
3602 }
3603
3604 /* Expand expression EXP, which is a call to the strcpy builtin.  Return
3605    NULL_RTX if we failed the caller should emit a normal call, otherwise
3606    try to get the result in TARGET, if convenient (and in mode MODE if that's
3607    convenient).  */
3608
3609 static rtx
3610 expand_builtin_strcpy (tree exp, rtx target)
3611 {
3612   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3613    {
3614      tree dest = CALL_EXPR_ARG (exp, 0);
3615      tree src = CALL_EXPR_ARG (exp, 1);
3616      return expand_builtin_strcpy_args (dest, src, target);
3617    }
3618    return NULL_RTX;
3619 }
3620
3621 /* Helper function to do the actual work for expand_builtin_strcpy.  The
3622    arguments to the builtin_strcpy call DEST and SRC are broken out
3623    so that this can also be called without constructing an actual CALL_EXPR.
3624    The other arguments and return value are the same as for
3625    expand_builtin_strcpy.  */
3626
3627 static rtx
3628 expand_builtin_strcpy_args (tree dest, tree src, rtx target)
3629 {
3630   return expand_movstr (dest, src, target, /*endp=*/0);
3631 }
3632
3633 /* Expand a call EXP to the stpcpy builtin.
3634    Return NULL_RTX if we failed the caller should emit a normal call,
3635    otherwise try to get the result in TARGET, if convenient (and in
3636    mode MODE if that's convenient).  */
3637
3638 static rtx
3639 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
3640 {
3641   tree dst, src;
3642   location_t loc = EXPR_LOCATION (exp);
3643
3644   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3645     return NULL_RTX;
3646
3647   dst = CALL_EXPR_ARG (exp, 0);
3648   src = CALL_EXPR_ARG (exp, 1);
3649
3650   /* If return value is ignored, transform stpcpy into strcpy.  */
3651   if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_STRCPY])
3652     {
3653       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
3654       tree result = build_call_nofold (fn, 2, dst, src);
3655       return expand_expr (result, target, mode, EXPAND_NORMAL);
3656     }
3657   else
3658     {
3659       tree len, lenp1;
3660       rtx ret;
3661
3662       /* Ensure we get an actual string whose length can be evaluated at
3663          compile-time, not an expression containing a string.  This is
3664          because the latter will potentially produce pessimized code
3665          when used to produce the return value.  */
3666       if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3667         return expand_movstr (dst, src, target, /*endp=*/2);
3668
3669       lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
3670       ret = expand_builtin_mempcpy_args (dst, src, lenp1,
3671                                          target, mode, /*endp=*/2);
3672
3673       if (ret)
3674         return ret;
3675
3676       if (TREE_CODE (len) == INTEGER_CST)
3677         {
3678           rtx len_rtx = expand_normal (len);
3679
3680           if (CONST_INT_P (len_rtx))
3681             {
3682               ret = expand_builtin_strcpy_args (dst, src, target);
3683
3684               if (ret)
3685                 {
3686                   if (! target)
3687                     {
3688                       if (mode != VOIDmode)
3689                         target = gen_reg_rtx (mode);
3690                       else
3691                         target = gen_reg_rtx (GET_MODE (ret));
3692                     }
3693                   if (GET_MODE (target) != GET_MODE (ret))
3694                     ret = gen_lowpart (GET_MODE (target), ret);
3695
3696                   ret = plus_constant (ret, INTVAL (len_rtx));
3697                   ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3698                   gcc_assert (ret);
3699
3700                   return target;
3701                 }
3702             }
3703         }
3704
3705       return expand_movstr (dst, src, target, /*endp=*/2);
3706     }
3707 }
3708
3709 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3710    bytes from constant string DATA + OFFSET and return it as target
3711    constant.  */
3712
3713 rtx
3714 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3715                           enum machine_mode mode)
3716 {
3717   const char *str = (const char *) data;
3718
3719   if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3720     return const0_rtx;
3721
3722   return c_readstr (str + offset, mode);
3723 }
3724
3725 /* Expand expression EXP, which is a call to the strncpy builtin.  Return
3726    NULL_RTX if we failed the caller should emit a normal call.  */
3727
3728 static rtx
3729 expand_builtin_strncpy (tree exp, rtx target)
3730 {
3731   location_t loc = EXPR_LOCATION (exp);
3732
3733   if (validate_arglist (exp,
3734                         POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3735     {
3736       tree dest = CALL_EXPR_ARG (exp, 0);
3737       tree src = CALL_EXPR_ARG (exp, 1);
3738       tree len = CALL_EXPR_ARG (exp, 2);
3739       tree slen = c_strlen (src, 1);
3740
3741       /* We must be passed a constant len and src parameter.  */
3742       if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
3743         return NULL_RTX;
3744
3745       slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
3746
3747       /* We're required to pad with trailing zeros if the requested
3748          len is greater than strlen(s2)+1.  In that case try to
3749          use store_by_pieces, if it fails, punt.  */
3750       if (tree_int_cst_lt (slen, len))
3751         {
3752           unsigned int dest_align
3753             = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3754           const char *p = c_getstr (src);
3755           rtx dest_mem;
3756
3757           if (!p || dest_align == 0 || !host_integerp (len, 1)
3758               || !can_store_by_pieces (tree_low_cst (len, 1),
3759                                        builtin_strncpy_read_str,
3760                                        CONST_CAST (char *, p),
3761                                        dest_align, false))
3762             return NULL_RTX;
3763
3764           dest_mem = get_memory_rtx (dest, len);
3765           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3766                            builtin_strncpy_read_str,
3767                            CONST_CAST (char *, p), dest_align, false, 0);
3768           dest_mem = force_operand (XEXP (dest_mem, 0), target);
3769           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3770           return dest_mem;
3771         }
3772     }
3773   return NULL_RTX;
3774 }
3775
3776 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3777    bytes from constant string DATA + OFFSET and return it as target
3778    constant.  */
3779
3780 rtx
3781 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3782                          enum machine_mode mode)
3783 {
3784   const char *c = (const char *) data;
3785   char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode));
3786
3787   memset (p, *c, GET_MODE_SIZE (mode));
3788
3789   return c_readstr (p, mode);
3790 }
3791
3792 /* Callback routine for store_by_pieces.  Return the RTL of a register
3793    containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3794    char value given in the RTL register data.  For example, if mode is
3795    4 bytes wide, return the RTL for 0x01010101*data.  */
3796
3797 static rtx
3798 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3799                         enum machine_mode mode)
3800 {
3801   rtx target, coeff;
3802   size_t size;
3803   char *p;
3804
3805   size = GET_MODE_SIZE (mode);
3806   if (size == 1)
3807     return (rtx) data;
3808
3809   p = XALLOCAVEC (char, size);
3810   memset (p, 1, size);
3811   coeff = c_readstr (p, mode);
3812
3813   target = convert_to_mode (mode, (rtx) data, 1);
3814   target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3815   return force_reg (mode, target);
3816 }
3817
3818 /* Expand expression EXP, which is a call to the memset builtin.  Return
3819    NULL_RTX if we failed the caller should emit a normal call, otherwise
3820    try to get the result in TARGET, if convenient (and in mode MODE if that's
3821    convenient).  */
3822
3823 static rtx
3824 expand_builtin_memset (tree exp, rtx target, enum machine_mode mode)
3825 {
3826   if (!validate_arglist (exp,
3827                          POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3828     return NULL_RTX;
3829   else
3830     {
3831       tree dest = CALL_EXPR_ARG (exp, 0);
3832       tree val = CALL_EXPR_ARG (exp, 1);
3833       tree len = CALL_EXPR_ARG (exp, 2);
3834       return expand_builtin_memset_args (dest, val, len, target, mode, exp);
3835     }
3836 }
3837
3838 /* Helper function to do the actual work for expand_builtin_memset.  The
3839    arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3840    so that this can also be called without constructing an actual CALL_EXPR.
3841    The other arguments and return value are the same as for
3842    expand_builtin_memset.  */
3843
3844 static rtx
3845 expand_builtin_memset_args (tree dest, tree val, tree len,
3846                             rtx target, enum machine_mode mode, tree orig_exp)
3847 {
3848   tree fndecl, fn;
3849   enum built_in_function fcode;
3850   char c;
3851   unsigned int dest_align;
3852   rtx dest_mem, dest_addr, len_rtx;
3853   HOST_WIDE_INT expected_size = -1;
3854   unsigned int expected_align = 0;
3855
3856   dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3857
3858   /* If DEST is not a pointer type, don't do this operation in-line.  */
3859   if (dest_align == 0)
3860     return NULL_RTX;
3861
3862   if (currently_expanding_gimple_stmt)
3863     stringop_block_profile (currently_expanding_gimple_stmt,
3864                             &expected_align, &expected_size);
3865
3866   if (expected_align < dest_align)
3867     expected_align = dest_align;
3868
3869   /* If the LEN parameter is zero, return DEST.  */
3870   if (integer_zerop (len))
3871     {
3872       /* Evaluate and ignore VAL in case it has side-effects.  */
3873       expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3874       return expand_expr (dest, target, mode, EXPAND_NORMAL);
3875     }
3876
3877   /* Stabilize the arguments in case we fail.  */
3878   dest = builtin_save_expr (dest);
3879   val = builtin_save_expr (val);
3880   len = builtin_save_expr (len);
3881
3882   len_rtx = expand_normal (len);
3883   dest_mem = get_memory_rtx (dest, len);
3884
3885   if (TREE_CODE (val) != INTEGER_CST)
3886     {
3887       rtx val_rtx;
3888
3889       val_rtx = expand_normal (val);
3890       val_rtx = convert_to_mode (TYPE_MODE (unsigned_char_type_node),
3891                                  val_rtx, 0);
3892
3893       /* Assume that we can memset by pieces if we can store
3894        * the coefficients by pieces (in the required modes).
3895        * We can't pass builtin_memset_gen_str as that emits RTL.  */
3896       c = 1;
3897       if (host_integerp (len, 1)
3898           && can_store_by_pieces (tree_low_cst (len, 1),
3899                                   builtin_memset_read_str, &c, dest_align,
3900                                   true))
3901         {
3902           val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
3903                                val_rtx);
3904           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3905                            builtin_memset_gen_str, val_rtx, dest_align,
3906                            true, 0);
3907         }
3908       else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
3909                                         dest_align, expected_align,
3910                                         expected_size))
3911         goto do_libcall;
3912
3913       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3914       dest_mem = convert_memory_address (ptr_mode, dest_mem);
3915       return dest_mem;
3916     }
3917
3918   if (target_char_cast (val, &c))
3919     goto do_libcall;
3920
3921   if (c)
3922     {
3923       if (host_integerp (len, 1)
3924           && can_store_by_pieces (tree_low_cst (len, 1),
3925                                   builtin_memset_read_str, &c, dest_align,
3926                                   true))
3927         store_by_pieces (dest_mem, tree_low_cst (len, 1),
3928                          builtin_memset_read_str, &c, dest_align, true, 0);
3929       else if (!set_storage_via_setmem (dest_mem, len_rtx, GEN_INT (c),
3930                                         dest_align, expected_align,
3931                                         expected_size))
3932         goto do_libcall;
3933
3934       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3935       dest_mem = convert_memory_address (ptr_mode, dest_mem);
3936       return dest_mem;
3937     }
3938
3939   set_mem_align (dest_mem, dest_align);
3940   dest_addr = clear_storage_hints (dest_mem, len_rtx,
3941                                    CALL_EXPR_TAILCALL (orig_exp)
3942                                    ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3943                                    expected_align, expected_size);
3944
3945   if (dest_addr == 0)
3946     {
3947       dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3948       dest_addr = convert_memory_address (ptr_mode, dest_addr);
3949     }
3950
3951   return dest_addr;
3952
3953  do_libcall:
3954   fndecl = get_callee_fndecl (orig_exp);
3955   fcode = DECL_FUNCTION_CODE (fndecl);
3956   if (fcode == BUILT_IN_MEMSET)
3957     fn = build_call_nofold (fndecl, 3, dest, val, len);
3958   else if (fcode == BUILT_IN_BZERO)
3959     fn = build_call_nofold (fndecl, 2, dest, len);
3960   else
3961     gcc_unreachable ();
3962   gcc_assert (TREE_CODE (fn) == CALL_EXPR);
3963   CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
3964   return expand_call (fn, target, target == const0_rtx);
3965 }
3966
3967 /* Expand expression EXP, which is a call to the bzero builtin.  Return
3968    NULL_RTX if we failed the caller should emit a normal call.  */
3969
3970 static rtx
3971 expand_builtin_bzero (tree exp)
3972 {
3973   tree dest, size;
3974   location_t loc = EXPR_LOCATION (exp);
3975
3976   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3977     return NULL_RTX;
3978
3979   dest = CALL_EXPR_ARG (exp, 0);
3980   size = CALL_EXPR_ARG (exp, 1);
3981
3982   /* New argument list transforming bzero(ptr x, int y) to
3983      memset(ptr x, int 0, size_t y).   This is done this way
3984      so that if it isn't expanded inline, we fallback to
3985      calling bzero instead of memset.  */
3986
3987   return expand_builtin_memset_args (dest, integer_zero_node,
3988                                      fold_convert_loc (loc, sizetype, size),
3989                                      const0_rtx, VOIDmode, exp);
3990 }
3991
3992 /* Expand expression EXP, which is a call to the memcmp built-in function.
3993    Return NULL_RTX if we failed and the
3994    caller should emit a normal call, otherwise try to get the result in
3995    TARGET, if convenient (and in mode MODE, if that's convenient).  */
3996
3997 static rtx
3998 expand_builtin_memcmp (tree exp, ATTRIBUTE_UNUSED rtx target,
3999                        ATTRIBUTE_UNUSED enum machine_mode mode)
4000 {
4001   location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
4002
4003   if (!validate_arglist (exp,
4004                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4005     return NULL_RTX;
4006
4007 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrnsi
4008   {
4009     rtx arg1_rtx, arg2_rtx, arg3_rtx;
4010     rtx result;
4011     rtx insn;
4012     tree arg1 = CALL_EXPR_ARG (exp, 0);
4013     tree arg2 = CALL_EXPR_ARG (exp, 1);
4014     tree len = CALL_EXPR_ARG (exp, 2);
4015
4016     int arg1_align
4017       = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4018     int arg2_align
4019       = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4020     enum machine_mode insn_mode;
4021
4022 #ifdef HAVE_cmpmemsi
4023     if (HAVE_cmpmemsi)
4024       insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
4025     else
4026 #endif
4027 #ifdef HAVE_cmpstrnsi
4028     if (HAVE_cmpstrnsi)
4029       insn_mode = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4030     else
4031 #endif
4032       return NULL_RTX;
4033
4034     /* If we don't have POINTER_TYPE, call the function.  */
4035     if (arg1_align == 0 || arg2_align == 0)
4036       return NULL_RTX;
4037
4038     /* Make a place to write the result of the instruction.  */
4039     result = target;
4040     if (! (result != 0
4041            && REG_P (result) && GET_MODE (result) == insn_mode
4042            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4043       result = gen_reg_rtx (insn_mode);
4044
4045     arg1_rtx = get_memory_rtx (arg1, len);
4046     arg2_rtx = get_memory_rtx (arg2, len);
4047     arg3_rtx = expand_normal (fold_convert_loc (loc, sizetype, len));
4048
4049     /* Set MEM_SIZE as appropriate.  */
4050     if (CONST_INT_P (arg3_rtx))
4051       {
4052         set_mem_size (arg1_rtx, arg3_rtx);
4053         set_mem_size (arg2_rtx, arg3_rtx);
4054       }
4055
4056 #ifdef HAVE_cmpmemsi
4057     if (HAVE_cmpmemsi)
4058       insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4059                            GEN_INT (MIN (arg1_align, arg2_align)));
4060     else
4061 #endif
4062 #ifdef HAVE_cmpstrnsi
4063     if (HAVE_cmpstrnsi)
4064       insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4065                             GEN_INT (MIN (arg1_align, arg2_align)));
4066     else
4067 #endif
4068       gcc_unreachable ();
4069
4070     if (insn)
4071       emit_insn (insn);
4072     else
4073       emit_library_call_value (memcmp_libfunc, result, LCT_PURE,
4074                                TYPE_MODE (integer_type_node), 3,
4075                                XEXP (arg1_rtx, 0), Pmode,
4076                                XEXP (arg2_rtx, 0), Pmode,
4077                                convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
4078                                                 TYPE_UNSIGNED (sizetype)),
4079                                TYPE_MODE (sizetype));
4080
4081     /* Return the value in the proper mode for this function.  */
4082     mode = TYPE_MODE (TREE_TYPE (exp));
4083     if (GET_MODE (result) == mode)
4084       return result;
4085     else if (target != 0)
4086       {
4087         convert_move (target, result, 0);
4088         return target;
4089       }
4090     else
4091       return convert_to_mode (mode, result, 0);
4092   }
4093 #endif
4094
4095   return NULL_RTX;
4096 }
4097
4098 /* Expand expression EXP, which is a call to the strcmp builtin.  Return NULL_RTX
4099    if we failed the caller should emit a normal call, otherwise try to get
4100    the result in TARGET, if convenient.  */
4101
4102 static rtx
4103 expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target)
4104 {
4105   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4106     return NULL_RTX;
4107
4108 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
4109   if (cmpstr_optab[SImode] != CODE_FOR_nothing
4110       || cmpstrn_optab[SImode] != CODE_FOR_nothing)
4111     {
4112       rtx arg1_rtx, arg2_rtx;
4113       rtx result, insn = NULL_RTX;
4114       tree fndecl, fn;
4115       tree arg1 = CALL_EXPR_ARG (exp, 0);
4116       tree arg2 = CALL_EXPR_ARG (exp, 1);
4117
4118       int arg1_align
4119         = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4120       int arg2_align
4121         = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4122
4123       /* If we don't have POINTER_TYPE, call the function.  */
4124       if (arg1_align == 0 || arg2_align == 0)
4125         return NULL_RTX;
4126
4127       /* Stabilize the arguments in case gen_cmpstr(n)si fail.  */
4128       arg1 = builtin_save_expr (arg1);
4129       arg2 = builtin_save_expr (arg2);
4130
4131       arg1_rtx = get_memory_rtx (arg1, NULL);
4132       arg2_rtx = get_memory_rtx (arg2, NULL);
4133
4134 #ifdef HAVE_cmpstrsi
4135       /* Try to call cmpstrsi.  */
4136       if (HAVE_cmpstrsi)
4137         {
4138           enum machine_mode insn_mode
4139             = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
4140
4141           /* Make a place to write the result of the instruction.  */
4142           result = target;
4143           if (! (result != 0
4144                  && REG_P (result) && GET_MODE (result) == insn_mode
4145                  && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4146             result = gen_reg_rtx (insn_mode);
4147
4148           insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx,
4149                                GEN_INT (MIN (arg1_align, arg2_align)));
4150         }
4151 #endif
4152 #ifdef HAVE_cmpstrnsi
4153       /* Try to determine at least one length and call cmpstrnsi.  */
4154       if (!insn && HAVE_cmpstrnsi)
4155         {
4156           tree len;
4157           rtx arg3_rtx;
4158
4159           enum machine_mode insn_mode
4160             = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4161           tree len1 = c_strlen (arg1, 1);
4162           tree len2 = c_strlen (arg2, 1);
4163
4164           if (len1)
4165             len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
4166           if (len2)
4167             len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
4168
4169           /* If we don't have a constant length for the first, use the length
4170              of the second, if we know it.  We don't require a constant for
4171              this case; some cost analysis could be done if both are available
4172              but neither is constant.  For now, assume they're equally cheap,
4173              unless one has side effects.  If both strings have constant lengths,
4174              use the smaller.  */
4175