projects / gcc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
builtins.c (expand_builtin_setjmp): Delete.
[gcc.git] / 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 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "machmode.h"
27 #include "real.h"
28 #include "rtl.h"
29 #include "tree.h"
30 #include "tree-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
51 #ifndef PAD_VARARGS_DOWN
52 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
53 #endif
54
55 /* Define the names of the builtin function types and codes. */
56 const char *const built_in_class_names[4]
57 = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
58
59 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
60 const char * built_in_names[(int) END_BUILTINS] =
61 {
62 #include "builtins.def"
63 };
64 #undef DEF_BUILTIN
65
66 /* Setup an array of _DECL trees, make sure each element is
67 initialized to NULL_TREE. */
68 tree built_in_decls[(int) END_BUILTINS];
69 /* Declarations used when constructing the builtin implicitly in the compiler.
70 It may be NULL_TREE when this is invalid (for instance runtime is not
71 required to implement the function call in all cases). */
72 tree implicit_built_in_decls[(int) END_BUILTINS];
73
74 static int get_pointer_alignment (tree, unsigned int);
75 static const char *c_getstr (tree);
76 static rtx c_readstr (const char *, enum machine_mode);
77 static int target_char_cast (tree, char *);
78 static rtx get_memory_rtx (tree, tree);
79 static int apply_args_size (void);
80 static int apply_result_size (void);
81 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
82 static rtx result_vector (int, rtx);
83 #endif
84 static void expand_builtin_update_setjmp_buf (rtx);
85 static void expand_builtin_prefetch (tree);
86 static rtx expand_builtin_apply_args (void);
87 static rtx expand_builtin_apply_args_1 (void);
88 static rtx expand_builtin_apply (rtx, rtx, rtx);
89 static void expand_builtin_return (rtx);
90 static enum type_class type_to_class (tree);
91 static rtx expand_builtin_classify_type (tree);
92 static void expand_errno_check (tree, rtx);
93 static rtx expand_builtin_mathfn (tree, rtx, rtx);
94 static rtx expand_builtin_mathfn_2 (tree, rtx, rtx);
95 static rtx expand_builtin_mathfn_3 (tree, rtx, rtx);
96 static rtx expand_builtin_sincos (tree);
97 static rtx expand_builtin_int_roundingfn (tree, rtx, rtx);
98 static rtx expand_builtin_args_info (tree);
99 static rtx expand_builtin_next_arg (void);
100 static rtx expand_builtin_va_start (tree);
101 static rtx expand_builtin_va_end (tree);
102 static rtx expand_builtin_va_copy (tree);
103 static rtx expand_builtin_memcmp (tree, tree, rtx, enum machine_mode);
104 static rtx expand_builtin_strcmp (tree, rtx, enum machine_mode);
105 static rtx expand_builtin_strncmp (tree, rtx, enum machine_mode);
106 static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
107 static rtx expand_builtin_strcat (tree, tree, rtx, enum machine_mode);
108 static rtx expand_builtin_strncat (tree, rtx, enum machine_mode);
109 static rtx expand_builtin_strspn (tree, rtx, enum machine_mode);
110 static rtx expand_builtin_strcspn (tree, rtx, enum machine_mode);
111 static rtx expand_builtin_memcpy (tree, rtx, enum machine_mode);
112 static rtx expand_builtin_mempcpy (tree, tree, rtx, enum machine_mode, int);
113 static rtx expand_builtin_memmove (tree, tree, rtx, enum machine_mode, tree);
114 static rtx expand_builtin_bcopy (tree);
115 static rtx expand_builtin_strcpy (tree, tree, rtx, enum machine_mode);
116 static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode);
117 static rtx builtin_strncpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
118 static rtx expand_builtin_strncpy (tree, rtx, enum machine_mode);
119 static rtx builtin_memset_read_str (void *, HOST_WIDE_INT, enum machine_mode);
120 static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, enum machine_mode);
121 static rtx expand_builtin_memset (tree, rtx, enum machine_mode, tree);
122 static rtx expand_builtin_bzero (tree);
123 static rtx expand_builtin_strlen (tree, rtx, enum machine_mode);
124 static rtx expand_builtin_strstr (tree, tree, rtx, enum machine_mode);
125 static rtx expand_builtin_strpbrk (tree, tree, rtx, enum machine_mode);
126 static rtx expand_builtin_strchr (tree, tree, rtx, enum machine_mode);
127 static rtx expand_builtin_strrchr (tree, tree, rtx, enum machine_mode);
128 static rtx expand_builtin_alloca (tree, rtx);
129 static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);
130 static rtx expand_builtin_frame_address (tree, tree);
131 static rtx expand_builtin_fputs (tree, rtx, bool);
132 static rtx expand_builtin_printf (tree, rtx, enum machine_mode, bool);
133 static rtx expand_builtin_fprintf (tree, rtx, enum machine_mode, bool);
134 static rtx expand_builtin_sprintf (tree, rtx, enum machine_mode);
135 static tree stabilize_va_list (tree, int);
136 static rtx expand_builtin_expect (tree, rtx);
137 static tree fold_builtin_constant_p (tree);
138 static tree fold_builtin_classify_type (tree);
139 static tree fold_builtin_strlen (tree);
140 static tree fold_builtin_inf (tree, int);
141 static tree fold_builtin_nan (tree, tree, int);
142 static int validate_arglist (tree, ...);
143 static bool integer_valued_real_p (tree);
144 static tree fold_trunc_transparent_mathfn (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 (tree, tree);
149 static tree fold_builtin_cbrt (tree, tree);
150 static tree fold_builtin_pow (tree, tree, tree);
151 static tree fold_builtin_powi (tree, tree, tree);
152 static tree fold_builtin_sin (tree);
153 static tree fold_builtin_cos (tree, tree, tree);
154 static tree fold_builtin_tan (tree);
155 static tree fold_builtin_atan (tree, tree);
156 static tree fold_builtin_trunc (tree, tree);
157 static tree fold_builtin_floor (tree, tree);
158 static tree fold_builtin_ceil (tree, tree);
159 static tree fold_builtin_round (tree, tree);
160 static tree fold_builtin_int_roundingfn (tree, tree);
161 static tree fold_builtin_bitop (tree, tree);
162 static tree fold_builtin_memory_op (tree, tree, bool, int);
163 static tree fold_builtin_strchr (tree, tree);
164 static tree fold_builtin_memcmp (tree);
165 static tree fold_builtin_strcmp (tree);
166 static tree fold_builtin_strncmp (tree);
167 static tree fold_builtin_signbit (tree, tree);
168 static tree fold_builtin_copysign (tree, tree, tree);
169 static tree fold_builtin_isascii (tree);
170 static tree fold_builtin_toascii (tree);
171 static tree fold_builtin_isdigit (tree);
172 static tree fold_builtin_fabs (tree, tree);
173 static tree fold_builtin_abs (tree, tree);
174 static tree fold_builtin_unordered_cmp (tree, tree, enum tree_code,
175 enum tree_code);
176 static tree fold_builtin_1 (tree, tree, bool);
177
178 static tree fold_builtin_strpbrk (tree, tree);
179 static tree fold_builtin_strstr (tree, tree);
180 static tree fold_builtin_strrchr (tree, tree);
181 static tree fold_builtin_strcat (tree);
182 static tree fold_builtin_strncat (tree);
183 static tree fold_builtin_strspn (tree);
184 static tree fold_builtin_strcspn (tree);
185 static tree fold_builtin_sprintf (tree, int);
186
187 static rtx expand_builtin_object_size (tree);
188 static rtx expand_builtin_memory_chk (tree, rtx, enum machine_mode,
189 enum built_in_function);
190 static void maybe_emit_chk_warning (tree, enum built_in_function);
191 static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
192 static tree fold_builtin_object_size (tree);
193 static tree fold_builtin_strcat_chk (tree, tree);
194 static tree fold_builtin_strncat_chk (tree, tree);
195 static tree fold_builtin_sprintf_chk (tree, enum built_in_function);
196 static tree fold_builtin_printf (tree, tree, bool, enum built_in_function);
197 static tree fold_builtin_fprintf (tree, tree, bool, enum built_in_function);
198 static bool init_target_chars (void);
199
200 static unsigned HOST_WIDE_INT target_newline;
201 static unsigned HOST_WIDE_INT target_percent;
202 static unsigned HOST_WIDE_INT target_c;
203 static unsigned HOST_WIDE_INT target_s;
204 static char target_percent_c[3];
205 static char target_percent_s[3];
206 static char target_percent_s_newline[4];
207
208 /* Return true if NODE should be considered for inline expansion regardless
209 of the optimization level. This means whenever a function is invoked with
210 its "internal" name, which normally contains the prefix "__builtin". */
211
212 static bool called_as_built_in (tree node)
213 {
214 const char *name = IDENTIFIER_POINTER (DECL_NAME (node));
215 if (strncmp (name, "__builtin_", 10) == 0)
216 return true;
217 if (strncmp (name, "__sync_", 7) == 0)
218 return true;
219 return false;
220 }
221
222 /* Return the alignment in bits of EXP, a pointer valued expression.
223 But don't return more than MAX_ALIGN no matter what.
224 The alignment returned is, by default, the alignment of the thing that
225 EXP points to. If it is not a POINTER_TYPE, 0 is returned.
226
227 Otherwise, look at the expression to see if we can do better, i.e., if the
228 expression is actually pointing at an object whose alignment is tighter. */
229
230 static int
231 get_pointer_alignment (tree exp, unsigned int max_align)
232 {
233 unsigned int align, inner;
234
235 if (! POINTER_TYPE_P (TREE_TYPE (exp)))
236 return 0;
237
238 align = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
239 align = MIN (align, max_align);
240
241 while (1)
242 {
243 switch (TREE_CODE (exp))
244 {
245 case NOP_EXPR:
246 case CONVERT_EXPR:
247 case NON_LVALUE_EXPR:
248 exp = TREE_OPERAND (exp, 0);
249 if (! POINTER_TYPE_P (TREE_TYPE (exp)))
250 return align;
251
252 inner = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
253 align = MIN (inner, max_align);
254 break;
255
256 case PLUS_EXPR:
257 /* If sum of pointer + int, restrict our maximum alignment to that
258 imposed by the integer. If not, we can't do any better than
259 ALIGN. */
260 if (! host_integerp (TREE_OPERAND (exp, 1), 1))
261 return align;
262
263 while (((tree_low_cst (TREE_OPERAND (exp, 1), 1))
264 & (max_align / BITS_PER_UNIT - 1))
265 != 0)
266 max_align >>= 1;
267
268 exp = TREE_OPERAND (exp, 0);
269 break;
270
271 case ADDR_EXPR:
272 /* See what we are pointing at and look at its alignment. */
273 exp = TREE_OPERAND (exp, 0);
274 inner = max_align;
275 if (handled_component_p (exp))
276 {
277 HOST_WIDE_INT bitsize, bitpos;
278 tree offset;
279 enum machine_mode mode;
280 int unsignedp, volatilep;
281
282 exp = get_inner_reference (exp, &bitsize, &bitpos, &offset,
283 &mode, &unsignedp, &volatilep, true);
284 if (bitpos)
285 inner = MIN (inner, (unsigned) (bitpos & -bitpos));
286 if (offset && TREE_CODE (offset) == PLUS_EXPR
287 && host_integerp (TREE_OPERAND (offset, 1), 1))
288 {
289 /* Any overflow in calculating offset_bits won't change
290 the alignment. */
291 unsigned offset_bits
292 = ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)
293 * BITS_PER_UNIT);
294
295 if (offset_bits)
296 inner = MIN (inner, (offset_bits & -offset_bits));
297 offset = TREE_OPERAND (offset, 0);
298 }
299 if (offset && TREE_CODE (offset) == MULT_EXPR
300 && host_integerp (TREE_OPERAND (offset, 1), 1))
301 {
302 /* Any overflow in calculating offset_factor won't change
303 the alignment. */
304 unsigned offset_factor
305 = ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)
306 * BITS_PER_UNIT);
307
308 if (offset_factor)
309 inner = MIN (inner, (offset_factor & -offset_factor));
310 }
311 else if (offset)
312 inner = MIN (inner, BITS_PER_UNIT);
313 }
314 if (TREE_CODE (exp) == FUNCTION_DECL)
315 align = FUNCTION_BOUNDARY;
316 else if (DECL_P (exp))
317 align = MIN (inner, DECL_ALIGN (exp));
318 #ifdef CONSTANT_ALIGNMENT
319 else if (CONSTANT_CLASS_P (exp))
320 align = MIN (inner, (unsigned)CONSTANT_ALIGNMENT (exp, align));
321 #endif
322 else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR
323 || TREE_CODE (exp) == INDIRECT_REF)
324 align = MIN (TYPE_ALIGN (TREE_TYPE (exp)), inner);
325 else
326 align = MIN (align, inner);
327 return MIN (align, max_align);
328
329 default:
330 return align;
331 }
332 }
333 }
334
335 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
336 way, because it could contain a zero byte in the middle.
337 TREE_STRING_LENGTH is the size of the character array, not the string.
338
339 ONLY_VALUE should be nonzero if the result is not going to be emitted
340 into the instruction stream and zero if it is going to be expanded.
341 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
342 is returned, otherwise NULL, since
343 len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
344 evaluate the side-effects.
345
346 The value returned is of type `ssizetype'.
347
348 Unfortunately, string_constant can't access the values of const char
349 arrays with initializers, so neither can we do so here. */
350
351 tree
352 c_strlen (tree src, int only_value)
353 {
354 tree offset_node;
355 HOST_WIDE_INT offset;
356 int max;
357 const char *ptr;
358
359 STRIP_NOPS (src);
360 if (TREE_CODE (src) == COND_EXPR
361 && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
362 {
363 tree len1, len2;
364
365 len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
366 len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
367 if (tree_int_cst_equal (len1, len2))
368 return len1;
369 }
370
371 if (TREE_CODE (src) == COMPOUND_EXPR
372 && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
373 return c_strlen (TREE_OPERAND (src, 1), only_value);
374
375 src = string_constant (src, &offset_node);
376 if (src == 0)
377 return 0;
378
379 max = TREE_STRING_LENGTH (src) - 1;
380 ptr = TREE_STRING_POINTER (src);
381
382 if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
383 {
384 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
385 compute the offset to the following null if we don't know where to
386 start searching for it. */
387 int i;
388
389 for (i = 0; i < max; i++)
390 if (ptr[i] == 0)
391 return 0;
392
393 /* We don't know the starting offset, but we do know that the string
394 has no internal zero bytes. We can assume that the offset falls
395 within the bounds of the string; otherwise, the programmer deserves
396 what he gets. Subtract the offset from the length of the string,
397 and return that. This would perhaps not be valid if we were dealing
398 with named arrays in addition to literal string constants. */
399
400 return size_diffop (size_int (max), offset_node);
401 }
402
403 /* We have a known offset into the string. Start searching there for
404 a null character if we can represent it as a single HOST_WIDE_INT. */
405 if (offset_node == 0)
406 offset = 0;
407 else if (! host_integerp (offset_node, 0))
408 offset = -1;
409 else
410 offset = tree_low_cst (offset_node, 0);
411
412 /* If the offset is known to be out of bounds, warn, and call strlen at
413 runtime. */
414 if (offset < 0 || offset > max)
415 {
416 warning (0, "offset outside bounds of constant string");
417 return 0;
418 }
419
420 /* Use strlen to search for the first zero byte. Since any strings
421 constructed with build_string will have nulls appended, we win even
422 if we get handed something like (char[4])"abcd".
423
424 Since OFFSET is our starting index into the string, no further
425 calculation is needed. */
426 return ssize_int (strlen (ptr + offset));
427 }
428
429 /* Return a char pointer for a C string if it is a string constant
430 or sum of string constant and integer constant. */
431
432 static const char *
433 c_getstr (tree src)
434 {
435 tree offset_node;
436
437 src = string_constant (src, &offset_node);
438 if (src == 0)
439 return 0;
440
441 if (offset_node == 0)
442 return TREE_STRING_POINTER (src);
443 else if (!host_integerp (offset_node, 1)
444 || compare_tree_int (offset_node, TREE_STRING_LENGTH (src) - 1) > 0)
445 return 0;
446
447 return TREE_STRING_POINTER (src) + tree_low_cst (offset_node, 1);
448 }
449
450 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
451 GET_MODE_BITSIZE (MODE) bits from string constant STR. */
452
453 static rtx
454 c_readstr (const char *str, enum machine_mode mode)
455 {
456 HOST_WIDE_INT c[2];
457 HOST_WIDE_INT ch;
458 unsigned int i, j;
459
460 gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
461
462 c[0] = 0;
463 c[1] = 0;
464 ch = 1;
465 for (i = 0; i < GET_MODE_SIZE (mode); i++)
466 {
467 j = i;
468 if (WORDS_BIG_ENDIAN)
469 j = GET_MODE_SIZE (mode) - i - 1;
470 if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
471 && GET_MODE_SIZE (mode) > UNITS_PER_WORD)
472 j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
473 j *= BITS_PER_UNIT;
474 gcc_assert (j <= 2 * HOST_BITS_PER_WIDE_INT);
475
476 if (ch)
477 ch = (unsigned char) str[i];
478 c[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
479 }
480 return immed_double_const (c[0], c[1], mode);
481 }
482
483 /* Cast a target constant CST to target CHAR and if that value fits into
484 host char type, return zero and put that value into variable pointed to by
485 P. */
486
487 static int
488 target_char_cast (tree cst, char *p)
489 {
490 unsigned HOST_WIDE_INT val, hostval;
491
492 if (!host_integerp (cst, 1)
493 || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
494 return 1;
495
496 val = tree_low_cst (cst, 1);
497 if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
498 val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
499
500 hostval = val;
501 if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
502 hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
503
504 if (val != hostval)
505 return 1;
506
507 *p = hostval;
508 return 0;
509 }
510
511 /* Similar to save_expr, but assumes that arbitrary code is not executed
512 in between the multiple evaluations. In particular, we assume that a
513 non-addressable local variable will not be modified. */
514
515 static tree
516 builtin_save_expr (tree exp)
517 {
518 if (TREE_ADDRESSABLE (exp) == 0
519 && (TREE_CODE (exp) == PARM_DECL
520 || (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp))))
521 return exp;
522
523 return save_expr (exp);
524 }
525
526 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
527 times to get the address of either a higher stack frame, or a return
528 address located within it (depending on FNDECL_CODE). */
529
530 static rtx
531 expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
532 {
533 int i;
534
535 #ifdef INITIAL_FRAME_ADDRESS_RTX
536 rtx tem = INITIAL_FRAME_ADDRESS_RTX;
537 #else
538 rtx tem;
539
540 /* For a zero count with __builtin_return_address, we don't care what
541 frame address we return, because target-specific definitions will
542 override us. Therefore frame pointer elimination is OK, and using
543 the soft frame pointer is OK.
544
545 For a non-zero count, or a zero count with __builtin_frame_address,
546 we require a stable offset from the current frame pointer to the
547 previous one, so we must use the hard frame pointer, and
548 we must disable frame pointer elimination. */
549 if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)
550 tem = frame_pointer_rtx;
551 else
552 {
553 tem = hard_frame_pointer_rtx;
554
555 /* Tell reload not to eliminate the frame pointer. */
556 current_function_accesses_prior_frames = 1;
557 }
558 #endif
559
560 /* Some machines need special handling before we can access
561 arbitrary frames. For example, on the sparc, we must first flush
562 all register windows to the stack. */
563 #ifdef SETUP_FRAME_ADDRESSES
564 if (count > 0)
565 SETUP_FRAME_ADDRESSES ();
566 #endif
567
568 /* On the sparc, the return address is not in the frame, it is in a
569 register. There is no way to access it off of the current frame
570 pointer, but it can be accessed off the previous frame pointer by
571 reading the value from the register window save area. */
572 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
573 if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
574 count--;
575 #endif
576
577 /* Scan back COUNT frames to the specified frame. */
578 for (i = 0; i < count; i++)
579 {
580 /* Assume the dynamic chain pointer is in the word that the
581 frame address points to, unless otherwise specified. */
582 #ifdef DYNAMIC_CHAIN_ADDRESS
583 tem = DYNAMIC_CHAIN_ADDRESS (tem);
584 #endif
585 tem = memory_address (Pmode, tem);
586 tem = gen_frame_mem (Pmode, tem);
587 tem = copy_to_reg (tem);
588 }
589
590 /* For __builtin_frame_address, return what we've got. */
591 if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
592 return tem;
593
594 /* For __builtin_return_address, Get the return address from that
595 frame. */
596 #ifdef RETURN_ADDR_RTX
597 tem = RETURN_ADDR_RTX (count, tem);
598 #else
599 tem = memory_address (Pmode,
600 plus_constant (tem, GET_MODE_SIZE (Pmode)));
601 tem = gen_frame_mem (Pmode, tem);
602 #endif
603 return tem;
604 }
605
606 /* Alias set used for setjmp buffer. */
607 static HOST_WIDE_INT setjmp_alias_set = -1;
608
609 /* Construct the leading half of a __builtin_setjmp call. Control will
610 return to RECEIVER_LABEL. This is also called directly by the SJLJ
611 exception handling code. */
612
613 void
614 expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
615 {
616 enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
617 rtx stack_save;
618 rtx mem;
619
620 if (setjmp_alias_set == -1)
621 setjmp_alias_set = new_alias_set ();
622
623 buf_addr = convert_memory_address (Pmode, buf_addr);
624
625 buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
626
627 /* We store the frame pointer and the address of receiver_label in
628 the buffer and use the rest of it for the stack save area, which
629 is machine-dependent. */
630
631 mem = gen_rtx_MEM (Pmode, buf_addr);
632 set_mem_alias_set (mem, setjmp_alias_set);
633 emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());
634
635 mem = gen_rtx_MEM (Pmode, plus_constant (buf_addr, GET_MODE_SIZE (Pmode))),
636 set_mem_alias_set (mem, setjmp_alias_set);
637
638 emit_move_insn (validize_mem (mem),
639 force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
640
641 stack_save = gen_rtx_MEM (sa_mode,
642 plus_constant (buf_addr,
643 2 * GET_MODE_SIZE (Pmode)));
644 set_mem_alias_set (stack_save, setjmp_alias_set);
645 emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
646
647 /* If there is further processing to do, do it. */
648 #ifdef HAVE_builtin_setjmp_setup
649 if (HAVE_builtin_setjmp_setup)
650 emit_insn (gen_builtin_setjmp_setup (buf_addr));
651 #endif
652
653 /* Tell optimize_save_area_alloca that extra work is going to
654 need to go on during alloca. */
655 current_function_calls_setjmp = 1;
656
657 /* Set this so all the registers get saved in our frame; we need to be
658 able to copy the saved values for any registers from frames we unwind. */
659 current_function_has_nonlocal_label = 1;
660 }
661
662 /* Construct the trailing part of a __builtin_setjmp call. This is
663 also called directly by the SJLJ exception handling code. */
664
665 void
666 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED)
667 {
668 /* Clobber the FP when we get here, so we have to make sure it's
669 marked as used by this function. */
670 emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
671
672 /* Mark the static chain as clobbered here so life information
673 doesn't get messed up for it. */
674 emit_insn (gen_rtx_CLOBBER (VOIDmode, static_chain_rtx));
675
676 /* Now put in the code to restore the frame pointer, and argument
677 pointer, if needed. */
678 #ifdef HAVE_nonlocal_goto
679 if (! HAVE_nonlocal_goto)
680 #endif
681 {
682 emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
683 /* This might change the hard frame pointer in ways that aren't
684 apparent to early optimization passes, so force a clobber. */
685 emit_insn (gen_rtx_CLOBBER (VOIDmode, hard_frame_pointer_rtx));
686 }
687
688 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
689 if (fixed_regs[ARG_POINTER_REGNUM])
690 {
691 #ifdef ELIMINABLE_REGS
692 size_t i;
693 static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
694
695 for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
696 if (elim_regs[i].from == ARG_POINTER_REGNUM
697 && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
698 break;
699
700 if (i == ARRAY_SIZE (elim_regs))
701 #endif
702 {
703 /* Now restore our arg pointer from the address at which it
704 was saved in our stack frame. */
705 emit_move_insn (virtual_incoming_args_rtx,
706 copy_to_reg (get_arg_pointer_save_area (cfun)));
707 }
708 }
709 #endif
710
711 #ifdef HAVE_builtin_setjmp_receiver
712 if (HAVE_builtin_setjmp_receiver)
713 emit_insn (gen_builtin_setjmp_receiver (receiver_label));
714 else
715 #endif
716 #ifdef HAVE_nonlocal_goto_receiver
717 if (HAVE_nonlocal_goto_receiver)
718 emit_insn (gen_nonlocal_goto_receiver ());
719 else
720 #endif
721 { /* Nothing */ }
722
723 /* @@@ This is a kludge. Not all machine descriptions define a blockage
724 insn, but we must not allow the code we just generated to be reordered
725 by scheduling. Specifically, the update of the frame pointer must
726 happen immediately, not later. So emit an ASM_INPUT to act as blockage
727 insn. */
728 emit_insn (gen_rtx_ASM_INPUT (VOIDmode, ""));
729 }
730
731 /* __builtin_longjmp is passed a pointer to an array of five words (not
732 all will be used on all machines). It operates similarly to the C
733 library function of the same name, but is more efficient. Much of
734 the code below is copied from the handling of non-local gotos. */
735
736 static void
737 expand_builtin_longjmp (rtx buf_addr, rtx value)
738 {
739 rtx fp, lab, stack, insn, last;
740 enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
741
742 if (setjmp_alias_set == -1)
743 setjmp_alias_set = new_alias_set ();
744
745 buf_addr = convert_memory_address (Pmode, buf_addr);
746
747 buf_addr = force_reg (Pmode, buf_addr);
748
749 /* We used to store value in static_chain_rtx, but that fails if pointers
750 are smaller than integers. We instead require that the user must pass
751 a second argument of 1, because that is what builtin_setjmp will
752 return. This also makes EH slightly more efficient, since we are no
753 longer copying around a value that we don't care about. */
754 gcc_assert (value == const1_rtx);
755
756 last = get_last_insn ();
757 #ifdef HAVE_builtin_longjmp
758 if (HAVE_builtin_longjmp)
759 emit_insn (gen_builtin_longjmp (buf_addr));
760 else
761 #endif
762 {
763 fp = gen_rtx_MEM (Pmode, buf_addr);
764 lab = gen_rtx_MEM (Pmode, plus_constant (buf_addr,
765 GET_MODE_SIZE (Pmode)));
766
767 stack = gen_rtx_MEM (sa_mode, plus_constant (buf_addr,
768 2 * GET_MODE_SIZE (Pmode)));
769 set_mem_alias_set (fp, setjmp_alias_set);
770 set_mem_alias_set (lab, setjmp_alias_set);
771 set_mem_alias_set (stack, setjmp_alias_set);
772
773 /* Pick up FP, label, and SP from the block and jump. This code is
774 from expand_goto in stmt.c; see there for detailed comments. */
775 #ifdef HAVE_nonlocal_goto
776 if (HAVE_nonlocal_goto)
777 /* We have to pass a value to the nonlocal_goto pattern that will
778 get copied into the static_chain pointer, but it does not matter
779 what that value is, because builtin_setjmp does not use it. */
780 emit_insn (gen_nonlocal_goto (value, lab, stack, fp));
781 else
782 #endif
783 {
784 lab = copy_to_reg (lab);
785
786 emit_insn (gen_rtx_CLOBBER (VOIDmode,
787 gen_rtx_MEM (BLKmode,
788 gen_rtx_SCRATCH (VOIDmode))));
789 emit_insn (gen_rtx_CLOBBER (VOIDmode,
790 gen_rtx_MEM (BLKmode,
791 hard_frame_pointer_rtx)));
792
793 emit_move_insn (hard_frame_pointer_rtx, fp);
794 emit_stack_restore (SAVE_NONLOCAL, stack, NULL_RTX);
795
796 emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
797 emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
798 emit_indirect_jump (lab);
799 }
800 }
801
802 /* Search backwards and mark the jump insn as a non-local goto.
803 Note that this precludes the use of __builtin_longjmp to a
804 __builtin_setjmp target in the same function. However, we've
805 already cautioned the user that these functions are for
806 internal exception handling use only. */
807 for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
808 {
809 gcc_assert (insn != last);
810
811 if (JUMP_P (insn))
812 {
813 REG_NOTES (insn) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO, const0_rtx,
814 REG_NOTES (insn));
815 break;
816 }
817 else if (CALL_P (insn))
818 break;
819 }
820 }
821
822 /* Expand a call to __builtin_nonlocal_goto. We're passed the target label
823 and the address of the save area. */
824
825 static rtx
826 expand_builtin_nonlocal_goto (tree arglist)
827 {
828 tree t_label, t_save_area;
829 rtx r_label, r_save_area, r_fp, r_sp, insn;
830
831 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
832 return NULL_RTX;
833
834 t_label = TREE_VALUE (arglist);
835 arglist = TREE_CHAIN (arglist);
836 t_save_area = TREE_VALUE (arglist);
837
838 r_label = expand_normal (t_label);
839 r_label = convert_memory_address (Pmode, r_label);
840 r_save_area = expand_normal (t_save_area);
841 r_save_area = convert_memory_address (Pmode, r_save_area);
842 r_fp = gen_rtx_MEM (Pmode, r_save_area);
843 r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL),
844 plus_constant (r_save_area, GET_MODE_SIZE (Pmode)));
845
846 current_function_has_nonlocal_goto = 1;
847
848 #ifdef HAVE_nonlocal_goto
849 /* ??? We no longer need to pass the static chain value, afaik. */
850 if (HAVE_nonlocal_goto)
851 emit_insn (gen_nonlocal_goto (const0_rtx, r_label, r_sp, r_fp));
852 else
853 #endif
854 {
855 r_label = copy_to_reg (r_label);
856
857 emit_insn (gen_rtx_CLOBBER (VOIDmode,
858 gen_rtx_MEM (BLKmode,
859 gen_rtx_SCRATCH (VOIDmode))));
860
861 emit_insn (gen_rtx_CLOBBER (VOIDmode,
862 gen_rtx_MEM (BLKmode,
863 hard_frame_pointer_rtx)));
864
865 /* Restore frame pointer for containing function.
866 This sets the actual hard register used for the frame pointer
867 to the location of the function's incoming static chain info.
868 The non-local goto handler will then adjust it to contain the
869 proper value and reload the argument pointer, if needed. */
870 emit_move_insn (hard_frame_pointer_rtx, r_fp);
871 emit_stack_restore (SAVE_NONLOCAL, r_sp, NULL_RTX);
872
873 /* USE of hard_frame_pointer_rtx added for consistency;
874 not clear if really needed. */
875 emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
876 emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
877 emit_indirect_jump (r_label);
878 }
879
880 /* Search backwards to the jump insn and mark it as a
881 non-local goto. */
882 for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
883 {
884 if (JUMP_P (insn))
885 {
886 REG_NOTES (insn) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO,
887 const0_rtx, REG_NOTES (insn));
888 break;
889 }
890 else if (CALL_P (insn))
891 break;
892 }
893
894 return const0_rtx;
895 }
896
897 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
898 (not all will be used on all machines) that was passed to __builtin_setjmp.
899 It updates the stack pointer in that block to correspond to the current
900 stack pointer. */
901
902 static void
903 expand_builtin_update_setjmp_buf (rtx buf_addr)
904 {
905 enum machine_mode sa_mode = Pmode;
906 rtx stack_save;
907
908
909 #ifdef HAVE_save_stack_nonlocal
910 if (HAVE_save_stack_nonlocal)
911 sa_mode = insn_data[(int) CODE_FOR_save_stack_nonlocal].operand[0].mode;
912 #endif
913 #ifdef STACK_SAVEAREA_MODE
914 sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
915 #endif
916
917 stack_save
918 = gen_rtx_MEM (sa_mode,
919 memory_address
920 (sa_mode,
921 plus_constant (buf_addr, 2 * GET_MODE_SIZE (Pmode))));
922
923 #ifdef HAVE_setjmp
924 if (HAVE_setjmp)
925 emit_insn (gen_setjmp ());
926 #endif
927
928 emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
929 }
930
931 /* Expand a call to __builtin_prefetch. For a target that does not support
932 data prefetch, evaluate the memory address argument in case it has side
933 effects. */
934
935 static void
936 expand_builtin_prefetch (tree arglist)
937 {
938 tree arg0, arg1, arg2;
939 rtx op0, op1, op2;
940
941 if (!validate_arglist (arglist, POINTER_TYPE, 0))
942 return;
943
944 arg0 = TREE_VALUE (arglist);
945 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
946 zero (read) and argument 2 (locality) defaults to 3 (high degree of
947 locality). */
948 if (TREE_CHAIN (arglist))
949 {
950 arg1 = TREE_VALUE (TREE_CHAIN (arglist));
951 if (TREE_CHAIN (TREE_CHAIN (arglist)))
952 arg2 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
953 else
954 arg2 = build_int_cst (NULL_TREE, 3);
955 }
956 else
957 {
958 arg1 = integer_zero_node;
959 arg2 = build_int_cst (NULL_TREE, 3);
960 }
961
962 /* Argument 0 is an address. */
963 op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
964
965 /* Argument 1 (read/write flag) must be a compile-time constant int. */
966 if (TREE_CODE (arg1) != INTEGER_CST)
967 {
968 error ("second argument to %<__builtin_prefetch%> must be a constant");
969 arg1 = integer_zero_node;
970 }
971 op1 = expand_normal (arg1);
972 /* Argument 1 must be either zero or one. */
973 if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
974 {
975 warning (0, "invalid second argument to %<__builtin_prefetch%>;"
976 " using zero");
977 op1 = const0_rtx;
978 }
979
980 /* Argument 2 (locality) must be a compile-time constant int. */
981 if (TREE_CODE (arg2) != INTEGER_CST)
982 {
983 error ("third argument to %<__builtin_prefetch%> must be a constant");
984 arg2 = integer_zero_node;
985 }
986 op2 = expand_normal (arg2);
987 /* Argument 2 must be 0, 1, 2, or 3. */
988 if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
989 {
990 warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
991 op2 = const0_rtx;
992 }
993
994 #ifdef HAVE_prefetch
995 if (HAVE_prefetch)
996 {
997 if ((! (*insn_data[(int) CODE_FOR_prefetch].operand[0].predicate)
998 (op0,
999 insn_data[(int) CODE_FOR_prefetch].operand[0].mode))
1000 || (GET_MODE (op0) != Pmode))
1001 {
1002 op0 = convert_memory_address (Pmode, op0);
1003 op0 = force_reg (Pmode, op0);
1004 }
1005 emit_insn (gen_prefetch (op0, op1, op2));
1006 }
1007 #endif
1008
1009 /* Don't do anything with direct references to volatile memory, but
1010 generate code to handle other side effects. */
1011 if (!MEM_P (op0) && side_effects_p (op0))
1012 emit_insn (op0);
1013 }
1014
1015 /* Get a MEM rtx for expression EXP which is the address of an operand
1016 to be used in a string instruction (cmpstrsi, movmemsi, ..). LEN is
1017 the maximum length of the block of memory that might be accessed or
1018 NULL if unknown. */
1019
1020 static rtx
1021 get_memory_rtx (tree exp, tree len)
1022 {
1023 rtx addr = expand_expr (exp, NULL_RTX, ptr_mode, EXPAND_NORMAL);
1024 rtx mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
1025
1026 /* Get an expression we can use to find the attributes to assign to MEM.
1027 If it is an ADDR_EXPR, use the operand. Otherwise, dereference it if
1028 we can. First remove any nops. */
1029 while ((TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
1030 || TREE_CODE (exp) == NON_LVALUE_EXPR)
1031 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
1032 exp = TREE_OPERAND (exp, 0);
1033
1034 if (TREE_CODE (exp) == ADDR_EXPR)
1035 exp = TREE_OPERAND (exp, 0);
1036 else if (POINTER_TYPE_P (TREE_TYPE (exp)))
1037 exp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (exp)), exp);
1038 else
1039 exp = NULL;
1040
1041 /* Honor attributes derived from exp, except for the alias set
1042 (as builtin stringops may alias with anything) and the size
1043 (as stringops may access multiple array elements). */
1044 if (exp)
1045 {
1046 set_mem_attributes (mem, exp, 0);
1047
1048 /* Allow the string and memory builtins to overflow from one
1049 field into another, see http://gcc.gnu.org/PR23561.
1050 Thus avoid COMPONENT_REFs in MEM_EXPR unless we know the whole
1051 memory accessed by the string or memory builtin will fit
1052 within the field. */
1053 if (MEM_EXPR (mem) && TREE_CODE (MEM_EXPR (mem)) == COMPONENT_REF)
1054 {
1055 tree mem_expr = MEM_EXPR (mem);
1056 HOST_WIDE_INT offset = -1, length = -1;
1057 tree inner = exp;
1058
1059 while (TREE_CODE (inner) == ARRAY_REF
1060 || TREE_CODE (inner) == NOP_EXPR
1061 || TREE_CODE (inner) == CONVERT_EXPR
1062 || TREE_CODE (inner) == NON_LVALUE_EXPR
1063 || TREE_CODE (inner) == VIEW_CONVERT_EXPR
1064 || TREE_CODE (inner) == SAVE_EXPR)
1065 inner = TREE_OPERAND (inner, 0);
1066
1067 gcc_assert (TREE_CODE (inner) == COMPONENT_REF);
1068
1069 if (MEM_OFFSET (mem)
1070 && GET_CODE (MEM_OFFSET (mem)) == CONST_INT)
1071 offset = INTVAL (MEM_OFFSET (mem));
1072
1073 if (offset >= 0 && len && host_integerp (len, 0))
1074 length = tree_low_cst (len, 0);
1075
1076 while (TREE_CODE (inner) == COMPONENT_REF)
1077 {
1078 tree field = TREE_OPERAND (inner, 1);
1079 gcc_assert (! DECL_BIT_FIELD (field));
1080 gcc_assert (TREE_CODE (mem_expr) == COMPONENT_REF);
1081 gcc_assert (field == TREE_OPERAND (mem_expr, 1));
1082
1083 if (length >= 0
1084 && TYPE_SIZE_UNIT (TREE_TYPE (inner))
1085 && host_integerp (TYPE_SIZE_UNIT (TREE_TYPE (inner)), 0))
1086 {
1087 HOST_WIDE_INT size
1088 = tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (inner)), 0);
1089 /* If we can prove the memory starting at XEXP (mem, 0)
1090 and ending at XEXP (mem, 0) + LENGTH will fit into
1091 this field, we can keep that COMPONENT_REF in MEM_EXPR. */
1092 if (offset <= size
1093 && length <= size
1094 && offset + length <= size)
1095 break;
1096 }
1097
1098 if (offset >= 0
1099 && host_integerp (DECL_FIELD_OFFSET (field), 0))
1100 offset += tree_low_cst (DECL_FIELD_OFFSET (field), 0)
1101 + tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1102 / BITS_PER_UNIT;
1103 else
1104 {
1105 offset = -1;
1106 length = -1;
1107 }
1108
1109 mem_expr = TREE_OPERAND (mem_expr, 0);
1110 inner = TREE_OPERAND (inner, 0);
1111 }
1112
1113 if (mem_expr == NULL)
1114 offset = -1;
1115 if (mem_expr != MEM_EXPR (mem))
1116 {
1117 set_mem_expr (mem, mem_expr);
1118 set_mem_offset (mem, offset >= 0 ? GEN_INT (offset) : NULL_RTX);
1119 }
1120 }
1121 set_mem_alias_set (mem, 0);
1122 set_mem_size (mem, NULL_RTX);
1123 }
1124
1125 return mem;
1126 }
1127 \f
1128 /* Built-in functions to perform an untyped call and return. */
1129
1130 /* For each register that may be used for calling a function, this
1131 gives a mode used to copy the register's value. VOIDmode indicates
1132 the register is not used for calling a function. If the machine
1133 has register windows, this gives only the outbound registers.
1134 INCOMING_REGNO gives the corresponding inbound register. */
1135 static enum machine_mode apply_args_mode[FIRST_PSEUDO_REGISTER];
1136
1137 /* For each register that may be used for returning values, this gives
1138 a mode used to copy the register's value. VOIDmode indicates the
1139 register is not used for returning values. If the machine has
1140 register windows, this gives only the outbound registers.
1141 INCOMING_REGNO gives the corresponding inbound register. */
1142 static enum machine_mode apply_result_mode[FIRST_PSEUDO_REGISTER];
1143
1144 /* For each register that may be used for calling a function, this
1145 gives the offset of that register into the block returned by
1146 __builtin_apply_args. 0 indicates that the register is not
1147 used for calling a function. */
1148 static int apply_args_reg_offset[FIRST_PSEUDO_REGISTER];
1149
1150 /* Return the size required for the block returned by __builtin_apply_args,
1151 and initialize apply_args_mode. */
1152
1153 static int
1154 apply_args_size (void)
1155 {
1156 static int size = -1;
1157 int align;
1158 unsigned int regno;
1159 enum machine_mode mode;
1160
1161 /* The values computed by this function never change. */
1162 if (size < 0)
1163 {
1164 /* The first value is the incoming arg-pointer. */
1165 size = GET_MODE_SIZE (Pmode);
1166
1167 /* The second value is the structure value address unless this is
1168 passed as an "invisible" first argument. */
1169 if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1170 size += GET_MODE_SIZE (Pmode);
1171
1172 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1173 if (FUNCTION_ARG_REGNO_P (regno))
1174 {
1175 mode = reg_raw_mode[regno];
1176
1177 gcc_assert (mode != VOIDmode);
1178
1179 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1180 if (size % align != 0)
1181 size = CEIL (size, align) * align;
1182 apply_args_reg_offset[regno] = size;
1183 size += GET_MODE_SIZE (mode);
1184 apply_args_mode[regno] = mode;
1185 }
1186 else
1187 {
1188 apply_args_mode[regno] = VOIDmode;
1189 apply_args_reg_offset[regno] = 0;
1190 }
1191 }
1192 return size;
1193 }
1194
1195 /* Return the size required for the block returned by __builtin_apply,
1196 and initialize apply_result_mode. */
1197
1198 static int
1199 apply_result_size (void)
1200 {
1201 static int size = -1;
1202 int align, regno;
1203 enum machine_mode mode;
1204
1205 /* The values computed by this function never change. */
1206 if (size < 0)
1207 {
1208 size = 0;
1209
1210 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1211 if (FUNCTION_VALUE_REGNO_P (regno))
1212 {
1213 mode = reg_raw_mode[regno];
1214
1215 gcc_assert (mode != VOIDmode);
1216
1217 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1218 if (size % align != 0)
1219 size = CEIL (size, align) * align;
1220 size += GET_MODE_SIZE (mode);
1221 apply_result_mode[regno] = mode;
1222 }
1223 else
1224 apply_result_mode[regno] = VOIDmode;
1225
1226 /* Allow targets that use untyped_call and untyped_return to override
1227 the size so that machine-specific information can be stored here. */
1228 #ifdef APPLY_RESULT_SIZE
1229 size = APPLY_RESULT_SIZE;
1230 #endif
1231 }
1232 return size;
1233 }
1234
1235 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1236 /* Create a vector describing the result block RESULT. If SAVEP is true,
1237 the result block is used to save the values; otherwise it is used to
1238 restore the values. */
1239
1240 static rtx
1241 result_vector (int savep, rtx result)
1242 {
1243 int regno, size, align, nelts;
1244 enum machine_mode mode;
1245 rtx reg, mem;
1246 rtx *savevec = alloca (FIRST_PSEUDO_REGISTER * sizeof (rtx));
1247
1248 size = nelts = 0;
1249 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1250 if ((mode = apply_result_mode[regno]) != VOIDmode)
1251 {
1252 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1253 if (size % align != 0)
1254 size = CEIL (size, align) * align;
1255 reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1256 mem = adjust_address (result, mode, size);
1257 savevec[nelts++] = (savep
1258 ? gen_rtx_SET (VOIDmode, mem, reg)
1259 : gen_rtx_SET (VOIDmode, reg, mem));
1260 size += GET_MODE_SIZE (mode);
1261 }
1262 return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1263 }
1264 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1265
1266 /* Save the state required to perform an untyped call with the same
1267 arguments as were passed to the current function. */
1268
1269 static rtx
1270 expand_builtin_apply_args_1 (void)
1271 {
1272 rtx registers, tem;
1273 int size, align, regno;
1274 enum machine_mode mode;
1275 rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1276
1277 /* Create a block where the arg-pointer, structure value address,
1278 and argument registers can be saved. */
1279 registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1280
1281 /* Walk past the arg-pointer and structure value address. */
1282 size = GET_MODE_SIZE (Pmode);
1283 if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1284 size += GET_MODE_SIZE (Pmode);
1285
1286 /* Save each register used in calling a function to the block. */
1287 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1288 if ((mode = apply_args_mode[regno]) != VOIDmode)
1289 {
1290 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1291 if (size % align != 0)
1292 size = CEIL (size, align) * align;
1293
1294 tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1295
1296 emit_move_insn (adjust_address (registers, mode, size), tem);
1297 size += GET_MODE_SIZE (mode);
1298 }
1299
1300 /* Save the arg pointer to the block. */
1301 tem = copy_to_reg (virtual_incoming_args_rtx);
1302 #ifdef STACK_GROWS_DOWNWARD
1303 /* We need the pointer as the caller actually passed them to us, not
1304 as we might have pretended they were passed. Make sure it's a valid
1305 operand, as emit_move_insn isn't expected to handle a PLUS. */
1306 tem
1307 = force_operand (plus_constant (tem, current_function_pretend_args_size),
1308 NULL_RTX);
1309 #endif
1310 emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1311
1312 size = GET_MODE_SIZE (Pmode);
1313
1314 /* Save the structure value address unless this is passed as an
1315 "invisible" first argument. */
1316 if (struct_incoming_value)
1317 {
1318 emit_move_insn (adjust_address (registers, Pmode, size),
1319 copy_to_reg (struct_incoming_value));
1320 size += GET_MODE_SIZE (Pmode);
1321 }
1322
1323 /* Return the address of the block. */
1324 return copy_addr_to_reg (XEXP (registers, 0));
1325 }
1326
1327 /* __builtin_apply_args returns block of memory allocated on
1328 the stack into which is stored the arg pointer, structure
1329 value address, static chain, and all the registers that might
1330 possibly be used in performing a function call. The code is
1331 moved to the start of the function so the incoming values are
1332 saved. */
1333
1334 static rtx
1335 expand_builtin_apply_args (void)
1336 {
1337 /* Don't do __builtin_apply_args more than once in a function.
1338 Save the result of the first call and reuse it. */
1339 if (apply_args_value != 0)
1340 return apply_args_value;
1341 {
1342 /* When this function is called, it means that registers must be
1343 saved on entry to this function. So we migrate the
1344 call to the first insn of this function. */
1345 rtx temp;
1346 rtx seq;
1347
1348 start_sequence ();
1349 temp = expand_builtin_apply_args_1 ();
1350 seq = get_insns ();
1351 end_sequence ();
1352
1353 apply_args_value = temp;
1354
1355 /* Put the insns after the NOTE that starts the function.
1356 If this is inside a start_sequence, make the outer-level insn
1357 chain current, so the code is placed at the start of the
1358 function. */
1359 push_topmost_sequence ();
1360 emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
1361 pop_topmost_sequence ();
1362 return temp;
1363 }
1364 }
1365
1366 /* Perform an untyped call and save the state required to perform an
1367 untyped return of whatever value was returned by the given function. */
1368
1369 static rtx
1370 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1371 {
1372 int size, align, regno;
1373 enum machine_mode mode;
1374 rtx incoming_args, result, reg, dest, src, call_insn;
1375 rtx old_stack_level = 0;
1376 rtx call_fusage = 0;
1377 rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1378
1379 arguments = convert_memory_address (Pmode, arguments);
1380
1381 /* Create a block where the return registers can be saved. */
1382 result = assign_stack_local (BLKmode, apply_result_size (), -1);
1383
1384 /* Fetch the arg pointer from the ARGUMENTS block. */
1385 incoming_args = gen_reg_rtx (Pmode);
1386 emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1387 #ifndef STACK_GROWS_DOWNWARD
1388 incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1389 incoming_args, 0, OPTAB_LIB_WIDEN);
1390 #endif
1391
1392 /* Push a new argument block and copy the arguments. Do not allow
1393 the (potential) memcpy call below to interfere with our stack
1394 manipulations. */
1395 do_pending_stack_adjust ();
1396 NO_DEFER_POP;
1397
1398 /* Save the stack with nonlocal if available. */
1399 #ifdef HAVE_save_stack_nonlocal
1400 if (HAVE_save_stack_nonlocal)
1401 emit_stack_save (SAVE_NONLOCAL, &old_stack_level, NULL_RTX);
1402 else
1403 #endif
1404 emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1405
1406 /* Allocate a block of memory onto the stack and copy the memory
1407 arguments to the outgoing arguments address. */
1408 allocate_dynamic_stack_space (argsize, 0, BITS_PER_UNIT);
1409 dest = virtual_outgoing_args_rtx;
1410 #ifndef STACK_GROWS_DOWNWARD
1411 if (GET_CODE (argsize) == CONST_INT)
1412 dest = plus_constant (dest, -INTVAL (argsize));
1413 else
1414 dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1415 #endif
1416 dest = gen_rtx_MEM (BLKmode, dest);
1417 set_mem_align (dest, PARM_BOUNDARY);
1418 src = gen_rtx_MEM (BLKmode, incoming_args);
1419 set_mem_align (src, PARM_BOUNDARY);
1420 emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1421
1422 /* Refer to the argument block. */
1423 apply_args_size ();
1424 arguments = gen_rtx_MEM (BLKmode, arguments);
1425 set_mem_align (arguments, PARM_BOUNDARY);
1426
1427 /* Walk past the arg-pointer and structure value address. */
1428 size = GET_MODE_SIZE (Pmode);
1429 if (struct_value)
1430 size += GET_MODE_SIZE (Pmode);
1431
1432 /* Restore each of the registers previously saved. Make USE insns
1433 for each of these registers for use in making the call. */
1434 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1435 if ((mode = apply_args_mode[regno]) != VOIDmode)
1436 {
1437 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1438 if (size % align != 0)
1439 size = CEIL (size, align) * align;
1440 reg = gen_rtx_REG (mode, regno);
1441 emit_move_insn (reg, adjust_address (arguments, mode, size));
1442 use_reg (&call_fusage, reg);
1443 size += GET_MODE_SIZE (mode);
1444 }
1445
1446 /* Restore the structure value address unless this is passed as an
1447 "invisible" first argument. */
1448 size = GET_MODE_SIZE (Pmode);
1449 if (struct_value)
1450 {
1451 rtx value = gen_reg_rtx (Pmode);
1452 emit_move_insn (value, adjust_address (arguments, Pmode, size));
1453 emit_move_insn (struct_value, value);
1454 if (REG_P (struct_value))
1455 use_reg (&call_fusage, struct_value);
1456 size += GET_MODE_SIZE (Pmode);
1457 }
1458
1459 /* All arguments and registers used for the call are set up by now! */
1460 function = prepare_call_address (function, NULL, &call_fusage, 0, 0);
1461
1462 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1463 and we don't want to load it into a register as an optimization,
1464 because prepare_call_address already did it if it should be done. */
1465 if (GET_CODE (function) != SYMBOL_REF)
1466 function = memory_address (FUNCTION_MODE, function);
1467
1468 /* Generate the actual call instruction and save the return value. */
1469 #ifdef HAVE_untyped_call
1470 if (HAVE_untyped_call)
1471 emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
1472 result, result_vector (1, result)));
1473 else
1474 #endif
1475 #ifdef HAVE_call_value
1476 if (HAVE_call_value)
1477 {
1478 rtx valreg = 0;
1479
1480 /* Locate the unique return register. It is not possible to
1481 express a call that sets more than one return register using
1482 call_value; use untyped_call for that. In fact, untyped_call
1483 only needs to save the return registers in the given block. */
1484 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1485 if ((mode = apply_result_mode[regno]) != VOIDmode)
1486 {
1487 gcc_assert (!valreg); /* HAVE_untyped_call required. */
1488
1489 valreg = gen_rtx_REG (mode, regno);
1490 }
1491
1492 emit_call_insn (GEN_CALL_VALUE (valreg,
1493 gen_rtx_MEM (FUNCTION_MODE, function),
1494 const0_rtx, NULL_RTX, const0_rtx));
1495
1496 emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1497 }
1498 else
1499 #endif
1500 gcc_unreachable ();
1501
1502 /* Find the CALL insn we just emitted, and attach the register usage
1503 information. */
1504 call_insn = last_call_insn ();
1505 add_function_usage_to (call_insn, call_fusage);
1506
1507 /* Restore the stack. */
1508 #ifdef HAVE_save_stack_nonlocal
1509 if (HAVE_save_stack_nonlocal)
1510 emit_stack_restore (SAVE_NONLOCAL, old_stack_level, NULL_RTX);
1511 else
1512 #endif
1513 emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1514
1515 OK_DEFER_POP;
1516
1517 /* Return the address of the result block. */
1518 result = copy_addr_to_reg (XEXP (result, 0));
1519 return convert_memory_address (ptr_mode, result);
1520 }
1521
1522 /* Perform an untyped return. */
1523
1524 static void
1525 expand_builtin_return (rtx result)
1526 {
1527 int size, align, regno;
1528 enum machine_mode mode;
1529 rtx reg;
1530 rtx call_fusage = 0;
1531
1532 result = convert_memory_address (Pmode, result);
1533
1534 apply_result_size ();
1535 result = gen_rtx_MEM (BLKmode, result);
1536
1537 #ifdef HAVE_untyped_return
1538 if (HAVE_untyped_return)
1539 {
1540 emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1541 emit_barrier ();
1542 return;
1543 }
1544 #endif
1545
1546 /* Restore the return value and note that each value is used. */
1547 size = 0;
1548 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1549 if ((mode = apply_result_mode[regno]) != VOIDmode)
1550 {
1551 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1552 if (size % align != 0)
1553 size = CEIL (size, align) * align;
1554 reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1555 emit_move_insn (reg, adjust_address (result, mode, size));
1556
1557 push_to_sequence (call_fusage);
1558 emit_insn (gen_rtx_USE (VOIDmode, reg));
1559 call_fusage = get_insns ();
1560 end_sequence ();
1561 size += GET_MODE_SIZE (mode);
1562 }
1563
1564 /* Put the USE insns before the return. */
1565 emit_insn (call_fusage);
1566
1567 /* Return whatever values was restored by jumping directly to the end
1568 of the function. */
1569 expand_naked_return ();
1570 }
1571
1572 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1573
1574 static enum type_class
1575 type_to_class (tree type)
1576 {
1577 switch (TREE_CODE (type))
1578 {
1579 case VOID_TYPE: return void_type_class;
1580 case INTEGER_TYPE: return integer_type_class;
1581 case ENUMERAL_TYPE: return enumeral_type_class;
1582 case BOOLEAN_TYPE: return boolean_type_class;
1583 case POINTER_TYPE: return pointer_type_class;
1584 case REFERENCE_TYPE: return reference_type_class;
1585 case OFFSET_TYPE: return offset_type_class;
1586 case REAL_TYPE: return real_type_class;
1587 case COMPLEX_TYPE: return complex_type_class;
1588 case FUNCTION_TYPE: return function_type_class;
1589 case METHOD_TYPE: return method_type_class;
1590 case RECORD_TYPE: return record_type_class;
1591 case UNION_TYPE:
1592 case QUAL_UNION_TYPE: return union_type_class;
1593 case ARRAY_TYPE: return (TYPE_STRING_FLAG (type)
1594 ? string_type_class : array_type_class);
1595 case LANG_TYPE: return lang_type_class;
1596 default: return no_type_class;
1597 }
1598 }
1599
1600 /* Expand a call to __builtin_classify_type with arguments found in
1601 ARGLIST. */
1602
1603 static rtx
1604 expand_builtin_classify_type (tree arglist)
1605 {
1606 if (arglist != 0)
1607 return GEN_INT (type_to_class (TREE_TYPE (TREE_VALUE (arglist))));
1608 return GEN_INT (no_type_class);
1609 }
1610
1611 /* This helper macro, meant to be used in mathfn_built_in below,
1612 determines which among a set of three builtin math functions is
1613 appropriate for a given type mode. The `F' and `L' cases are
1614 automatically generated from the `double' case. */
1615 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1616 case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1617 fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1618 fcodel = BUILT_IN_MATHFN##L ; break;
1619
1620 /* Return mathematic function equivalent to FN but operating directly
1621 on TYPE, if available. If we can't do the conversion, return zero. */
1622 tree
1623 mathfn_built_in (tree type, enum built_in_function fn)
1624 {
1625 enum built_in_function fcode, fcodef, fcodel;
1626
1627 switch (fn)
1628 {
1629 CASE_MATHFN (BUILT_IN_ACOS)
1630 CASE_MATHFN (BUILT_IN_ACOSH)
1631 CASE_MATHFN (BUILT_IN_ASIN)
1632 CASE_MATHFN (BUILT_IN_ASINH)
1633 CASE_MATHFN (BUILT_IN_ATAN)
1634 CASE_MATHFN (BUILT_IN_ATAN2)
1635 CASE_MATHFN (BUILT_IN_ATANH)
1636 CASE_MATHFN (BUILT_IN_CBRT)
1637 CASE_MATHFN (BUILT_IN_CEIL)
1638 CASE_MATHFN (BUILT_IN_COPYSIGN)
1639 CASE_MATHFN (BUILT_IN_COS)
1640 CASE_MATHFN (BUILT_IN_COSH)
1641 CASE_MATHFN (BUILT_IN_DREM)
1642 CASE_MATHFN (BUILT_IN_ERF)
1643 CASE_MATHFN (BUILT_IN_ERFC)
1644 CASE_MATHFN (BUILT_IN_EXP)
1645 CASE_MATHFN (BUILT_IN_EXP10)
1646 CASE_MATHFN (BUILT_IN_EXP2)
1647 CASE_MATHFN (BUILT_IN_EXPM1)
1648 CASE_MATHFN (BUILT_IN_FABS)
1649 CASE_MATHFN (BUILT_IN_FDIM)
1650 CASE_MATHFN (BUILT_IN_FLOOR)
1651 CASE_MATHFN (BUILT_IN_FMA)
1652 CASE_MATHFN (BUILT_IN_FMAX)
1653 CASE_MATHFN (BUILT_IN_FMIN)
1654 CASE_MATHFN (BUILT_IN_FMOD)
1655 CASE_MATHFN (BUILT_IN_FREXP)
1656 CASE_MATHFN (BUILT_IN_GAMMA)
1657 CASE_MATHFN (BUILT_IN_HUGE_VAL)
1658 CASE_MATHFN (BUILT_IN_HYPOT)
1659 CASE_MATHFN (BUILT_IN_ILOGB)
1660 CASE_MATHFN (BUILT_IN_INF)
1661 CASE_MATHFN (BUILT_IN_J0)
1662 CASE_MATHFN (BUILT_IN_J1)
1663 CASE_MATHFN (BUILT_IN_JN)
1664 CASE_MATHFN (BUILT_IN_LCEIL)
1665 CASE_MATHFN (BUILT_IN_LDEXP)
1666 CASE_MATHFN (BUILT_IN_LFLOOR)
1667 CASE_MATHFN (BUILT_IN_LGAMMA)
1668 CASE_MATHFN (BUILT_IN_LLCEIL)
1669 CASE_MATHFN (BUILT_IN_LLFLOOR)
1670 CASE_MATHFN (BUILT_IN_LLRINT)
1671 CASE_MATHFN (BUILT_IN_LLROUND)
1672 CASE_MATHFN (BUILT_IN_LOG)
1673 CASE_MATHFN (BUILT_IN_LOG10)
1674 CASE_MATHFN (BUILT_IN_LOG1P)
1675 CASE_MATHFN (BUILT_IN_LOG2)
1676 CASE_MATHFN (BUILT_IN_LOGB)
1677 CASE_MATHFN (BUILT_IN_LRINT)
1678 CASE_MATHFN (BUILT_IN_LROUND)
1679 CASE_MATHFN (BUILT_IN_MODF)
1680 CASE_MATHFN (BUILT_IN_NAN)
1681 CASE_MATHFN (BUILT_IN_NANS)
1682 CASE_MATHFN (BUILT_IN_NEARBYINT)
1683 CASE_MATHFN (BUILT_IN_NEXTAFTER)
1684 CASE_MATHFN (BUILT_IN_NEXTTOWARD)
1685 CASE_MATHFN (BUILT_IN_POW)
1686 CASE_MATHFN (BUILT_IN_POWI)
1687 CASE_MATHFN (BUILT_IN_POW10)
1688 CASE_MATHFN (BUILT_IN_REMAINDER)
1689 CASE_MATHFN (BUILT_IN_REMQUO)
1690 CASE_MATHFN (BUILT_IN_RINT)
1691 CASE_MATHFN (BUILT_IN_ROUND)
1692 CASE_MATHFN (BUILT_IN_SCALB)
1693 CASE_MATHFN (BUILT_IN_SCALBLN)
1694 CASE_MATHFN (BUILT_IN_SCALBN)
1695 CASE_MATHFN (BUILT_IN_SIGNIFICAND)
1696 CASE_MATHFN (BUILT_IN_SIN)
1697 CASE_MATHFN (BUILT_IN_SINCOS)
1698 CASE_MATHFN (BUILT_IN_SINH)
1699 CASE_MATHFN (BUILT_IN_SQRT)
1700 CASE_MATHFN (BUILT_IN_TAN)
1701 CASE_MATHFN (BUILT_IN_TANH)
1702 CASE_MATHFN (BUILT_IN_TGAMMA)
1703 CASE_MATHFN (BUILT_IN_TRUNC)
1704 CASE_MATHFN (BUILT_IN_Y0)
1705 CASE_MATHFN (BUILT_IN_Y1)
1706 CASE_MATHFN (BUILT_IN_YN)
1707
1708 default:
1709 return 0;
1710 }
1711
1712 if (TYPE_MAIN_VARIANT (type) == double_type_node)
1713 return implicit_built_in_decls[fcode];
1714 else if (TYPE_MAIN_VARIANT (type) == float_type_node)
1715 return implicit_built_in_decls[fcodef];
1716 else if (TYPE_MAIN_VARIANT (type) == long_double_type_node)
1717 return implicit_built_in_decls[fcodel];
1718 else
1719 return 0;
1720 }
1721
1722 /* If errno must be maintained, expand the RTL to check if the result,
1723 TARGET, of a built-in function call, EXP, is NaN, and if so set
1724 errno to EDOM. */
1725
1726 static void
1727 expand_errno_check (tree exp, rtx target)
1728 {
1729 rtx lab = gen_label_rtx ();
1730
1731 /* Test the result; if it is NaN, set errno=EDOM because
1732 the argument was not in the domain. */
1733 emit_cmp_and_jump_insns (target, target, EQ, 0, GET_MODE (target),
1734 0, lab);
1735
1736 #ifdef TARGET_EDOM
1737 /* If this built-in doesn't throw an exception, set errno directly. */
1738 if (TREE_NOTHROW (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
1739 {
1740 #ifdef GEN_ERRNO_RTX
1741 rtx errno_rtx = GEN_ERRNO_RTX;
1742 #else
1743 rtx errno_rtx
1744 = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1745 #endif
1746 emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1747 emit_label (lab);
1748 return;
1749 }
1750 #endif
1751
1752 /* We can't set errno=EDOM directly; let the library call do it.
1753 Pop the arguments right away in case the call gets deleted. */
1754 NO_DEFER_POP;
1755 expand_call (exp, target, 0);
1756 OK_DEFER_POP;
1757 emit_label (lab);
1758 }
1759
1760
1761 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1762 Return 0 if a normal call should be emitted rather than expanding the
1763 function in-line. EXP is the expression that is a call to the builtin
1764 function; if convenient, the result should be placed in TARGET.
1765 SUBTARGET may be used as the target for computing one of EXP's operands. */
1766
1767 static rtx
1768 expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
1769 {
1770 optab builtin_optab;
1771 rtx op0, insns, before_call;
1772 tree fndecl = get_callee_fndecl (exp);
1773 tree arglist = TREE_OPERAND (exp, 1);
1774 enum machine_mode mode;
1775 bool errno_set = false;
1776 tree arg, narg;
1777
1778 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
1779 return 0;
1780
1781 arg = TREE_VALUE (arglist);
1782
1783 switch (DECL_FUNCTION_CODE (fndecl))
1784 {
1785 CASE_FLT_FN (BUILT_IN_SQRT):
1786 errno_set = ! tree_expr_nonnegative_p (arg);
1787 builtin_optab = sqrt_optab;
1788 break;
1789 CASE_FLT_FN (BUILT_IN_EXP):
1790 errno_set = true; builtin_optab = exp_optab; break;
1791 CASE_FLT_FN (BUILT_IN_EXP10):
1792 CASE_FLT_FN (BUILT_IN_POW10):
1793 errno_set = true; builtin_optab = exp10_optab; break;
1794 CASE_FLT_FN (BUILT_IN_EXP2):
1795 errno_set = true; builtin_optab = exp2_optab; break;
1796 CASE_FLT_FN (BUILT_IN_EXPM1):
1797 errno_set = true; builtin_optab = expm1_optab; break;
1798 CASE_FLT_FN (BUILT_IN_LOGB):
1799 errno_set = true; builtin_optab = logb_optab; break;
1800 CASE_FLT_FN (BUILT_IN_ILOGB):
1801 errno_set = true; builtin_optab = ilogb_optab; break;
1802 CASE_FLT_FN (BUILT_IN_LOG):
1803 errno_set = true; builtin_optab = log_optab; break;
1804 CASE_FLT_FN (BUILT_IN_LOG10):
1805 errno_set = true; builtin_optab = log10_optab; break;
1806 CASE_FLT_FN (BUILT_IN_LOG2):
1807 errno_set = true; builtin_optab = log2_optab; break;
1808 CASE_FLT_FN (BUILT_IN_LOG1P):
1809 errno_set = true; builtin_optab = log1p_optab; break;
1810 CASE_FLT_FN (BUILT_IN_ASIN):
1811 builtin_optab = asin_optab; break;
1812 CASE_FLT_FN (BUILT_IN_ACOS):
1813 builtin_optab = acos_optab; break;
1814 CASE_FLT_FN (BUILT_IN_TAN):
1815 builtin_optab = tan_optab; break;
1816 CASE_FLT_FN (BUILT_IN_ATAN):
1817 builtin_optab = atan_optab; break;
1818 CASE_FLT_FN (BUILT_IN_FLOOR):
1819 builtin_optab = floor_optab; break;
1820 CASE_FLT_FN (BUILT_IN_CEIL):
1821 builtin_optab = ceil_optab; break;
1822 CASE_FLT_FN (BUILT_IN_TRUNC):
1823 builtin_optab = btrunc_optab; break;
1824 CASE_FLT_FN (BUILT_IN_ROUND):
1825 builtin_optab = round_optab; break;
1826 CASE_FLT_FN (BUILT_IN_NEARBYINT):
1827 builtin_optab = nearbyint_optab; break;
1828 CASE_FLT_FN (BUILT_IN_RINT):
1829 builtin_optab = rint_optab; break;
1830 CASE_FLT_FN (BUILT_IN_LRINT):
1831 CASE_FLT_FN (BUILT_IN_LLRINT):
1832 builtin_optab = lrint_optab; break;
1833 default:
1834 gcc_unreachable ();
1835 }
1836
1837 /* Make a suitable register to place result in. */
1838 mode = TYPE_MODE (TREE_TYPE (exp));
1839
1840 if (! flag_errno_math || ! HONOR_NANS (mode))
1841 errno_set = false;
1842
1843 /* Before working hard, check whether the instruction is available. */
1844 if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
1845 {
1846 target = gen_reg_rtx (mode);
1847
1848 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
1849 need to expand the argument again. This way, we will not perform
1850 side-effects more the once. */
1851 narg = builtin_save_expr (arg);
1852 if (narg != arg)
1853 {
1854 arg = narg;
1855 arglist = build_tree_list (NULL_TREE, arg);
1856 exp = build_function_call_expr (fndecl, arglist);
1857 }
1858
1859 op0 = expand_expr (arg, subtarget, VOIDmode, 0);
1860
1861 start_sequence ();
1862
1863 /* Compute into TARGET.
1864 Set TARGET to wherever the result comes back. */
1865 target = expand_unop (mode, builtin_optab, op0, target, 0);
1866
1867 if (target != 0)
1868 {
1869 if (errno_set)
1870 expand_errno_check (exp, target);
1871
1872 /* Output the entire sequence. */
1873 insns = get_insns ();
1874 end_sequence ();
1875 emit_insn (insns);
1876 return target;
1877 }
1878
1879 /* If we were unable to expand via the builtin, stop the sequence
1880 (without outputting the insns) and call to the library function
1881 with the stabilized argument list. */
1882 end_sequence ();
1883 }
1884
1885 before_call = get_last_insn ();
1886
1887 target = expand_call (exp, target, target == const0_rtx);
1888
1889 /* If this is a sqrt operation and we don't care about errno, try to
1890 attach a REG_EQUAL note with a SQRT rtx to the emitted libcall.
1891 This allows the semantics of the libcall to be visible to the RTL
1892 optimizers. */
1893 if (builtin_optab == sqrt_optab && !errno_set)
1894 {
1895 /* Search backwards through the insns emitted by expand_call looking
1896 for the instruction with the REG_RETVAL note. */
1897 rtx last = get_last_insn ();
1898 while (last != before_call)
1899 {
1900 if (find_reg_note (last, REG_RETVAL, NULL))
1901 {
1902 rtx note = find_reg_note (last, REG_EQUAL, NULL);
1903 /* Check that the REQ_EQUAL note is an EXPR_LIST with
1904 two elements, i.e. symbol_ref(sqrt) and the operand. */
1905 if (note
1906 && GET_CODE (note) == EXPR_LIST
1907 && GET_CODE (XEXP (note, 0)) == EXPR_LIST
1908 && XEXP (XEXP (note, 0), 1) != NULL_RTX
1909 && XEXP (XEXP (XEXP (note, 0), 1), 1) == NULL_RTX)
1910 {
1911 rtx operand = XEXP (XEXP (XEXP (note, 0), 1), 0);
1912 /* Check operand is a register with expected mode. */
1913 if (operand
1914 && REG_P (operand)
1915 && GET_MODE (operand) == mode)
1916 {
1917 /* Replace the REG_EQUAL note with a SQRT rtx. */
1918 rtx equiv = gen_rtx_SQRT (mode, operand);
1919 set_unique_reg_note (last, REG_EQUAL, equiv);
1920 }
1921 }
1922 break;
1923 }
1924 last = PREV_INSN (last);
1925 }
1926 }
1927
1928 return target;
1929 }
1930
1931 /* Expand a call to the builtin binary math functions (pow and atan2).
1932 Return 0 if a normal call should be emitted rather than expanding the
1933 function in-line. EXP is the expression that is a call to the builtin
1934 function; if convenient, the result should be placed in TARGET.
1935 SUBTARGET may be used as the target for computing one of EXP's
1936 operands. */
1937
1938 static rtx
1939 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
1940 {
1941 optab builtin_optab;
1942 rtx op0, op1, insns;
1943 int op1_type = REAL_TYPE;
1944 tree fndecl = get_callee_fndecl (exp);
1945 tree arglist = TREE_OPERAND (exp, 1);
1946 tree arg0, arg1, temp, narg;
1947 enum machine_mode mode;
1948 bool errno_set = true;
1949 bool stable = true;
1950
1951 if ((DECL_FUNCTION_CODE (fndecl) == BUILT_IN_LDEXP)
1952 || (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_LDEXPF)
1953 || (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_LDEXPL))
1954 op1_type = INTEGER_TYPE;
1955
1956 if (!validate_arglist (arglist, REAL_TYPE, op1_type, VOID_TYPE))
1957 return 0;
1958
1959 arg0 = TREE_VALUE (arglist);
1960 arg1 = TREE_VALUE (TREE_CHAIN (arglist));
1961
1962 switch (DECL_FUNCTION_CODE (fndecl))
1963 {
1964 CASE_FLT_FN (BUILT_IN_POW):
1965 builtin_optab = pow_optab; break;
1966 CASE_FLT_FN (BUILT_IN_ATAN2):
1967 builtin_optab = atan2_optab; break;
1968 CASE_FLT_FN (BUILT_IN_LDEXP):
1969 builtin_optab = ldexp_optab; break;
1970 CASE_FLT_FN (BUILT_IN_FMOD):
1971 builtin_optab = fmod_optab; break;
1972 CASE_FLT_FN (BUILT_IN_DREM):
1973 builtin_optab = drem_optab; break;
1974 default:
1975 gcc_unreachable ();
1976 }
1977
1978 /* Make a suitable register to place result in. */
1979 mode = TYPE_MODE (TREE_TYPE (exp));
1980
1981 /* Before working hard, check whether the instruction is available. */
1982 if (builtin_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing)
1983 return 0;
1984
1985 target = gen_reg_rtx (mode);
1986
1987 if (! flag_errno_math || ! HONOR_NANS (mode))
1988 errno_set = false;
1989
1990 /* Always stabilize the argument list. */
1991 narg = builtin_save_expr (arg1);
1992 if (narg != arg1)
1993 {
1994 arg1 = narg;
1995 temp = build_tree_list (NULL_TREE, narg);
1996 stable = false;
1997 }
1998 else
1999 temp = TREE_CHAIN (arglist);
2000
2001 narg = builtin_save_expr (arg0);
2002 if (narg != arg0)
2003 {
2004 arg0 = narg;
2005 arglist = tree_cons (NULL_TREE, narg, temp);
2006 stable = false;
2007 }
2008 else if (! stable)
2009 arglist = tree_cons (NULL_TREE, arg0, temp);
2010
2011 if (! stable)
2012 exp = build_function_call_expr (fndecl, arglist);
2013
2014 op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2015 op1 = expand_normal (arg1);
2016
2017 start_sequence ();
2018
2019 /* Compute into TARGET.
2020 Set TARGET to wherever the result comes back. */
2021 target = expand_binop (mode, builtin_optab, op0, op1,
2022 target, 0, OPTAB_DIRECT);
2023
2024 /* If we were unable to expand via the builtin, stop the sequence
2025 (without outputting the insns) and call to the library function
2026 with the stabilized argument list. */
2027 if (target == 0)
2028 {
2029 end_sequence ();
2030 return expand_call (exp, target, target == const0_rtx);
2031 }
2032
2033 if (errno_set)
2034 expand_errno_check (exp, target);
2035
2036 /* Output the entire sequence. */
2037 insns = get_insns ();
2038 end_sequence ();
2039 emit_insn (insns);
2040
2041 return target;
2042 }
2043
2044 /* Expand a call to the builtin sin and cos math functions.
2045 Return 0 if a normal call should be emitted rather than expanding the
2046 function in-line. EXP is the expression that is a call to the builtin
2047 function; if convenient, the result should be placed in TARGET.
2048 SUBTARGET may be used as the target for computing one of EXP's
2049 operands. */
2050
2051 static rtx
2052 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2053 {
2054 optab builtin_optab;
2055 rtx op0, insns;
2056 tree fndecl = get_callee_fndecl (exp);
2057 tree arglist = TREE_OPERAND (exp, 1);
2058 enum machine_mode mode;
2059 tree arg, narg;
2060
2061 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
2062 return 0;
2063
2064 arg = TREE_VALUE (arglist);
2065
2066 switch (DECL_FUNCTION_CODE (fndecl))
2067 {
2068 CASE_FLT_FN (BUILT_IN_SIN):
2069 CASE_FLT_FN (BUILT_IN_COS):
2070 builtin_optab = sincos_optab; break;
2071 default:
2072 gcc_unreachable ();
2073 }
2074
2075 /* Make a suitable register to place result in. */
2076 mode = TYPE_MODE (TREE_TYPE (exp));
2077
2078 /* Check if sincos insn is available, otherwise fallback
2079 to sin or cos insn. */
2080 if (builtin_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing) {
2081 switch (DECL_FUNCTION_CODE (fndecl))
2082 {
2083 CASE_FLT_FN (BUILT_IN_SIN):
2084 builtin_optab = sin_optab; break;
2085 CASE_FLT_FN (BUILT_IN_COS):
2086 builtin_optab = cos_optab; break;
2087 default:
2088 gcc_unreachable ();
2089 }
2090 }
2091
2092 /* Before working hard, check whether the instruction is available. */
2093 if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
2094 {
2095 target = gen_reg_rtx (mode);
2096
2097 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2098 need to expand the argument again. This way, we will not perform
2099 side-effects more the once. */
2100 narg = save_expr (arg);
2101 if (narg != arg)
2102 {
2103 arg = narg;
2104 arglist = build_tree_list (NULL_TREE, arg);
2105 exp = build_function_call_expr (fndecl, arglist);
2106 }
2107
2108 op0 = expand_expr (arg, subtarget, VOIDmode, 0);
2109
2110 start_sequence ();
2111
2112 /* Compute into TARGET.
2113 Set TARGET to wherever the result comes back. */
2114 if (builtin_optab == sincos_optab)
2115 {
2116 int result;
2117
2118 switch (DECL_FUNCTION_CODE (fndecl))
2119 {
2120 CASE_FLT_FN (BUILT_IN_SIN):
2121 result = expand_twoval_unop (builtin_optab, op0, 0, target, 0);
2122 break;
2123 CASE_FLT_FN (BUILT_IN_COS):
2124 result = expand_twoval_unop (builtin_optab, op0, target, 0, 0);
2125 break;
2126 default:
2127 gcc_unreachable ();
2128 }
2129 gcc_assert (result);
2130 }
2131 else
2132 {
2133 target = expand_unop (mode, builtin_optab, op0, target, 0);
2134 }
2135
2136 if (target != 0)
2137 {
2138 /* Output the entire sequence. */
2139 insns = get_insns ();
2140 end_sequence ();
2141 emit_insn (insns);
2142 return target;
2143 }
2144
2145 /* If we were unable to expand via the builtin, stop the sequence
2146 (without outputting the insns) and call to the library function
2147 with the stabilized argument list. */
2148 end_sequence ();
2149 }
2150
2151 target = expand_call (exp, target, target == const0_rtx);
2152
2153 return target;
2154 }
2155
2156 /* Expand a call to the builtin sincos math function.
2157 Return 0 if a normal call should be emitted rather than expanding the
2158 function in-line. EXP is the expression that is a call to the builtin
2159 function. */
2160
2161 static rtx
2162 expand_builtin_sincos (tree exp)
2163 {
2164 rtx op0, op1, op2, target1, target2;
2165 tree arglist = TREE_OPERAND (exp, 1);
2166 enum machine_mode mode;
2167 tree arg, sinp, cosp;
2168 int result;
2169
2170 if (!validate_arglist (arglist, REAL_TYPE,
2171 POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2172 return 0;
2173
2174 arg = TREE_VALUE (arglist);
2175 sinp = TREE_VALUE (TREE_CHAIN (arglist));
2176 cosp = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2177
2178 /* Make a suitable register to place result in. */
2179 mode = TYPE_MODE (TREE_TYPE (arg));
2180
2181 /* Check if sincos insn is available, otherwise emit the call. */
2182 if (sincos_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing)
2183 return NULL_RTX;
2184
2185 target1 = gen_reg_rtx (mode);
2186 target2 = gen_reg_rtx (mode);
2187
2188 op0 = expand_normal (arg);
2189 op1 = expand_normal (build_fold_indirect_ref (sinp));
2190 op2 = expand_normal (build_fold_indirect_ref (cosp));
2191
2192 /* Compute into target1 and target2.
2193 Set TARGET to wherever the result comes back. */
2194 result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2195 gcc_assert (result);
2196
2197 /* Move target1 and target2 to the memory locations indicated
2198 by op1 and op2. */
2199 emit_move_insn (op1, target1);
2200 emit_move_insn (op2, target2);
2201
2202 return const0_rtx;
2203 }
2204
2205 /* Expand a call to one of the builtin rounding functions (lfloor).
2206 If expanding via optab fails, lower expression to (int)(floor(x)).
2207 EXP is the expression that is a call to the builtin function;
2208 if convenient, the result should be placed in TARGET. SUBTARGET may
2209 be used as the target for computing one of EXP's operands. */
2210
2211 static rtx
2212 expand_builtin_int_roundingfn (tree exp, rtx target, rtx subtarget)
2213 {
2214 optab builtin_optab;
2215 rtx op0, insns, tmp;
2216 tree fndecl = get_callee_fndecl (exp);
2217 tree arglist = TREE_OPERAND (exp, 1);
2218 enum built_in_function fallback_fn;
2219 tree fallback_fndecl;
2220 enum machine_mode mode;
2221 tree arg, narg;
2222
2223 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
2224 gcc_unreachable ();
2225
2226 arg = TREE_VALUE (arglist);
2227
2228 switch (DECL_FUNCTION_CODE (fndecl))
2229 {
2230 CASE_FLT_FN (BUILT_IN_LCEIL):
2231 CASE_FLT_FN (BUILT_IN_LLCEIL):
2232 builtin_optab = lceil_optab;
2233 fallback_fn = BUILT_IN_CEIL;
2234 break;
2235
2236 CASE_FLT_FN (BUILT_IN_LFLOOR):
2237 CASE_FLT_FN (BUILT_IN_LLFLOOR):
2238 builtin_optab = lfloor_optab;
2239 fallback_fn = BUILT_IN_FLOOR;
2240 break;
2241
2242 default:
2243 gcc_unreachable ();
2244 }
2245
2246 /* Make a suitable register to place result in. */
2247 mode = TYPE_MODE (TREE_TYPE (exp));
2248
2249 /* Before working hard, check whether the instruction is available. */
2250 if (builtin_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
2251 {
2252 target = gen_reg_rtx (mode);
2253
2254 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2255 need to expand the argument again. This way, we will not perform
2256 side-effects more the once. */
2257 narg = builtin_save_expr (arg);
2258 if (narg != arg)
2259 {
2260 arg = narg;
2261 arglist = build_tree_list (NULL_TREE, arg);
2262 exp = build_function_call_expr (fndecl, arglist);
2263 }
2264
2265 op0 = expand_expr (arg, subtarget, VOIDmode, 0);
2266
2267 start_sequence ();
2268
2269 /* Compute into TARGET.
2270 Set TARGET to wherever the result comes back. */
2271 target = expand_unop (mode, builtin_optab, op0, target, 0);
2272
2273 if (target != 0)
2274 {
2275 /* Output the entire sequence. */
2276 insns = get_insns ();
2277 end_sequence ();
2278 emit_insn (insns);
2279 return target;
2280 }
2281
2282 /* If we were unable to expand via the builtin, stop the sequence
2283 (without outputting the insns). */
2284 end_sequence ();
2285 }
2286
2287 /* Fall back to floating point rounding optab. */
2288 fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2289 /* We shouldn't get here on targets without TARGET_C99_FUNCTIONS.
2290 ??? Perhaps convert (int)floorf(x) into (int)floor((double)x). */
2291 gcc_assert (fallback_fndecl != NULL_TREE);
2292 exp = build_function_call_expr (fallback_fndecl, arglist);
2293
2294 tmp = expand_normal (exp);
2295
2296 /* Truncate the result of floating point optab to integer
2297 via expand_fix (). */
2298 target = gen_reg_rtx (mode);
2299 expand_fix (target, tmp, 0);
2300
2301 return target;
2302 }
2303
2304 /* To evaluate powi(x,n), the floating point value x raised to the
2305 constant integer exponent n, we use a hybrid algorithm that
2306 combines the "window method" with look-up tables. For an
2307 introduction to exponentiation algorithms and "addition chains",
2308 see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2309 "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2310 3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2311 Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998. */
2312
2313 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2314 multiplications to inline before calling the system library's pow
2315 function. powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2316 so this default never requires calling pow, powf or powl. */
2317
2318 #ifndef POWI_MAX_MULTS
2319 #define POWI_MAX_MULTS (2*HOST_BITS_PER_WIDE_INT-2)
2320 #endif
2321
2322 /* The size of the "optimal power tree" lookup table. All
2323 exponents less than this value are simply looked up in the
2324 powi_table below. This threshold is also used to size the
2325 cache of pseudo registers that hold intermediate results. */
2326 #define POWI_TABLE_SIZE 256
2327
2328 /* The size, in bits of the window, used in the "window method"
2329 exponentiation algorithm. This is equivalent to a radix of
2330 (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method". */
2331 #define POWI_WINDOW_SIZE 3
2332
2333 /* The following table is an efficient representation of an
2334 "optimal power tree". For each value, i, the corresponding
2335 value, j, in the table states than an optimal evaluation
2336 sequence for calculating pow(x,i) can be found by evaluating
2337 pow(x,j)*pow(x,i-j). An optimal power tree for the first
2338 100 integers is given in Knuth's "Seminumerical algorithms". */
2339
2340 static const unsigned char powi_table[POWI_TABLE_SIZE] =
2341 {
2342 0, 1, 1, 2, 2, 3, 3, 4, /* 0 - 7 */
2343 4, 6, 5, 6, 6, 10, 7, 9, /* 8 - 15 */
2344 8, 16, 9, 16, 10, 12, 11, 13, /* 16 - 23 */
2345 12, 17, 13, 18, 14, 24, 15, 26, /* 24 - 31 */
2346 16, 17, 17, 19, 18, 33, 19, 26, /* 32 - 39 */
2347 20, 25, 21, 40, 22, 27, 23, 44, /* 40 - 47 */
2348 24, 32, 25, 34, 26, 29, 27, 44, /* 48 - 55 */
2349 28, 31, 29, 34, 30, 60, 31, 36, /* 56 - 63 */
2350 32, 64, 33, 34, 34, 46, 35, 37, /* 64 - 71 */
2351 36, 65, 37, 50, 38, 48, 39, 69, /* 72 - 79 */
2352 40, 49, 41, 43, 42, 51, 43, 58, /* 80 - 87 */
2353 44, 64, 45, 47, 46, 59, 47, 76, /* 88 - 95 */
2354 48, 65, 49, 66, 50, 67, 51, 66, /* 96 - 103 */
2355 52, 70, 53, 74, 54, 104, 55, 74, /* 104 - 111 */
2356 56, 64, 57, 69, 58, 78, 59, 68, /* 112 - 119 */
2357 60, 61, 61, 80, 62, 75, 63, 68, /* 120 - 127 */
2358 64, 65, 65, 128, 66, 129, 67, 90, /* 128 - 135 */
2359 68, 73, 69, 131, 70, 94, 71, 88, /* 136 - 143 */
2360 72, 128, 73, 98, 74, 132, 75, 121, /* 144 - 151 */
2361 76, 102, 77, 124, 78, 132, 79, 106, /* 152 - 159 */
2362 80, 97, 81, 160, 82, 99, 83, 134, /* 160 - 167 */
2363 84, 86, 85, 95, 86, 160, 87, 100, /* 168 - 175 */
2364 88, 113, 89, 98, 90, 107, 91, 122, /* 176 - 183 */
2365 92, 111, 93, 102, 94, 126, 95, 150, /* 184 - 191 */
2366 96, 128, 97, 130, 98, 133, 99, 195, /* 192 - 199 */
2367 100, 128, 101, 123, 102, 164, 103, 138, /* 200 - 207 */
2368 104, 145, 105, 146, 106, 109, 107, 149, /* 208 - 215 */
2369 108, 200, 109, 146, 110, 170, 111, 157, /* 216 - 223 */
2370 112, 128, 113, 130, 114, 182, 115, 132, /* 224 - 231 */
2371 116, 200, 117, 132, 118, 158, 119, 206, /* 232 - 239 */
2372 120, 240, 121, 162, 122, 147, 123, 152, /* 240 - 247 */
2373 124, 166, 125, 214, 126, 138, 127, 153, /* 248 - 255 */
2374 };
2375
2376
2377 /* Return the number of multiplications required to calculate
2378 powi(x,n) where n is less than POWI_TABLE_SIZE. This is a
2379 subroutine of powi_cost. CACHE is an array indicating
2380 which exponents have already been calculated. */
2381
2382 static int
2383 powi_lookup_cost (unsigned HOST_WIDE_INT n, bool *cache)
2384 {
2385 /* If we've already calculated this exponent, then this evaluation
2386 doesn't require any additional multiplications. */
2387 if (cache[n])
2388 return 0;
2389
2390 cache[n] = true;
2391 return powi_lookup_cost (n - powi_table[n], cache)
2392 + powi_lookup_cost (powi_table[n], cache) + 1;
2393 }
2394
2395 /* Return the number of multiplications required to calculate
2396 powi(x,n) for an arbitrary x, given the exponent N. This
2397 function needs to be kept in sync with expand_powi below. */
2398
2399 static int
2400 powi_cost (HOST_WIDE_INT n)
2401 {
2402 bool cache[POWI_TABLE_SIZE];
2403 unsigned HOST_WIDE_INT digit;
2404 unsigned HOST_WIDE_INT val;
2405 int result;
2406
2407 if (n == 0)
2408 return 0;
2409
2410 /* Ignore the reciprocal when calculating the cost. */
2411 val = (n < 0) ? -n : n;
2412
2413 /* Initialize the exponent cache. */
2414 memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool));
2415 cache[1] = true;
2416
2417 result = 0;
2418
2419 while (val >= POWI_TABLE_SIZE)
2420 {
2421 if (val & 1)
2422 {
2423 digit = val & ((1 << POWI_WINDOW_SIZE) - 1);
2424 result += powi_lookup_cost (digit, cache)
2425 + POWI_WINDOW_SIZE + 1;
2426 val >>= POWI_WINDOW_SIZE;
2427 }
2428 else
2429 {
2430 val >>= 1;
2431 result++;
2432 }
2433 }
2434
2435 return result + powi_lookup_cost (val, cache);
2436 }
2437
2438 /* Recursive subroutine of expand_powi. This function takes the array,
2439 CACHE, of already calculated exponents and an exponent N and returns
2440 an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE. */
2441
2442 static rtx
2443 expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
2444 {
2445 unsigned HOST_WIDE_INT digit;
2446 rtx target, result;
2447 rtx op0, op1;
2448
2449 if (n < POWI_TABLE_SIZE)
2450 {
2451 if (cache[n])
2452 return cache[n];
2453
2454 target = gen_reg_rtx (mode);
2455 cache[n] = target;
2456
2457 op0 = expand_powi_1 (mode, n - powi_table[n], cache);
2458 op1 = expand_powi_1 (mode, powi_table[n], cache);
2459 }
2460 else if (n & 1)
2461 {
2462 target = gen_reg_rtx (mode);
2463 digit = n & ((1 << POWI_WINDOW_SIZE) - 1);
2464 op0 = expand_powi_1 (mode, n - digit, cache);
2465 op1 = expand_powi_1 (mode, digit, cache);
2466 }
2467 else
2468 {
2469 target = gen_reg_rtx (mode);
2470 op0 = expand_powi_1 (mode, n >> 1, cache);
2471 op1 = op0;
2472 }
2473
2474 result = expand_mult (mode, op0, op1, target, 0);
2475 if (result != target)
2476 emit_move_insn (target, result);
2477 return target;
2478 }
2479
2480 /* Expand the RTL to evaluate powi(x,n) in mode MODE. X is the
2481 floating point operand in mode MODE, and N is the exponent. This
2482 function needs to be kept in sync with powi_cost above. */
2483
2484 static rtx
2485 expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
2486 {
2487 unsigned HOST_WIDE_INT val;
2488 rtx cache[POWI_TABLE_SIZE];
2489 rtx result;
2490
2491 if (n == 0)
2492 return CONST1_RTX (mode);
2493
2494 val = (n < 0) ? -n : n;
2495
2496 memset (cache, 0, sizeof (cache));
2497 cache[1] = x;
2498
2499 result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
2500
2501 /* If the original exponent was negative, reciprocate the result. */
2502 if (n < 0)
2503 result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2504 result, NULL_RTX, 0, OPTAB_LIB_WIDEN);
2505
2506 return result;
2507 }
2508
2509 /* Expand a call to the pow built-in mathematical function. Return 0 if
2510 a normal call should be emitted rather than expanding the function
2511 in-line. EXP is the expression that is a call to the builtin
2512 function; if convenient, the result should be placed in TARGET. */
2513
2514 static rtx
2515 expand_builtin_pow (tree exp, rtx target, rtx subtarget)
2516 {
2517 tree arglist = TREE_OPERAND (exp, 1);
2518 tree arg0, arg1;
2519
2520 if (! validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
2521 return 0;
2522
2523 arg0 = TREE_VALUE (arglist);
2524 arg1 = TREE_VALUE (TREE_CHAIN (arglist));
2525
2526 if (TREE_CODE (arg1) == REAL_CST
2527 && ! TREE_CONSTANT_OVERFLOW (arg1))
2528 {
2529 REAL_VALUE_TYPE cint;
2530 REAL_VALUE_TYPE c;
2531 HOST_WIDE_INT n;
2532
2533 c = TREE_REAL_CST (arg1);
2534 n = real_to_integer (&c);
2535 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
2536 if (real_identical (&c, &cint))
2537 {
2538 /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
2539 Otherwise, check the number of multiplications required.
2540 Note that pow never sets errno for an integer exponent. */
2541 if ((n >= -1 && n <= 2)
2542 || (flag_unsafe_math_optimizations
2543 && ! optimize_size
2544 && powi_cost (n) <= POWI_MAX_MULTS))
2545 {
2546 enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2547 rtx op = expand_expr (arg0, subtarget, VOIDmode, 0);
2548 op = force_reg (mode, op);
2549 return expand_powi (op, mode, n);
2550 }
2551 }
2552 }
2553
2554 if (! flag_unsafe_math_optimizations)
2555 return NULL_RTX;
2556 return expand_builtin_mathfn_2 (exp, target, subtarget);
2557 }
2558
2559 /* Expand a call to the powi built-in mathematical function. Return 0 if
2560 a normal call should be emitted rather than expanding the function
2561 in-line. EXP is the expression that is a call to the builtin
2562 function; if convenient, the result should be placed in TARGET. */
2563
2564 static rtx
2565 expand_builtin_powi (tree exp, rtx target, rtx subtarget)
2566 {
2567 tree arglist = TREE_OPERAND (exp, 1);
2568 tree arg0, arg1;
2569 rtx op0, op1;
2570 enum machine_mode mode;
2571 enum machine_mode mode2;
2572
2573 if (! validate_arglist (arglist, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
2574 return 0;
2575
2576 arg0 = TREE_VALUE (arglist);
2577 arg1 = TREE_VALUE (TREE_CHAIN (arglist));
2578 mode = TYPE_MODE (TREE_TYPE (exp));
2579
2580 /* Handle constant power. */
2581
2582 if (TREE_CODE (arg1) == INTEGER_CST
2583 && ! TREE_CONSTANT_OVERFLOW (arg1))
2584 {
2585 HOST_WIDE_INT n = TREE_INT_CST_LOW (arg1);
2586
2587 /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
2588 Otherwise, check the number of multiplications required. */
2589 if ((TREE_INT_CST_HIGH (arg1) == 0
2590 || TREE_INT_CST_HIGH (arg1) == -1)
2591 && ((n >= -1 && n <= 2)
2592 || (! optimize_size
2593 && powi_cost (n) <= POWI_MAX_MULTS)))
2594 {
2595 op0 = expand_expr (arg0, subtarget, VOIDmode, 0);
2596 op0 = force_reg (mode, op0);
2597 return expand_powi (op0, mode, n);
2598 }
2599 }
2600
2601 /* Emit a libcall to libgcc. */
2602
2603 /* Mode of the 2nd argument must match that of an int. */
2604 mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
2605
2606 if (target == NULL_RTX)
2607 target = gen_reg_rtx (mode);
2608
2609 op0 = expand_expr (arg0, subtarget, mode, 0);
2610 if (GET_MODE (op0) != mode)
2611 op0 = convert_to_mode (mode, op0, 0);
2612 op1 = expand_expr (arg1, 0, mode2, 0);
2613 if (GET_MODE (op1) != mode2)
2614 op1 = convert_to_mode (mode2, op1, 0);
2615
2616 target = emit_library_call_value (powi_optab->handlers[(int) mode].libfunc,
2617 target, LCT_CONST_MAKE_BLOCK, mode, 2,
2618 op0, mode, op1, mode2);
2619
2620 return target;
2621 }
2622
2623 /* Expand expression EXP which is a call to the strlen builtin. Return 0
2624 if we failed the caller should emit a normal call, otherwise
2625 try to get the result in TARGET, if convenient. */
2626
2627 static rtx
2628 expand_builtin_strlen (tree arglist, rtx target,
2629 enum machine_mode target_mode)
2630 {
2631 if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
2632 return 0;
2633 else
2634 {
2635 rtx pat;
2636 tree len, src = TREE_VALUE (arglist);
2637 rtx result, src_reg, char_rtx, before_strlen;
2638 enum machine_mode insn_mode = target_mode, char_mode;
2639 enum insn_code icode = CODE_FOR_nothing;
2640 int align;
2641
2642 /* If the length can be computed at compile-time, return it. */
2643 len = c_strlen (src, 0);
2644 if (len)
2645 return expand_expr (len, target, target_mode, EXPAND_NORMAL);
2646
2647 /* If the length can be computed at compile-time and is constant
2648 integer, but there are side-effects in src, evaluate
2649 src for side-effects, then return len.
2650 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
2651 can be optimized into: i++; x = 3; */
2652 len = c_strlen (src, 1);
2653 if (len && TREE_CODE (len) == INTEGER_CST)
2654 {
2655 expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
2656 return expand_expr (len, target, target_mode, EXPAND_NORMAL);
2657 }
2658
2659 align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
2660
2661 /* If SRC is not a pointer type, don't do this operation inline. */
2662 if (align == 0)
2663 return 0;
2664
2665 /* Bail out if we can't compute strlen in the right mode. */
2666 while (insn_mode != VOIDmode)
2667 {
2668 icode = strlen_optab->handlers[(int) insn_mode].insn_code;
2669 if (icode != CODE_FOR_nothing)
2670 break;
2671
2672 insn_mode = GET_MODE_WIDER_MODE (insn_mode);
2673 }
2674 if (insn_mode == VOIDmode)
2675 return 0;
2676
2677 /* Make a place to write the result of the instruction. */
2678 result = target;
2679 if (! (result != 0
2680 && REG_P (result)
2681 && GET_MODE (result) == insn_mode
2682 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
2683 result = gen_reg_rtx (insn_mode);
2684
2685 /* Make a place to hold the source address. We will not expand
2686 the actual source until we are sure that the expansion will
2687 not fail -- there are trees that cannot be expanded twice. */
2688 src_reg = gen_reg_rtx (Pmode);
2689
2690 /* Mark the beginning of the strlen sequence so we can emit the
2691 source operand later. */
2692 before_strlen = get_last_insn ();
2693
2694 char_rtx = const0_rtx;
2695 char_mode = insn_data[(int) icode].operand[2].mode;
2696 if (! (*insn_data[(int) icode].operand[2].predicate) (char_rtx,
2697 char_mode))
2698 char_rtx = copy_to_mode_reg (char_mode, char_rtx);
2699
2700 pat = GEN_FCN (icode) (result, gen_rtx_MEM (BLKmode, src_reg),
2701 char_rtx, GEN_INT (align));
2702 if (! pat)
2703 return 0;
2704 emit_insn (pat);
2705
2706 /* Now that we are assured of success, expand the source. */
2707 start_sequence ();
2708 pat = expand_expr (src, src_reg, ptr_mode, EXPAND_NORMAL);
2709 if (pat != src_reg)
2710 emit_move_insn (src_reg, pat);
2711 pat = get_insns ();
2712 end_sequence ();
2713
2714 if (before_strlen)
2715 emit_insn_after (pat, before_strlen);
2716 else
2717 emit_insn_before (pat, get_insns ());
2718
2719 /* Return the value in the proper mode for this function. */
2720 if (GET_MODE (result) == target_mode)
2721 target = result;
2722 else if (target != 0)
2723 convert_move (target, result, 0);
2724 else
2725 target = convert_to_mode (target_mode, result, 0);
2726
2727 return target;
2728 }
2729 }
2730
2731 /* Expand a call to the strstr builtin. Return 0 if we failed the
2732 caller should emit a normal call, otherwise try to get the result
2733 in TARGET, if convenient (and in mode MODE if that's convenient). */
2734
2735 static rtx
2736 expand_builtin_strstr (tree arglist, tree type, rtx target, enum machine_mode mode)
2737 {
2738 if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2739 {
2740 tree result = fold_builtin_strstr (arglist, type);
2741 if (result)
2742 return expand_expr (result, target, mode, EXPAND_NORMAL);
2743 }
2744 return 0;
2745 }
2746
2747 /* Expand a call to the strchr builtin. Return 0 if we failed the
2748 caller should emit a normal call, otherwise try to get the result
2749 in TARGET, if convenient (and in mode MODE if that's convenient). */
2750
2751 static rtx
2752 expand_builtin_strchr (tree arglist, tree type, rtx target, enum machine_mode mode)
2753 {
2754 if (validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2755 {
2756 tree result = fold_builtin_strchr (arglist, type);
2757 if (result)
2758 return expand_expr (result, target, mode, EXPAND_NORMAL);
2759
2760 /* FIXME: Should use strchrM optab so that ports can optimize this. */
2761 }
2762 return 0;
2763 }
2764
2765 /* Expand a call to the strrchr builtin. Return 0 if we failed the
2766 caller should emit a normal call, otherwise try to get the result
2767 in TARGET, if convenient (and in mode MODE if that's convenient). */
2768
2769 static rtx
2770 expand_builtin_strrchr (tree arglist, tree type, rtx target, enum machine_mode mode)
2771 {
2772 if (validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2773 {
2774 tree result = fold_builtin_strrchr (arglist, type);
2775 if (result)
2776 return expand_expr (result, target, mode, EXPAND_NORMAL);
2777 }
2778 return 0;
2779 }
2780
2781 /* Expand a call to the strpbrk builtin. Return 0 if we failed the
2782 caller should emit a normal call, otherwise try to get the result
2783 in TARGET, if convenient (and in mode MODE if that's convenient). */
2784
2785 static rtx
2786 expand_builtin_strpbrk (tree arglist, tree type, rtx target, enum machine_mode mode)
2787 {
2788 if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2789 {
2790 tree result = fold_builtin_strpbrk (arglist, type);
2791 if (result)
2792 return expand_expr (result, target, mode, EXPAND_NORMAL);
2793 }
2794 return 0;
2795 }
2796
2797 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
2798 bytes from constant string DATA + OFFSET and return it as target
2799 constant. */
2800
2801 static rtx
2802 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
2803 enum machine_mode mode)
2804 {
2805 const char *str = (const char *) data;
2806
2807 gcc_assert (offset >= 0
2808 && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
2809 <= strlen (str) + 1));
2810
2811 return c_readstr (str + offset, mode);
2812 }
2813
2814 /* Expand a call to the memcpy builtin, with arguments in ARGLIST.
2815 Return 0 if we failed, the caller should emit a normal call,
2816 otherwise try to get the result in TARGET, if convenient (and in
2817 mode MODE if that's convenient). */
2818 static rtx
2819 expand_builtin_memcpy (tree exp, rtx target, enum machine_mode mode)
2820 {
2821 tree fndecl = get_callee_fndecl (exp);
2822 tree arglist = TREE_OPERAND (exp, 1);
2823 if (!validate_arglist (arglist,
2824 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2825 return 0;
2826 else
2827 {
2828 tree dest = TREE_VALUE (arglist);
2829 tree src = TREE_VALUE (TREE_CHAIN (arglist));
2830 tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2831 const char *src_str;
2832 unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
2833 unsigned int dest_align
2834 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
2835 rtx dest_mem, src_mem, dest_addr, len_rtx;
2836 tree result = fold_builtin_memory_op (arglist, TREE_TYPE (TREE_TYPE (fndecl)),
2837 false, /*endp=*/0);
2838
2839 if (result)
2840 {
2841 while (TREE_CODE (result) == COMPOUND_EXPR)
2842 {
2843 expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
2844 EXPAND_NORMAL);
2845 result = TREE_OPERAND (result, 1);
2846 }
2847 return expand_expr (result, target, mode, EXPAND_NORMAL);
2848 }
2849
2850 /* If DEST is not a pointer type, call the normal function. */
2851 if (dest_align == 0)
2852 return 0;
2853
2854 /* If either SRC is not a pointer type, don't do this
2855 operation in-line. */
2856 if (src_align == 0)
2857 return 0;
2858
2859 dest_mem = get_memory_rtx (dest, len);
2860 set_mem_align (dest_mem, dest_align);
2861 len_rtx = expand_normal (len);
2862 src_str = c_getstr (src);
2863
2864 /* If SRC is a string constant and block move would be done
2865 by pieces, we can avoid loading the string from memory
2866 and only stored the computed constants. */
2867 if (src_str
2868 && GET_CODE (len_rtx) == CONST_INT
2869 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
2870 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
2871 (void *) src_str, dest_align))
2872 {
2873 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
2874 builtin_memcpy_read_str,
2875 (void *) src_str, dest_align, 0);
2876 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2877 dest_mem = convert_memory_address (ptr_mode, dest_mem);
2878 return dest_mem;
2879 }
2880
2881 src_mem = get_memory_rtx (src, len);
2882 set_mem_align (src_mem, src_align);
2883
2884 /* Copy word part most expediently. */
2885 dest_addr = emit_block_move (dest_mem, src_mem, len_rtx,
2886 CALL_EXPR_TAILCALL (exp)
2887 ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL);
2888
2889 if (dest_addr == 0)
2890 {
2891 dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2892 dest_addr = convert_memory_address (ptr_mode, dest_addr);
2893 }
2894 return dest_addr;
2895 }
2896 }
2897
2898 /* Expand a call to the mempcpy builtin, with arguments in ARGLIST.
2899 Return 0 if we failed; the caller should emit a normal call,
2900 otherwise try to get the result in TARGET, if convenient (and in
2901 mode MODE if that's convenient). If ENDP is 0 return the
2902 destination pointer, if ENDP is 1 return the end pointer ala
2903 mempcpy, and if ENDP is 2 return the end pointer minus one ala
2904 stpcpy. */
2905
2906 static rtx
2907 expand_builtin_mempcpy (tree arglist, tree type, rtx target, enum machine_mode mode,
2908 int endp)
2909 {
2910 if (!validate_arglist (arglist,
2911 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2912 return 0;
2913 /* If return value is ignored, transform mempcpy into memcpy. */
2914 else if (target == const0_rtx)
2915 {
2916 tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
2917
2918 if (!fn)
2919 return 0;
2920
2921 return expand_expr (build_function_call_expr (fn, arglist),
2922 target, mode, EXPAND_NORMAL);
2923 }
2924 else
2925 {
2926 tree dest = TREE_VALUE (arglist);
2927 tree src = TREE_VALUE (TREE_CHAIN (arglist));
2928 tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
2929 const char *src_str;
2930 unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
2931 unsigned int dest_align
2932 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
2933 rtx dest_mem, src_mem, len_rtx;
2934 tree result = fold_builtin_memory_op (arglist, type, false, endp);
2935
2936 if (result)
2937 {
2938 while (TREE_CODE (result) == COMPOUND_EXPR)
2939 {
2940 expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
2941 EXPAND_NORMAL);
2942 result = TREE_OPERAND (result, 1);
2943 }
2944 return expand_expr (result, target, mode, EXPAND_NORMAL);
2945 }
2946
2947 /* If either SRC or DEST is not a pointer type, don't do this
2948 operation in-line. */
2949 if (dest_align == 0 || src_align == 0)
2950 return 0;
2951
2952 /* If LEN is not constant, call the normal function. */
2953 if (! host_integerp (len, 1))
2954 return 0;
2955
2956 len_rtx = expand_normal (len);
2957 src_str = c_getstr (src);
2958
2959 /* If SRC is a string constant and block move would be done
2960 by pieces, we can avoid loading the string from memory
2961 and only stored the computed constants. */
2962 if (src_str
2963 && GET_CODE (len_rtx) == CONST_INT
2964 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
2965 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
2966 (void *) src_str, dest_align))
2967 {
2968 dest_mem = get_memory_rtx (dest, len);
2969 set_mem_align (dest_mem, dest_align);
2970 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
2971 builtin_memcpy_read_str,
2972 (void *) src_str, dest_align, endp);
2973 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2974 dest_mem = convert_memory_address (ptr_mode, dest_mem);
2975 return dest_mem;
2976 }
2977
2978 if (GET_CODE (len_rtx) == CONST_INT
2979 && can_move_by_pieces (INTVAL (len_rtx),
2980 MIN (dest_align, src_align)))
2981 {
2982 dest_mem = get_memory_rtx (dest, len);
2983 set_mem_align (dest_mem, dest_align);
2984 src_mem = get_memory_rtx (src, len);
2985 set_mem_align (src_mem, src_align);
2986 dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
2987 MIN (dest_align, src_align), endp);
2988 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
2989 dest_mem = convert_memory_address (ptr_mode, dest_mem);
2990 return dest_mem;
2991 }
2992
2993 return 0;
2994 }
2995 }
2996
2997 /* Expand expression EXP, which is a call to the memmove builtin. Return 0
2998 if we failed; the caller should emit a normal call. */
2999
3000 static rtx
3001 expand_builtin_memmove (tree arglist, tree type, rtx target,
3002 enum machine_mode mode, tree orig_exp)
3003 {
3004 if (!validate_arglist (arglist,
3005 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3006 return 0;
3007 else
3008 {
3009 tree dest = TREE_VALUE (arglist);
3010 tree src = TREE_VALUE (TREE_CHAIN (arglist));
3011 tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3012
3013 unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3014 unsigned int dest_align
3015 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3016 tree result = fold_builtin_memory_op (arglist, type, false, /*endp=*/3);
3017
3018 if (result)
3019 {
3020 while (TREE_CODE (result) == COMPOUND_EXPR)
3021 {
3022 expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3023 EXPAND_NORMAL);
3024 result = TREE_OPERAND (result, 1);
3025 }
3026 return expand_expr (result, target, mode, EXPAND_NORMAL);
3027 }
3028
3029 /* If DEST is not a pointer type, call the normal function. */
3030 if (dest_align == 0)
3031 return 0;
3032
3033 /* If either SRC is not a pointer type, don't do this
3034 operation in-line. */
3035 if (src_align == 0)
3036 return 0;
3037
3038 /* If src is categorized for a readonly section we can use
3039 normal memcpy. */
3040 if (readonly_data_expr (src))
3041 {
3042 tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
3043 if (!fn)
3044 return 0;
3045 fn = build_function_call_expr (fn, arglist);
3046 if (TREE_CODE (fn) == CALL_EXPR)
3047 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
3048 return expand_expr (fn, target, mode, EXPAND_NORMAL);
3049 }
3050
3051 /* If length is 1 and we can expand memcpy call inline,
3052 it is ok to use memcpy as well. */
3053 if (integer_onep (len))
3054 {
3055 rtx ret = expand_builtin_mempcpy (arglist, type, target, mode,
3056 /*endp=*/0);
3057 if (ret)
3058 return ret;
3059 }
3060
3061 /* Otherwise, call the normal function. */
3062 return 0;
3063 }
3064 }
3065
3066 /* Expand expression EXP, which is a call to the bcopy builtin. Return 0
3067 if we failed the caller should emit a normal call. */
3068
3069 static rtx
3070 expand_builtin_bcopy (tree exp)
3071 {
3072 tree arglist = TREE_OPERAND (exp, 1);
3073 tree type = TREE_TYPE (exp);
3074 tree src, dest, size, newarglist;
3075
3076 if (!validate_arglist (arglist,
3077 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3078 return NULL_RTX;
3079
3080 src = TREE_VALUE (arglist);
3081 dest = TREE_VALUE (TREE_CHAIN (arglist));
3082 size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3083
3084 /* New argument list transforming bcopy(ptr x, ptr y, int z) to
3085 memmove(ptr y, ptr x, size_t z). This is done this way
3086 so that if it isn't expanded inline, we fallback to
3087 calling bcopy instead of memmove. */
3088
3089 newarglist = build_tree_list (NULL_TREE, fold_convert (sizetype, size));
3090 newarglist = tree_cons (NULL_TREE, src, newarglist);
3091 newarglist = tree_cons (NULL_TREE, dest, newarglist);
3092
3093 return expand_builtin_memmove (newarglist, type, const0_rtx, VOIDmode, exp);
3094 }
3095
3096 #ifndef HAVE_movstr
3097 # define HAVE_movstr 0
3098 # define CODE_FOR_movstr CODE_FOR_nothing
3099 #endif
3100
3101 /* Expand into a movstr instruction, if one is available. Return 0 if
3102 we failed, the caller should emit a normal call, otherwise try to
3103 get the result in TARGET, if convenient. If ENDP is 0 return the
3104 destination pointer, if ENDP is 1 return the end pointer ala
3105 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3106 stpcpy. */
3107
3108 static rtx
3109 expand_movstr (tree dest, tree src, rtx target, int endp)
3110 {
3111 rtx end;
3112 rtx dest_mem;
3113 rtx src_mem;
3114 rtx insn;
3115 const struct insn_data * data;
3116
3117 if (!HAVE_movstr)
3118 return 0;
3119
3120 dest_mem = get_memory_rtx (dest, NULL);
3121 src_mem = get_memory_rtx (src, NULL);
3122 if (!endp)
3123 {
3124 target = force_reg (Pmode, XEXP (dest_mem, 0));
3125 dest_mem = replace_equiv_address (dest_mem, target);
3126 end = gen_reg_rtx (Pmode);
3127 }
3128 else
3129 {
3130 if (target == 0 || target == const0_rtx)
3131 {
3132 end = gen_reg_rtx (Pmode);
3133 if (target == 0)
3134 target = end;
3135 }
3136 else
3137 end = target;
3138 }
3139
3140 data = insn_data + CODE_FOR_movstr;
3141
3142 if (data->operand[0].mode != VOIDmode)
3143 end = gen_lowpart (data->operand[0].mode, end);
3144
3145 insn = data->genfun (end, dest_mem, src_mem);
3146
3147 gcc_assert (insn);
3148
3149 emit_insn (insn);
3150
3151 /* movstr is supposed to set end to the address of the NUL
3152 terminator. If the caller requested a mempcpy-like return value,
3153 adjust it. */
3154 if (endp == 1 && target != const0_rtx)
3155 {
3156 rtx tem = plus_constant (gen_lowpart (GET_MODE (target), end), 1);
3157 emit_move_insn (target, force_operand (tem, NULL_RTX));
3158 }
3159
3160 return target;
3161 }
3162
3163 /* Expand expression EXP, which is a call to the strcpy builtin. Return 0
3164 if we failed the caller should emit a normal call, otherwise try to get
3165 the result in TARGET, if convenient (and in mode MODE if that's
3166 convenient). */
3167
3168 static rtx
3169 expand_builtin_strcpy (tree fndecl, tree arglist, rtx target, enum machine_mode mode)
3170 {
3171 if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3172 {
3173 tree result = fold_builtin_strcpy (fndecl, arglist, 0);
3174 if (result)
3175 {
3176 while (TREE_CODE (result) == COMPOUND_EXPR)
3177 {
3178 expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3179 EXPAND_NORMAL);
3180 result = TREE_OPERAND (result, 1);
3181 }
3182 return expand_expr (result, target, mode, EXPAND_NORMAL);
3183 }
3184
3185 return expand_movstr (TREE_VALUE (arglist),
3186 TREE_VALUE (TREE_CHAIN (arglist)),
3187 target, /*endp=*/0);
3188 }
3189 return 0;
3190 }
3191
3192 /* Expand a call to the stpcpy builtin, with arguments in ARGLIST.
3193 Return 0 if we failed the caller should emit a normal call,
3194 otherwise try to get the result in TARGET, if convenient (and in
3195 mode MODE if that's convenient). */
3196
3197 static rtx
3198 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
3199 {
3200 tree arglist = TREE_OPERAND (exp, 1);
3201 /* If return value is ignored, transform stpcpy into strcpy. */
3202 if (target == const0_rtx)
3203 {
3204 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
3205 if (!fn)
3206 return 0;
3207
3208 return expand_expr (build_function_call_expr (fn, arglist),
3209 target, mode, EXPAND_NORMAL);
3210 }
3211
3212 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3213 return 0;
3214 else
3215 {
3216 tree dst, src, len, lenp1;
3217 tree narglist;
3218 rtx ret;
3219
3220 /* Ensure we get an actual string whose length can be evaluated at
3221 compile-time, not an expression containing a string. This is
3222 because the latter will potentially produce pessimized code
3223 when used to produce the return value. */
3224 src = TREE_VALUE (TREE_CHAIN (arglist));
3225 if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3226 return expand_movstr (TREE_VALUE (arglist),
3227 TREE_VALUE (TREE_CHAIN (arglist)),
3228 target, /*endp=*/2);
3229
3230 dst = TREE_VALUE (arglist);
3231 lenp1 = size_binop (PLUS_EXPR, len, ssize_int (1));
3232 narglist = build_tree_list (NULL_TREE, lenp1);
3233 narglist = tree_cons (NULL_TREE, src, narglist);
3234 narglist = tree_cons (NULL_TREE, dst, narglist);
3235 ret = expand_builtin_mempcpy (narglist, TREE_TYPE (exp),
3236 target, mode, /*endp=*/2);
3237
3238 if (ret)
3239 return ret;
3240
3241 if (TREE_CODE (len) == INTEGER_CST)
3242 {
3243 rtx len_rtx = expand_normal (len);
3244
3245 if (GET_CODE (len_rtx) == CONST_INT)
3246 {
3247 ret = expand_builtin_strcpy (get_callee_fndecl (exp),
3248 arglist, target, mode);
3249
3250 if (ret)
3251 {
3252 if (! target)
3253 {
3254 if (mode != VOIDmode)
3255 target = gen_reg_rtx (mode);
3256 else
3257 target = gen_reg_rtx (GET_MODE (ret));
3258 }
3259 if (GET_MODE (target) != GET_MODE (ret))
3260 ret = gen_lowpart (GET_MODE (target), ret);
3261
3262 ret = plus_constant (ret, INTVAL (len_rtx));
3263 ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3264 gcc_assert (ret);
3265
3266 return target;
3267 }
3268 }
3269 }
3270
3271 return expand_movstr (TREE_VALUE (arglist),
3272 TREE_VALUE (TREE_CHAIN (arglist)),
3273 target, /*endp=*/2);
3274 }
3275 }
3276
3277 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3278 bytes from constant string DATA + OFFSET and return it as target
3279 constant. */
3280
3281 static rtx
3282 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3283 enum machine_mode mode)
3284 {
3285 const char *str = (const char *) data;
3286
3287 if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3288 return const0_rtx;
3289
3290 return c_readstr (str + offset, mode);
3291 }
3292
3293 /* Expand expression EXP, which is a call to the strncpy builtin. Return 0
3294 if we failed the caller should emit a normal call. */
3295
3296 static rtx
3297 expand_builtin_strncpy (tree exp, rtx target, enum machine_mode mode)
3298 {
3299 tree fndecl = get_callee_fndecl (exp);
3300 tree arglist = TREE_OPERAND (exp, 1);
3301 if (validate_arglist (arglist,
3302 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3303 {
3304 tree slen = c_strlen (TREE_VALUE (TREE_CHAIN (arglist)), 1);
3305 tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3306 tree result = fold_builtin_strncpy (fndecl, arglist, slen);
3307
3308 if (result)
3309 {
3310 while (TREE_CODE (result) == COMPOUND_EXPR)
3311 {
3312 expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3313 EXPAND_NORMAL);
3314 result = TREE_OPERAND (result, 1);
3315 }
3316 return expand_expr (result, target, mode, EXPAND_NORMAL);
3317 }
3318
3319 /* We must be passed a constant len and src parameter. */
3320 if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
3321 return 0;
3322
3323 slen = size_binop (PLUS_EXPR, slen, ssize_int (1));
3324
3325 /* We're required to pad with trailing zeros if the requested
3326 len is greater than strlen(s2)+1. In that case try to
3327 use store_by_pieces, if it fails, punt. */
3328 if (tree_int_cst_lt (slen, len))
3329 {
3330 tree dest = TREE_VALUE (arglist);
3331 unsigned int dest_align
3332 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3333 const char *p = c_getstr (TREE_VALUE (TREE_CHAIN (arglist)));
3334 rtx dest_mem;
3335
3336 if (!p || dest_align == 0 || !host_integerp (len, 1)
3337 || !can_store_by_pieces (tree_low_cst (len, 1),
3338 builtin_strncpy_read_str,
3339 (void *) p, dest_align))
3340 return 0;
3341
3342 dest_mem = get_memory_rtx (dest, len);
3343 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3344 builtin_strncpy_read_str,
3345 (void *) p, dest_align, 0);
3346 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3347 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3348 return dest_mem;
3349 }
3350 }
3351 return 0;
3352 }
3353
3354 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3355 bytes from constant string DATA + OFFSET and return it as target
3356 constant. */
3357
3358 static rtx
3359 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3360 enum machine_mode mode)
3361 {
3362 const char *c = (const char *) data;
3363 char *p = alloca (GET_MODE_SIZE (mode));
3364
3365 memset (p, *c, GET_MODE_SIZE (mode));
3366
3367 return c_readstr (p, mode);
3368 }
3369
3370 /* Callback routine for store_by_pieces. Return the RTL of a register
3371 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3372 char value given in the RTL register data. For example, if mode is
3373 4 bytes wide, return the RTL for 0x01010101*data. */
3374
3375 static rtx
3376 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3377 enum machine_mode mode)
3378 {
3379 rtx target, coeff;
3380 size_t size;
3381 char *p;
3382
3383 size = GET_MODE_SIZE (mode);
3384 if (size == 1)
3385 return (rtx) data;
3386
3387 p = alloca (size);
3388 memset (p, 1, size);
3389 coeff = c_readstr (p, mode);
3390
3391 target = convert_to_mode (mode, (rtx) data, 1);
3392 target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3393 return force_reg (mode, target);
3394 }
3395
3396 /* Expand expression EXP, which is a call to the memset builtin. Return 0
3397 if we failed the caller should emit a normal call, otherwise try to get
3398 the result in TARGET, if convenient (and in mode MODE if that's
3399 convenient). */
3400
3401 static rtx
3402 expand_builtin_memset (tree arglist, rtx target, enum machine_mode mode,
3403 tree orig_exp)
3404 {
3405 if (!validate_arglist (arglist,
3406 POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3407 return 0;
3408 else
3409 {
3410 tree dest = TREE_VALUE (arglist);
3411 tree val = TREE_VALUE (TREE_CHAIN (arglist));
3412 tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3413 tree fndecl, fn;
3414 enum built_in_function fcode;
3415 char c;
3416 unsigned int dest_align;
3417 rtx dest_mem, dest_addr, len_rtx;
3418
3419 dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3420
3421 /* If DEST is not a pointer type, don't do this
3422 operation in-line. */
3423 if (dest_align == 0)
3424 return 0;
3425
3426 /* If the LEN parameter is zero, return DEST. */
3427 if (integer_zerop (len))
3428 {
3429 /* Evaluate and ignore VAL in case it has side-effects. */
3430 expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3431 return expand_expr (dest, target, mode, EXPAND_NORMAL);
3432 }
3433
3434 /* Stabilize the arguments in case we fail. */
3435 dest = builtin_save_expr (dest);
3436 val = builtin_save_expr (val);
3437 len = builtin_save_expr (len);
3438
3439 len_rtx = expand_normal (len);
3440 dest_mem = get_memory_rtx (dest, len);
3441
3442 if (TREE_CODE (val) != INTEGER_CST)
3443 {
3444 rtx val_rtx;
3445
3446 val_rtx = expand_normal (val);
3447 val_rtx = convert_to_mode (TYPE_MODE (unsigned_char_type_node),
3448 val_rtx, 0);
3449
3450 /* Assume that we can memset by pieces if we can store the
3451 * the coefficients by pieces (in the required modes).
3452 * We can't pass builtin_memset_gen_str as that emits RTL. */
3453 c = 1;
3454 if (host_integerp (len, 1)
3455 && !(optimize_size && tree_low_cst (len, 1) > 1)
3456 && can_store_by_pieces (tree_low_cst (len, 1),
3457 builtin_memset_read_str, &c, dest_align))
3458 {
3459 val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
3460 val_rtx);
3461 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3462 builtin_memset_gen_str, val_rtx, dest_align, 0);
3463 }
3464 else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
3465 dest_align))
3466 goto do_libcall;
3467
3468 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3469 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3470 return dest_mem;
3471 }
3472
3473 if (target_char_cast (val, &c))
3474 goto do_libcall;
3475
3476 if (c)
3477 {
3478 if (host_integerp (len, 1)
3479 && !(optimize_size && tree_low_cst (len, 1) > 1)
3480 && can_store_by_pieces (tree_low_cst (len, 1),
3481 builtin_memset_read_str, &c, dest_align))
3482 store_by_pieces (dest_mem, tree_low_cst (len, 1),
3483 builtin_memset_read_str, &c, dest_align, 0);
3484 else if (!set_storage_via_setmem (dest_mem, len_rtx, GEN_INT (c),
3485 dest_align))
3486 goto do_libcall;
3487
3488 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3489 dest_mem = convert_memory_address (ptr_mode, dest_mem);
3490 return dest_mem;
3491 }
3492
3493 set_mem_align (dest_mem, dest_align);
3494 dest_addr = clear_storage (dest_mem, len_rtx,
3495 CALL_EXPR_TAILCALL (orig_exp)
3496 ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL);
3497
3498 if (dest_addr == 0)
3499 {
3500 dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3501 dest_addr = convert_memory_address (ptr_mode, dest_addr);
3502 }
3503
3504 return dest_addr;
3505
3506 do_libcall:
3507 fndecl = get_callee_fndecl (orig_exp);
3508 fcode = DECL_FUNCTION_CODE (fndecl);
3509 gcc_assert (fcode == BUILT_IN_MEMSET || fcode == BUILT_IN_BZERO);
3510 arglist = build_tree_list (NULL_TREE, len);
3511 if (fcode == BUILT_IN_MEMSET)
3512 arglist = tree_cons (NULL_TREE, val, arglist);
3513 arglist = tree_cons (NULL_TREE, dest, arglist);
3514 fn = build_function_call_expr (fndecl, arglist);
3515 if (TREE_CODE (fn) == CALL_EXPR)
3516 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
3517 return expand_call (fn, target, target == const0_rtx);
3518 }
3519 }
3520
3521 /* Expand expression EXP, which is a call to the bzero builtin. Return 0
3522 if we failed the caller should emit a normal call. */
3523
3524 static rtx
3525 expand_builtin_bzero (tree exp)
3526 {
3527 tree arglist = TREE_OPERAND (exp, 1);
3528 tree dest, size, newarglist;
3529
3530 if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3531 return NULL_RTX;
3532
3533 dest = TREE_VALUE (arglist);
3534 size = TREE_VALUE (TREE_CHAIN (arglist));
3535
3536 /* New argument list transforming bzero(ptr x, int y) to
3537 memset(ptr x, int 0, size_t y). This is done this way
3538 so that if it isn't expanded inline, we fallback to
3539 calling bzero instead of memset. */
3540
3541 newarglist = build_tree_list (NULL_TREE, fold_convert (sizetype, size));
3542 newarglist = tree_cons (NULL_TREE, integer_zero_node, newarglist);
3543 newarglist = tree_cons (NULL_TREE, dest, newarglist);
3544
3545 return expand_builtin_memset (newarglist, const0_rtx, VOIDmode, exp);
3546 }
3547
3548 /* Expand expression EXP, which is a call to the memcmp built-in function.
3549 ARGLIST is the argument list for this call. Return 0 if we failed and the
3550 caller should emit a normal call, otherwise try to get the result in
3551 TARGET, if convenient (and in mode MODE, if that's convenient). */
3552
3553 static rtx
3554 expand_builtin_memcmp (tree exp ATTRIBUTE_UNUSED, tree arglist, rtx target,
3555 enum machine_mode mode)
3556 {
3557 if (!validate_arglist (arglist,
3558 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3559 return 0;
3560 else
3561 {
3562 tree result = fold_builtin_memcmp (arglist);
3563 if (result)
3564 return expand_expr (result, target, mode, EXPAND_NORMAL);
3565 }
3566
3567 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrnsi
3568 {
3569 tree arg1 = TREE_VALUE (arglist);
3570 tree arg2 = TREE_VALUE (TREE_CHAIN (arglist));
3571 tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3572 rtx arg1_rtx, arg2_rtx, arg3_rtx;
3573 rtx result;
3574 rtx insn;
3575
3576 int arg1_align
3577 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3578 int arg2_align
3579 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3580 enum machine_mode insn_mode;
3581
3582 #ifdef HAVE_cmpmemsi
3583 if (HAVE_cmpmemsi)
3584 insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
3585 else
3586 #endif
3587 #ifdef HAVE_cmpstrnsi
3588 if (HAVE_cmpstrnsi)
3589 insn_mode = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
3590 else
3591 #endif
3592 return 0;
3593
3594 /* If we don't have POINTER_TYPE, call the function. */
3595 if (arg1_align == 0 || arg2_align == 0)
3596 return 0;
3597
3598 /* Make a place to write the result of the instruction. */
3599 result = target;
3600 if (! (result != 0
3601 && REG_P (result) && GET_MODE (result) == insn_mode
3602 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3603 result = gen_reg_rtx (insn_mode);
3604
3605 arg1_rtx = get_memory_rtx (arg1, len);
3606 arg2_rtx = get_memory_rtx (arg2, len);
3607 arg3_rtx = expand_normal (len);
3608
3609 /* Set MEM_SIZE as appropriate. */
3610 if (GET_CODE (arg3_rtx) == CONST_INT)
3611 {
3612 set_mem_size (arg1_rtx, arg3_rtx);
3613 set_mem_size (arg2_rtx, arg3_rtx);
3614 }
3615
3616 #ifdef HAVE_cmpmemsi
3617 if (HAVE_cmpmemsi)
3618 insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3619 GEN_INT (MIN (arg1_align, arg2_align)));
3620 else
3621 #endif
3622 #ifdef HAVE_cmpstrnsi
3623 if (HAVE_cmpstrnsi)
3624 insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3625 GEN_INT (MIN (arg1_align, arg2_align)));
3626 else
3627 #endif
3628 gcc_unreachable ();
3629
3630 if (insn)
3631 emit_insn (insn);
3632 else
3633 emit_library_call_value (memcmp_libfunc, result, LCT_PURE_MAKE_BLOCK,
3634 TYPE_MODE (integer_type_node), 3,
3635 XEXP (arg1_rtx, 0), Pmode,
3636 XEXP (arg2_rtx, 0), Pmode,
3637 convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
3638 TYPE_UNSIGNED (sizetype)),
3639 TYPE_MODE (sizetype));
3640
3641 /* Return the value in the proper mode for this function. */
3642 mode = TYPE_MODE (TREE_TYPE (exp));
3643 if (GET_MODE (result) == mode)
3644 return result;
3645 else if (target != 0)
3646 {
3647 convert_move (target, result, 0);
3648 return target;
3649 }
3650 else
3651 return convert_to_mode (mode, result, 0);
3652 }
3653 #endif
3654
3655 return 0;
3656 }
3657
3658 /* Expand expression EXP, which is a call to the strcmp builtin. Return 0
3659 if we failed the caller should emit a normal call, otherwise try to get
3660 the result in TARGET, if convenient. */
3661
3662 static rtx
3663 expand_builtin_strcmp (tree exp, rtx target, enum machine_mode mode)
3664 {
3665 tree arglist = TREE_OPERAND (exp, 1);
3666
3667 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3668 return 0;
3669 else
3670 {
3671 tree result = fold_builtin_strcmp (arglist);
3672 if (result)
3673 return expand_expr (result, target, mode, EXPAND_NORMAL);
3674 }
3675
3676 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
3677 if (cmpstr_optab[SImode] != CODE_FOR_nothing
3678 || cmpstrn_optab[SImode] != CODE_FOR_nothing)
3679 {
3680 rtx arg1_rtx, arg2_rtx;
3681 rtx result, insn = NULL_RTX;
3682 tree fndecl, fn;
3683
3684 tree arg1 = TREE_VALUE (arglist);
3685 tree arg2 = TREE_VALUE (TREE_CHAIN (arglist));
3686 int arg1_align
3687 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3688 int arg2_align
3689 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3690
3691 /* If we don't have POINTER_TYPE, call the function. */
3692 if (arg1_align == 0 || arg2_align == 0)
3693 return 0;
3694
3695 /* Stabilize the arguments in case gen_cmpstr(n)si fail. */
3696 arg1 = builtin_save_expr (arg1);
3697 arg2 = builtin_save_expr (arg2);
3698
3699 arg1_rtx = get_memory_rtx (arg1, NULL);
3700 arg2_rtx = get_memory_rtx (arg2, NULL);
3701
3702 #ifdef HAVE_cmpstrsi
3703 /* Try to call cmpstrsi. */
3704 if (HAVE_cmpstrsi)
3705 {
3706 enum machine_mode insn_mode
3707 = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
3708
3709 /* Make a place to write the result of the instruction. */
3710 result = target;
3711 if (! (result != 0
3712 && REG_P (result) && GET_MODE (result) == insn_mode
3713 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3714 result = gen_reg_rtx (insn_mode);
3715
3716 insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx,
3717 GEN_INT (MIN (arg1_align, arg2_align)));
3718 }
3719 #endif
3720 #ifdef HAVE_cmpstrnsi
3721 /* Try to determine at least one length and call cmpstrnsi. */
3722 if (!insn && HAVE_cmpstrnsi)
3723 {
3724 tree len;
3725 rtx arg3_rtx;
3726
3727 enum machine_mode insn_mode
3728 = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
3729 tree len1 = c_strlen (arg1, 1);
3730 tree len2 = c_strlen (arg2, 1);
3731
3732 if (len1)
3733 len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
3734 if (len2)
3735 len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
3736
3737 /* If we don't have a constant length for the first, use the length
3738 of the second, if we know it. We don't require a constant for
3739 this case; some cost analysis could be done if both are available
3740 but neither is constant. For now, assume they're equally cheap,
3741 unless one has side effects. If both strings have constant lengths,
3742 use the smaller. */
3743
3744 if (!len1)
3745 len = len2;
3746 else if (!len2)
3747 len = len1;
3748 else if (TREE_SIDE_EFFECTS (len1))
3749 len = len2;
3750 else if (TREE_SIDE_EFFECTS (len2))
3751 len = len1;
3752 else if (TREE_CODE (len1) != INTEGER_CST)
3753 len = len2;
3754 else if (TREE_CODE (len2) != INTEGER_CST)
3755 len = len1;
3756 else if (tree_int_cst_lt (len1, len2))
3757 len = len1;
3758 else
3759 len = len2;
3760
3761 /* If both arguments have side effects, we cannot optimize. */
3762 if (!len || TREE_SIDE_EFFECTS (len))
3763 goto do_libcall;
3764
3765 arg3_rtx = expand_normal (len);
3766
3767 /* Make a place to write the result of the instruction. */
3768 result = target;
3769 if (! (result != 0
3770 && REG_P (result) && GET_MODE (result) == insn_mode
3771 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3772 result = gen_reg_rtx (insn_mode);
3773
3774 insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3775 GEN_INT (MIN (arg1_align, arg2_align)));
3776 }
3777 #endif
3778
3779 if (insn)
3780 {
3781 emit_insn (insn);
3782
3783 /* Return the value in the proper mode for this function. */
3784 mode = TYPE_MODE (TREE_TYPE (exp));
3785 if (GET_MODE (result) == mode)
3786 return result;
3787 if (target == 0)
3788 return convert_to_mode (mode, result, 0);
3789 convert_move (target, result, 0);
3790 return target;
3791 }
3792
3793 /* Expand the library call ourselves using a stabilized argument
3794 list to avoid re-evaluating the function's arguments twice. */
3795 #ifdef HAVE_cmpstrnsi
3796 do_libcall:
3797 #endif
3798 arglist = build_tree_list (NULL_TREE, arg2);
3799 arglist = tree_cons (NULL_TREE, arg1, arglist);
3800 fndecl = get_callee_fndecl (exp);
3801 fn = build_function_call_expr (fndecl, arglist);
3802 if (TREE_CODE (fn) == CALL_EXPR)
3803 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
3804 return expand_call (fn, target, target == const0_rtx);
3805 }
3806 #endif
3807 return 0;
3808 }
3809
3810 /* Expand expression EXP, which is a call to the strncmp builtin. Return 0
3811 if we failed the caller should emit a normal call, otherwise try to get
3812 the result in TARGET, if convenient. */
3813
3814 static rtx
3815 expand_builtin_strncmp (tree exp, rtx target, enum machine_mode mode)
3816 {
3817 tree arglist = TREE_OPERAND (exp, 1);
3818
3819 if (!validate_arglist (arglist,
3820 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3821 return 0;
3822 else
3823 {
3824 tree result = fold_builtin_strncmp (arglist);
3825 if (result)
3826 return expand_expr (result, target, mode, EXPAND_NORMAL);
3827 }
3828
3829 /* If c_strlen can determine an expression for one of the string
3830 lengths, and it doesn't have side effects, then emit cmpstrnsi
3831 using length MIN(strlen(string)+1, arg3). */
3832 #ifdef HAVE_cmpstrnsi
3833 if (HAVE_cmpstrnsi)
3834 {
3835 tree arg1 = TREE_VALUE (arglist);
3836 tree arg2 = TREE_VALUE (TREE_CHAIN (arglist));
3837 tree arg3 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
3838 tree len, len1, len2;
3839 rtx arg1_rtx, arg2_rtx, arg3_rtx;
3840 rtx result, insn;
3841 tree fndecl, fn;
3842
3843 int arg1_align
3844 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3845 int arg2_align
3846 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3847 enum machine_mode insn_mode
3848 = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
3849
3850 len1 = c_strlen (arg1, 1);
3851 len2 = c_strlen (arg2, 1);
3852
3853 if (len1)
3854 len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
3855 if (len2)
3856 len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
3857
3858 /* If we don't have a constant length for the first, use the length
3859 of the second, if we know it. We don't require a constant for
3860 this case; some cost analysis could be done if both are available
3861 but neither is constant. For now, assume they're equally cheap,
3862 unless one has side effects. If both strings have constant lengths,
3863 use the smaller. */
3864
3865 if (!len1)
3866 len = len2;
3867 else if (!len2)
3868 len = len1;
3869 else if (TREE_SIDE_EFFECTS (len1))
3870 len = len2;
3871 else if (TREE_SIDE_EFFECTS (len2))
3872 len = len1;
3873 else if (TREE_CODE (len1) != INTEGER_CST)
3874 len = len2;
3875 else if (TREE_CODE (len2) != INTEGER_CST)
3876 len = len1;
3877 else if (tree_int_cst_lt (len1, len2))
3878 len = len1;
3879 else
3880 len = len2;
3881
3882 /* If both arguments have side effects, we cannot optimize. */
3883 if (!len || TREE_SIDE_EFFECTS (len))
3884 return 0;
3885
3886 /* The actual new length parameter is MIN(len,arg3). */
3887 len = fold_build2 (MIN_EXPR, TREE_TYPE (len), len,
3888 fold_convert (TREE_TYPE (len), arg3));
3889
3890 /* If we don't have POINTER_TYPE, call the function. */
3891 if (arg1_align == 0 || arg2_align == 0)
3892 return 0;
3893
3894 /* Make a place to write the result of the instruction. */
3895 result = target;
3896 if (! (result != 0
3897 && REG_P (result) && GET_MODE (result) == insn_mode
3898 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3899 result = gen_reg_rtx (insn_mode);
3900
3901 /* Stabilize the arguments in case gen_cmpstrnsi fails. */
3902 arg1 = builtin_save_expr (arg1);
3903 arg2 = builtin_save_expr (arg2);
3904 len = builtin_save_expr (len);
3905
3906 arg1_rtx = get_memory_rtx (arg1, len);
3907 arg2_rtx = get_memory_rtx (arg2, len);
3908 arg3_rtx = expand_normal (len);
3909 insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3910 GEN_INT (MIN (arg1_align, arg2_align)));
3911 if (insn)
3912 {
3913 emit_insn (insn);
3914
3915 /* Return the value in the proper mode for this function. */
3916 mode = TYPE_MODE (TREE_TYPE (exp));
3917 if (GET_MODE (result) == mode)
3918 return result;
3919 if (target == 0)
3920 return convert_to_mode (mode, result, 0);
3921 convert_move (target, result, 0);
3922 return target;
3923 }
3924
3925 /* Expand the library call ourselves using a stabilized argument
3926 list to avoid re-evaluating the function's arguments twice. */
3927 arglist = build_tree_list (NULL_TREE, len);
3928 arglist = tree_cons (NULL_TREE, arg2, arglist);
3929 arglist = tree_cons (NULL_TREE, arg1, arglist);
3930 fndecl = get_callee_fndecl (exp);
3931 fn = build_function_call_expr (fndecl, arglist);
3932 if (TREE_CODE (fn) == CALL_EXPR)
3933 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
3934 return expand_call (fn, target, target == const0_rtx);
3935 }
3936 #endif
3937 return 0;
3938 }
3939
3940 /* Expand expression EXP, which is a call to the strcat builtin.
3941 Return 0 if we failed the caller should emit a normal call,
3942 otherwise try to get the result in TARGET, if convenient. */
3943
3944 static rtx
3945 expand_builtin_strcat (tree fndecl, tree arglist, rtx target, enum machine_mode mode)
3946 {
3947 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3948 return 0;
3949 else
3950 {
3951 tree dst = TREE_VALUE (arglist),
3952 src = TREE_VALUE (TREE_CHAIN (arglist));
3953 const char *p = c_getstr (src);
3954
3955 /* If the string length is zero, return the dst parameter. */
3956 if (p && *p == '\0')
3957 return expand_expr (dst, target, mode, EXPAND_NORMAL);
3958
3959 if (!optimize_size)
3960 {
3961 /* See if we can store by pieces into (dst + strlen(dst)). */
3962 tree newsrc, newdst,
3963 strlen_fn = implicit_built_in_decls[BUILT_IN_STRLEN];
3964 rtx insns;
3965
3966 /* Stabilize the argument list. */
3967 newsrc = builtin_save_expr (src);
3968 if (newsrc != src)
3969 arglist = build_tree_list (NULL_TREE, newsrc);
3970 else
3971 arglist = TREE_CHAIN (arglist); /* Reusing arglist if safe. */
3972
3973 dst = builtin_save_expr (dst);
3974
3975 start_sequence ();
3976
3977 /* Create strlen (dst). */
3978 newdst =
3979 build_function_call_expr (strlen_fn,
3980 build_tree_list (NULL_TREE, dst));
3981 /* Create (dst + (cast) strlen (dst)). */
3982 newdst = fold_convert (TREE_TYPE (dst), newdst);
3983 newdst = fold_build2 (PLUS_EXPR, TREE_TYPE (dst), dst, newdst);
3984
3985 newdst = builtin_save_expr (newdst);
3986 arglist = tree_cons (NULL_TREE, newdst, arglist);
3987
3988 if (!expand_builtin_strcpy (fndecl, arglist, target, mode))
3989 {
3990 end_sequence (); /* Stop sequence. */
3991 return 0;
3992 }
3993
3994 /* Output the entire sequence. */
3995 insns = get_insns ();
3996 end_sequence ();
3997 emit_insn (insns);
3998
3999 return expand_expr (dst, target, mode, EXPAND_NORMAL);
4000 }
4001
4002 return 0;
4003 }
4004 }
4005
4006 /* Expand expression EXP, which is a call to the strncat builtin.
4007 Return 0 if we failed the caller should emit a normal call,
4008 otherwise try to get the result in TARGET, if convenient. */
4009
4010 static rtx
4011 expand_builtin_strncat (tree arglist, rtx target, enum machine_mode mode)
4012 {
4013 if (validate_arglist (arglist,
4014 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4015 {
4016 tree result = fold_builtin_strncat (arglist);
4017 if (result)
4018 return expand_expr (result, target, mode, EXPAND_NORMAL);
4019 }
4020 return 0;
4021 }
4022
4023 /* Expand expression EXP, which is a call to the strspn builtin.
4024 Return 0 if we failed the caller should emit a normal call,
4025 otherwise try to get the result in TARGET, if convenient. */
4026
4027 static rtx
4028 expand_builtin_strspn (tree arglist, rtx target, enum machine_mode mode)
4029 {
4030 if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4031 {
4032 tree result = fold_builtin_strspn (arglist);
4033 if (result)
4034 return expand_expr (result, target, mode, EXPAND_NORMAL);
4035 }
4036 return 0;
4037 }
4038
4039 /* Expand expression EXP, which is a call to the strcspn builtin.
4040 Return 0 if we failed the caller should emit a normal call,
4041 otherwise try to get the result in TARGET, if convenient. */
4042
4043 static rtx
4044 expand_builtin_strcspn (tree arglist, rtx target, enum machine_mode mode)
4045 {
4046 if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4047 {
4048 tree result = fold_builtin_strcspn (arglist);
4049 if (result)
4050 return expand_expr (result, target, mode, EXPAND_NORMAL);
4051 }
4052 return 0;
4053 }
4054
4055 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4056 if that's convenient. */
4057
4058 rtx
4059 expand_builtin_saveregs (void)
4060 {
4061 rtx val, seq;
4062
4063 /* Don't do __builtin_saveregs more than once in a function.
4064 Save the result of the first call and reuse it. */
4065 if (saveregs_value != 0)
4066 return saveregs_value;
4067
4068 /* When this function is called, it means that registers must be
4069 saved on entry to this function. So we migrate the call to the
4070 first insn of this function. */
4071
4072 start_sequence ();
4073
4074 /* Do whatever the machine needs done in this case. */
4075 val = targetm.calls.expand_builtin_saveregs ();
4076
4077 seq = get_insns ();
4078 end_sequence ();
4079
4080 saveregs_value = val;
4081
4082 /* Put the insns after the NOTE that starts the function. If this
4083 is inside a start_sequence, make the outer-level insn chain current, so
4084 the code is placed at the start of the function. */
4085 push_topmost_sequence ();
4086 emit_insn_after (seq, entry_of_function ());
4087 pop_topmost_sequence ();
4088
4089 return val;
4090 }
4091
4092 /* __builtin_args_info (N) returns word N of the arg space info
4093 for the current function. The number and meanings of words
4094 is controlled by the definition of CUMULATIVE_ARGS. */
4095
4096 static rtx
4097 expand_builtin_args_info (tree arglist)
4098 {
4099 int nwords = sizeof (CUMULATIVE_ARGS) / sizeof (int);
4100 int *word_ptr = (int *) &current_function_args_info;
4101
4102 gcc_assert (sizeof (CUMULATIVE_ARGS) % sizeof (int) == 0);
4103
4104 if (arglist != 0)
4105 {
4106 if (!host_integerp (TREE_VALUE (arglist), 0))
4107 error ("argument of %<__builtin_args_info%> must be constant");
4108 else
4109 {
4110 HOST_WIDE_INT wordnum = tree_low_cst (TREE_VALUE (arglist), 0);
4111
4112 if (wordnum < 0 || wordnum >= nwords)
4113 error ("argument of %<__builtin_args_info%> out of range");
4114 else
4115 return GEN_INT (word_ptr[wordnum]);
4116 }
4117 }
4118 else
4119 error ("missing argument in %<__builtin_args_info%>");
4120
4121 return const0_rtx;
4122 }
4123
4124 /* Expand a call to __builtin_next_arg. */
4125
4126 static rtx
4127 expand_builtin_next_arg (void)
4128 {
4129 /* Checking arguments is already done in fold_builtin_next_arg
4130 that must be called before this function. */
4131 return expand_binop (Pmode, add_optab,
4132 current_function_internal_arg_pointer,
4133 current_function_arg_offset_rtx,
4134 NULL_RTX, 0, OPTAB_LIB_WIDEN);
4135 }
4136
4137 /* Make it easier for the backends by protecting the valist argument
4138 from multiple evaluations. */
4139
4140 static tree
4141 stabilize_va_list (tree valist, int needs_lvalue)
4142 {
4143 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
4144 {
4145 if (TREE_SIDE_EFFECTS (valist))
4146 valist = save_expr (valist);
4147
4148 /* For this case, the backends will be expecting a pointer to
4149 TREE_TYPE (va_list_type_node), but it's possible we've
4150 actually been given an array (an actual va_list_type_node).
4151 So fix it. */
4152 if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4153 {
4154 tree p1 = build_pointer_type (TREE_TYPE (va_list_type_node));
4155 valist = build_fold_addr_expr_with_type (valist, p1);
4156 }
4157 }
4158 else
4159 {
4160 tree pt;
4161
4162 if (! needs_lvalue)
4163 {
4164 if (! TREE_SIDE_EFFECTS (valist))
4165 return valist;
4166
4167 pt = build_pointer_type (va_list_type_node);
4168 valist = fold_build1 (ADDR_EXPR, pt, valist);
4169 TREE_SIDE_EFFECTS (valist) = 1;
4170 }
4171
4172 if (TREE_SIDE_EFFECTS (valist))
4173 valist = save_expr (valist);
4174 valist = build_fold_indirect_ref (valist);
4175 }
4176
4177 return valist;
4178 }
4179
4180 /* The "standard" definition of va_list is void*. */
4181
4182 tree
4183 std_build_builtin_va_list (void)
4184 {
4185 return ptr_type_node;
4186 }
4187
4188 /* The "standard" implementation of va_start: just assign `nextarg' to
4189 the variable. */
4190
4191 void
4192 std_expand_builtin_va_start (tree valist, rtx nextarg)
4193 {
4194 tree t;
4195
4196 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist,
4197 make_tree (ptr_type_node, nextarg));
4198 TREE_SIDE_EFFECTS (t) = 1;
4199
4200 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4201 }
4202
4203 /* Expand ARGLIST, from a call to __builtin_va_start. */
4204
4205 static rtx
4206 expand_builtin_va_start (tree arglist)
4207 {
4208 rtx nextarg;
4209 tree chain, valist;
4210
4211 chain = TREE_CHAIN (arglist);
4212
4213 if (!chain)
4214 {
4215 error ("too few arguments to function %<va_start%>");
4216 return const0_rtx;
4217 }
4218
4219 if (fold_builtin_next_arg (chain))
4220 return const0_rtx;
4221
4222 nextarg = expand_builtin_next_arg ();
4223 valist = stabilize_va_list (TREE_VALUE (arglist), 1);
4224
4225 #ifdef EXPAND_BUILTIN_VA_START
4226 EXPAND_BUILTIN_VA_START (valist, nextarg);
4227 #else
4228 std_expand_builtin_va_start (valist, nextarg);
4229 #endif
4230
4231 return const0_rtx;
4232 }
4233
4234 /* The "standard" implementation of va_arg: read the value from the
4235 current (padded) address and increment by the (padded) size. */
4236
4237 tree
4238 std_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p, tree *post_p)
4239 {
4240 tree addr, t, type_size, rounded_size, valist_tmp;
4241 unsigned HOST_WIDE_INT align, boundary;
4242 bool indirect;
4243
4244 #ifdef ARGS_GROW_DOWNWARD
4245 /* All of the alignment and movement below is for args-grow-up machines.
4246 As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4247 implement their own specialized gimplify_va_arg_expr routines. */
4248 gcc_unreachable ();
4249 #endif
4250
4251 indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
4252 if (indirect)
4253 type = build_pointer_type (type);
4254
4255 align = PARM_BOUNDARY / BITS_PER_UNIT;
4256 boundary = FUNCTION_ARG_BOUNDARY (TYPE_MODE (type), type) / BITS_PER_UNIT;
4257
4258 /* Hoist the valist value into a temporary for the moment. */
4259 valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
4260
4261 /* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
4262 requires greater alignment, we must perform dynamic alignment. */
4263 if (boundary > align
4264 && !integer_zerop (TYPE_SIZE (type)))
4265 {
4266 t = fold_convert (TREE_TYPE (valist), size_int (boundary - 1));
4267 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4268 build2 (PLUS_EXPR, TREE_TYPE (valist), valist_tmp, t));
4269 gimplify_and_add (t, pre_p);
4270
4271 t = fold_convert (TREE_TYPE (valist), size_int (-boundary));
4272 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4273 build2 (BIT_AND_EXPR, TREE_TYPE (valist), valist_tmp, t));
4274 gimplify_and_add (t, pre_p);
4275 }
4276 else
4277 boundary = align;
4278
4279 /* If the actual alignment is less than the alignment of the type,
4280 adjust the type accordingly so that we don't assume strict alignment
4281 when deferencing the pointer. */
4282 boundary *= BITS_PER_UNIT;
4283 if (boundary < TYPE_ALIGN (type))
4284 {
4285 type = build_variant_type_copy (type);
4286 TYPE_ALIGN (type) = boundary;
4287 }
4288
4289 /* Compute the rounded size of the type. */
4290 type_size = size_in_bytes (type);
4291 rounded_size = round_up (type_size, align);
4292
4293 /* Reduce rounded_size so it's sharable with the postqueue. */
4294 gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
4295
4296 /* Get AP. */
4297 addr = valist_tmp;
4298 if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
4299 {
4300 /* Small args are padded downward. */
4301 t = fold_build2 (GT_EXPR, sizetype, rounded_size, size_int (align));
4302 t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
4303 size_binop (MINUS_EXPR, rounded_size, type_size));
4304 t = fold_convert (TREE_TYPE (addr), t);
4305 addr = fold_build2 (PLUS_EXPR, TREE_TYPE (addr), addr, t);
4306 }
4307
4308 /* Compute new value for AP. */
4309 t = fold_convert (TREE_TYPE (valist), rounded_size);
4310 t = build2 (PLUS_EXPR, TREE_TYPE (valist), valist_tmp, t);
4311 t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
4312 gimplify_and_add (t, pre_p);
4313
4314 addr = fold_convert (build_pointer_type (type), addr);
4315
4316 if (indirect)
4317 addr = build_va_arg_indirect_ref (addr);
4318
4319 return build_va_arg_indirect_ref (addr);
4320 }
4321
4322 /* Build an indirect-ref expression over the given TREE, which represents a
4323 piece of a va_arg() expansion. */
4324 tree
4325 build_va_arg_indirect_ref (tree addr)
4326 {
4327 addr = build_fold_indirect_ref (addr);
4328
4329 if (flag_mudflap) /* Don't instrument va_arg INDIRECT_REF. */
4330 mf_mark (addr);
4331
4332 return addr;
4333 }
4334
4335 /* Return a dummy expression of type TYPE in order to keep going after an
4336 error. */
4337
4338 static tree
4339 dummy_object (tree type)
4340 {
4341 tree t = build_int_cst (build_pointer_type (type), 0);
4342 return build1 (INDIRECT_REF, type, t);
4343 }
4344
4345 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4346 builtin function, but a very special sort of operator. */
4347
4348 enum gimplify_status
4349 gimplify_va_arg_expr (tree *expr_p, tree *pre_p, tree *post_p)
4350 {
4351 tree promoted_type, want_va_type, have_va_type;
4352 tree valist = TREE_OPERAND (*expr_p, 0);
4353 tree type = TREE_TYPE (*expr_p);
4354 tree t;
4355
4356 /* Verify that valist is of the proper type. */
4357 want_va_type = va_list_type_node;
4358 have_va_type = TREE_TYPE (valist);
4359
4360 if (have_va_type == error_mark_node)
4361 return GS_ERROR;
4362
4363 if (TREE_CODE (want_va_type) == ARRAY_TYPE)
4364 {
4365 /* If va_list is an array type, the argument may have decayed
4366 to a pointer type, e.g. by being passed to another function.
4367 In that case, unwrap both types so that we can compare the
4368 underlying records. */
4369 if (TREE_CODE (have_va_type) == ARRAY_TYPE
4370 || POINTER_TYPE_P (have_va_type))
4371 {
4372 want_va_type = TREE_TYPE (want_va_type);
4373 have_va_type = TREE_TYPE (have_va_type);
4374 }
4375 }
4376
4377 if (TYPE_MAIN_VARIANT (want_va_type) != TYPE_MAIN_VARIANT (have_va_type))
4378 {
4379 error ("first argument to %<va_arg%> not of type %<va_list%>");
4380 return GS_ERROR;
4381 }
4382
4383 /* Generate a diagnostic for requesting data of a type that cannot
4384 be passed through `...' due to type promotion at the call site. */
4385 else if ((promoted_type = lang_hooks.types.type_promotes_to (type))
4386 != type)
4387 {
4388 static bool gave_help;
4389
4390 /* Unfortunately, this is merely undefined, rather than a constraint
4391 violation, so we cannot make this an error. If this call is never
4392 executed, the program is still strictly conforming. */
4393 warning (0, "%qT is promoted to %qT when passed through %<...%>",
4394 type, promoted_type);
4395 if (! gave_help)
4396 {
4397 gave_help = true;
4398 warning (0, "(so you should pass %qT not %qT to %<va_arg%>)",
4399 promoted_type, type);
4400 }
4401
4402 /* We can, however, treat "undefined" any way we please.
4403 Call abort to encourage the user to fix the program. */
4404 inform ("if this code is reached, the program will abort");
4405 t = build_function_call_expr (implicit_built_in_decls[BUILT_IN_TRAP],
4406 NULL);
4407 append_to_statement_list (t, pre_p);
4408
4409 /* This is dead code, but go ahead and finish so that the
4410 mode of the result comes out right. */
4411 *expr_p = dummy_object (type);
4412 return GS_ALL_DONE;
4413 }
4414 else
4415 {
4416 /* Make it easier for the backends by protecting the valist argument
4417 from multiple evaluations. */
4418 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
4419 {
4420 /* For this case, the backends will be expecting a pointer to
4421 TREE_TYPE (va_list_type_node), but it's possible we've
4422 actually been given an array (an actual va_list_type_node).
4423 So fix it. */
4424 if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4425 {
4426 tree p1 = build_pointer_type (TREE_TYPE (va_list_type_node));
4427 valist = build_fold_addr_expr_with_type (valist, p1);
4428 }
4429 gimplify_expr (&valist, pre_p, post_p, is_gimple_val, fb_rvalue);
4430 }
4431 else
4432 gimplify_expr (&valist, pre_p, post_p, is_gimple_min_lval, fb_lvalue);
4433
4434 if (!targetm.gimplify_va_arg_expr)
4435 /* FIXME:Once most targets are converted we should merely
4436 assert this is non-null. */
4437 return GS_ALL_DONE;
4438
4439 *expr_p = targetm.gimplify_va_arg_expr (valist, type, pre_p, post_p);
4440 return GS_OK;
4441 }
4442 }
4443
4444 /* Expand ARGLIST, from a call to __builtin_va_end. */
4445
4446 static rtx
4447 expand_builtin_va_end (tree arglist)
4448 {
4449 tree valist = TREE_VALUE (arglist);
4450
4451 /* Evaluate for side effects, if needed. I hate macros that don't
4452 do that. */
4453 if (TREE_SIDE_EFFECTS (valist))
4454 expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
4455
4456 return const0_rtx;
4457 }
4458
4459 /* Expand ARGLIST, from a call to __builtin_va_copy. We do this as a
4460 builtin rather than just as an assignment in stdarg.h because of the
4461 nastiness of array-type va_list types. */
4462
4463 static rtx
4464 expand_builtin_va_copy (tree arglist)
4465 {
4466 tree dst, src, t;
4467
4468 dst = TREE_VALUE (arglist);
4469 src = TREE_VALUE (TREE_CHAIN (arglist));
4470
4471 dst = stabilize_va_list (dst, 1);
4472 src = stabilize_va_list (src, 0);
4473
4474 if (TREE_CODE (va_list_type_node) != ARRAY_TYPE)
4475 {
4476 t = build2 (MODIFY_EXPR, va_list_type_node, dst, src);
4477 TREE_SIDE_EFFECTS (t) = 1;
4478 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4479 }
4480 else
4481 {
4482 rtx dstb, srcb, size;
4483
4484 /* Evaluate to pointers. */
4485 dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
4486 srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
4487 size = expand_expr (TYPE_SIZE_UNIT (va_list_type_node), NULL_RTX,
4488 VOIDmode, EXPAND_NORMAL);
4489
4490 dstb = convert_memory_address (Pmode, dstb);
4491 srcb = convert_memory_address (Pmode, srcb);
4492
4493 /* "Dereference" to BLKmode memories. */
4494 dstb = gen_rtx_MEM (BLKmode, dstb);
4495 set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
4496 set_mem_align (dstb, TYPE_ALIGN (va_list_type_node));
4497 srcb = gen_rtx_MEM (BLKmode, srcb);
4498 set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
4499 set_mem_align (srcb, TYPE_ALIGN (va_list_type_node));
4500
4501 /* Copy. */
4502 emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
4503 }
4504
4505 return const0_rtx;
4506 }
4507
4508 /* Expand a call to one of the builtin functions __builtin_frame_address or
4509 __builtin_return_address. */
4510
4511 static rtx
4512 expand_builtin_frame_address (tree fndecl, tree arglist)
4513 {
4514 /* The argument must be a nonnegative integer constant.
4515 It counts the number of frames to scan up the stack.
4516 The value is the return address saved in that frame. */
4517 if (arglist == 0)
4518 /* Warning about missing arg was already issued. */
4519 return const0_rtx;
4520 else if (! host_integerp (TREE_VALUE (arglist), 1))
4521 {
4522 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4523 error ("invalid argument to %<__builtin_frame_address%>");
4524 else
4525 error ("invalid argument to %<__builtin_return_address%>");
4526 return const0_rtx;
4527 }
4528 else
4529 {
4530 rtx tem
4531 = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
4532 tree_low_cst (TREE_VALUE (arglist), 1));
4533
4534 /* Some ports cannot access arbitrary stack frames. */
4535 if (tem == NULL)
4536 {
4537 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4538 warning (0, "unsupported argument to %<__builtin_frame_address%>");
4539 else
4540 warning (0, "unsupported argument to %<__builtin_return_address%>");
4541 return const0_rtx;
4542 }
4543
4544 /* For __builtin_frame_address, return what we've got. */
4545 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4546 return tem;
4547
4548 if (!REG_P (tem)
4549 && ! CONSTANT_P (tem))
4550 tem = copy_to_mode_reg (Pmode, tem);
4551 return tem;
4552 }
4553 }
4554
4555 /* Expand a call to the alloca builtin, with arguments ARGLIST. Return 0 if
4556 we failed and the caller should emit a normal call, otherwise try to get
4557 the result in TARGET, if convenient. */
4558
4559 static rtx
4560 expand_builtin_alloca (tree arglist, rtx target)
4561 {
4562 rtx op0;
4563 rtx result;
4564
4565 /* In -fmudflap-instrumented code, alloca() and __builtin_alloca()
4566 should always expand to function calls. These can be intercepted
4567 in libmudflap. */
4568 if (flag_mudflap)
4569 return 0;
4570
4571 if (!validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
4572 return 0;
4573
4574 /* Compute the argument. */
4575 op0 = expand_normal (TREE_VALUE (arglist));
4576
4577 /* Allocate the desired space. */
4578 result = allocate_dynamic_stack_space (op0, target, BITS_PER_UNIT);
4579 result = convert_memory_address (ptr_mode, result);
4580
4581 return result;
4582 }
4583
4584 /* Expand a call to a unary builtin. The arguments are in ARGLIST.
4585 Return 0 if a normal call should be emitted rather than expanding the
4586 function in-line. If convenient, the result should be placed in TARGET.
4587 SUBTARGET may be used as the target for computing one of EXP's operands. */
4588
4589 static rtx
4590 expand_builtin_unop (enum machine_mode target_mode, tree arglist, rtx target,
4591 rtx subtarget, optab op_optab)
4592 {
4593 rtx op0;
4594 if (!validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
4595 return 0;
4596
4597 /* Compute the argument. */
4598 op0 = expand_expr (TREE_VALUE (arglist), subtarget, VOIDmode, 0);
4599 /* Compute op, into TARGET if possible.
4600 Set TARGET to wherever the result comes back. */
4601 target = expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist))),
4602 op_optab, op0, target, 1);
4603 gcc_assert (target);
4604
4605 return convert_to_mode (target_mode, target, 0);
4606 }
4607
4608 /* If the string passed to fputs is a constant and is one character
4609 long, we attempt to transform this call into __builtin_fputc(). */
4610
4611 static rtx
4612 expand_builtin_fputs (tree arglist, rtx target, bool unlocked)
4613 {
4614 /* Verify the arguments in the original call. */
4615 if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4616 {
4617 tree result = fold_builtin_fputs (arglist, (target == const0_rtx),
4618 unlocked, NULL_TREE);
4619 if (result)
4620 return expand_expr (result, target, VOIDmode, EXPAND_NORMAL);
4621 }
4622 return 0;
4623 }
4624
4625 /* Expand a call to __builtin_expect. We return our argument and emit a
4626 NOTE_INSN_EXPECTED_VALUE note. This is the expansion of __builtin_expect in
4627 a non-jump context. */
4628
4629 static rtx
4630 expand_builtin_expect (tree arglist, rtx target)
4631 {
4632 tree exp, c;
4633 rtx note, rtx_c;
4634
4635 if (arglist == NULL_TREE
4636 || TREE_CHAIN (arglist) == NULL_TREE)
4637 return const0_rtx;
4638 exp = TREE_VALUE (arglist);
4639 c = TREE_VALUE (TREE_CHAIN (arglist));
4640
4641 if (TREE_CODE (c) != INTEGER_CST)
4642 {
4643 error ("second argument to %<__builtin_expect%> must be a constant");
4644 c = integer_zero_node;
4645 }
4646
4647 target = expand_expr (exp, target, VOIDmode, EXPAND_NORMAL);
4648
4649 /* Don't bother with expected value notes for integral constants. */
4650 if (flag_guess_branch_prob && GET_CODE (target) != CONST_INT)
4651 {
4652 /* We do need to force this into a register so that we can be
4653 moderately sure to be able to correctly interpret the branch
4654 condition later. */
4655 target = force_reg (GET_MODE (target), target);
4656
4657 rtx_c = expand_expr (c, NULL_RTX, GET_MODE (target), EXPAND_NORMAL);
4658
4659 note = emit_note (NOTE_INSN_EXPECTED_VALUE);
4660 NOTE_EXPECTED_VALUE (note) = gen_rtx_EQ (VOIDmode, target, rtx_c);
4661 }
4662
4663 return target;
4664 }
4665
4666 /* Like expand_builtin_expect, except do this in a jump context. This is
4667 called from do_jump if the conditional is a __builtin_expect. Return either
4668 a list of insns to emit the jump or NULL if we cannot optimize
4669 __builtin_expect. We need to optimize this at jump time so that machines
4670 like the PowerPC don't turn the test into a SCC operation, and then jump
4671 based on the test being 0/1. */
4672
4673 rtx
4674 expand_builtin_expect_jump (tree exp, rtx if_false_label, rtx if_true_label)
4675 {
4676 tree arglist = TREE_OPERAND (exp, 1);
4677 tree arg0 = TREE_VALUE (arglist);
4678 tree arg1 = TREE_VALUE (TREE_CHAIN (arglist));
4679 rtx ret = NULL_RTX;
4680
4681 /* Only handle __builtin_expect (test, 0) and
4682 __builtin_expect (test, 1). */
4683 if (TREE_CODE (TREE_TYPE (arg1)) == INTEGER_TYPE
4684 && (integer_zerop (arg1) || integer_onep (arg1)))
4685 {
4686 rtx insn, drop_through_label, temp;
4687
4688 /* Expand the jump insns. */
4689 start_sequence ();
4690 do_jump (arg0, if_false_label, if_true_label);
4691 ret = get_insns ();
4692
4693 drop_through_label = get_last_insn ();
4694 if (drop_through_label && NOTE_P (drop_through_label))
4695 drop_through_label = prev_nonnote_insn (drop_through_label);
4696 if (drop_through_label && !LABEL_P (drop_through_label))
4697 drop_through_label = NULL_RTX;
4698 end_sequence ();
4699
4700 if (! if_true_label)
4701 if_true_label = drop_through_label;
4702 if (! if_false_label)
4703 if_false_label = drop_through_label;
4704
4705 /* Go through and add the expect's to each of the conditional jumps. */
4706 insn = ret;
4707 while (insn != NULL_RTX)
4708 {
4709 rtx next = NEXT_INSN (insn);
4710
4711 if (JUMP_P (insn) && any_condjump_p (insn))
4712 {
4713 rtx ifelse = SET_SRC (pc_set (insn));
4714 rtx then_dest = XEXP (ifelse, 1);
4715 rtx else_dest = XEXP (ifelse, 2);
4716 int taken = -1;
4717
4718 /* First check if we recognize any of the labels. */
4719 if (GET_CODE (then_dest) == LABEL_REF
4720 && XEXP (then_dest, 0) == if_true_label)
4721 taken = 1;
4722 else if (GET_CODE (then_dest) == LABEL_REF
4723 && XEXP (then_dest, 0) == if_false_label)
4724 taken = 0;
4725 else if (GET_CODE (else_dest) == LABEL_REF
4726 && XEXP (else_dest, 0) == if_false_label)
4727 taken = 1;
4728 else if (GET_CODE (else_dest) == LABEL_REF
4729 && XEXP (else_dest, 0) == if_true_label)
4730 taken = 0;
4731 /* Otherwise check where we drop through. */
4732 else if (else_dest == pc_rtx)
4733 {
4734 if (next && NOTE_P (next))
4735 next = next_nonnote_insn (next);
4736
4737 if (next && JUMP_P (next)
4738 && any_uncondjump_p (next))
4739 temp = XEXP (SET_SRC (pc_set (next)), 0);
4740 else
4741 temp = next;
4742
4743 /* TEMP is either a CODE_LABEL, NULL_RTX or something
4744 else that can't possibly match either target label. */
4745 if (temp == if_false_label)
4746 taken = 1;
4747 else if (temp == if_true_label)
4748 taken = 0;
4749 }
4750 else if (then_dest == pc_rtx)
4751 {
4752 if (next && NOTE_P (next))
4753 next = next_nonnote_insn (next);
4754
4755 if (next && JUMP_P (next)
4756 && any_uncondjump_p (next))
4757 temp = XEXP (SET_SRC (pc_set (next)), 0);
4758 else
4759 temp = next;
4760
4761 if (temp == if_false_label)
4762 taken = 0;
4763 else if (temp == if_true_label)
4764 taken = 1;
4765 }
4766
4767 if (taken != -1)
4768 {
4769 /* If the test is expected to fail, reverse the
4770 probabilities. */
4771 if (integer_zerop (arg1))
4772 taken = 1 - taken;
4773 predict_insn_def (insn, PRED_BUILTIN_EXPECT, taken);
4774 }
4775 }
4776
4777 insn = next;
4778 }
4779 }
4780
4781 return ret;
4782 }
4783
4784 void
4785 expand_builtin_trap (void)
4786 {
4787 #ifdef HAVE_trap
4788 if (HAVE_trap)
4789 emit_insn (gen_trap ());
4790 else
4791 #endif
4792 emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
4793 emit_barrier ();
4794 }
4795
4796 /* Expand a call to fabs, fabsf or fabsl with arguments ARGLIST.
4797 Return 0 if a normal call should be emitted rather than expanding
4798 the function inline. If convenient, the result should be placed
4799 in TARGET. SUBTARGET may be used as the target for computing
4800 the operand. */
4801
4802 static rtx
4803 expand_builtin_fabs (tree arglist, rtx target, rtx subtarget)
4804 {
4805 enum machine_mode mode;
4806 tree arg;
4807 rtx op0;
4808
4809 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
4810 return 0;
4811
4812 arg = TREE_VALUE (arglist);
4813 mode = TYPE_MODE (TREE_TYPE (arg));
4814 op0 = expand_expr (arg, subtarget, VOIDmode, 0);
4815 return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
4816 }
4817
4818 /* Expand a call to copysign, copysignf, or copysignl with arguments ARGLIST.
4819 Return NULL is a normal call should be emitted rather than expanding the
4820 function inline. If convenient, the result should be placed in TARGET.
4821 SUBTARGET may be used as the target for computing the operand. */
4822
4823 static rtx
4824 expand_builtin_copysign (tree arglist, rtx target, rtx subtarget)
4825 {
4826 rtx op0, op1;
4827 tree arg;
4828
4829 if (!validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
4830 return 0;
4831
4832 arg = TREE_VALUE (arglist);
4833 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4834
4835 arg = TREE_VALUE (TREE_CHAIN (arglist));
4836 op1 = expand_normal (arg);
4837
4838 return expand_copysign (op0, op1, target);
4839 }
4840
4841 /* Create a new constant string literal and return a char* pointer to it.
4842 The STRING_CST value is the LEN characters at STR. */
4843 tree
4844 build_string_literal (int len, const char *str)
4845 {
4846 tree t, elem, index, type;
4847
4848 t = build_string (len, str);
4849 elem = build_type_variant (char_type_node, 1, 0);
4850 index = build_index_type (build_int_cst (NULL_TREE, len - 1));
4851 type = build_array_type (elem, index);
4852 TREE_TYPE (t) = type;
4853 TREE_CONSTANT (t) = 1;
4854 TREE_INVARIANT (t) = 1;
4855 TREE_READONLY (t) = 1;
4856 TREE_STATIC (t) = 1;
4857
4858 type = build_pointer_type (type);
4859 t = build1 (ADDR_EXPR, type, t);
4860
4861 type = build_pointer_type (elem);
4862 t = build1 (NOP_EXPR, type, t);
4863 return t;
4864 }
4865
4866 /* Expand EXP, a call to printf or printf_unlocked.
4867 Return 0 if a normal call should be emitted rather than transforming
4868 the function inline. If convenient, the result should be placed in
4869 TARGET with mode MODE. UNLOCKED indicates this is a printf_unlocked
4870 call. */
4871 static rtx
4872 expand_builtin_printf (tree exp, rtx target, enum machine_mode mode,
4873 bool unlocked)
4874 {
4875 tree arglist = TREE_OPERAND (exp, 1);
4876 /* If we're using an unlocked function, assume the other unlocked
4877 functions exist explicitly. */
4878 tree const fn_putchar = unlocked ? built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED]
4879 : implicit_built_in_decls[BUILT_IN_PUTCHAR];
4880 tree const fn_puts = unlocked ? built_in_decls[BUILT_IN_PUTS_UNLOCKED]
4881 : implicit_built_in_decls[BUILT_IN_PUTS];
4882 const char *fmt_str;
4883 tree fn, fmt, arg;
4884
4885 /* If the return value is used, don't do the transformation. */
4886 if (target != const0_rtx)
4887 return 0;
4888
4889 /* Verify the required arguments in the original call. */
4890 if (! arglist)
4891 return 0;
4892 fmt = TREE_VALUE (arglist);
4893 if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
4894 return 0;
4895 arglist = TREE_CHAIN (arglist);
4896
4897 /* Check whether the format is a literal string constant. */
4898 fmt_str = c_getstr (fmt);
4899 if (fmt_str == NULL)
4900 return 0;
4901
4902 if (!init_target_chars())
4903 return 0;
4904
4905 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
4906 if (strcmp (fmt_str, target_percent_s_newline) == 0)
4907 {
4908 if (! arglist
4909 || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist)))
4910 || TREE_CHAIN (arglist))
4911 return 0;
4912 fn = fn_puts;
4913 }
4914 /* If the format specifier was "%c", call __builtin_putchar(arg). */
4915 else if (strcmp (fmt_str, target_percent_c) == 0)
4916 {
4917 if (! arglist
4918 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE
4919 || TREE_CHAIN (arglist))
4920 return 0;
4921 fn = fn_putchar;
4922 }
4923 else
4924 {
4925 /* We can't handle anything else with % args or %% ... yet. */
4926 if (strchr (fmt_str, target_percent))
4927 return 0;
4928
4929 if (arglist)
4930 return 0;
4931
4932 /* If the format specifier was "", printf does nothing. */
4933 if (fmt_str[0] == '\0')
4934 return const0_rtx;
4935 /* If the format specifier has length of 1, call putchar. */
4936 if (fmt_str[1] == '\0')
4937 {
4938 /* Given printf("c"), (where c is any one character,)
4939 convert "c"[0] to an int and pass that to the replacement
4940 function. */
4941 arg = build_int_cst (NULL_TREE, fmt_str[0]);
4942 arglist = build_tree_list (NULL_TREE, arg);
4943 fn = fn_putchar;
4944 }
4945 else
4946 {
4947 /* If the format specifier was "string\n", call puts("string"). */
4948 size_t len = strlen (fmt_str);
4949 if ((unsigned char)fmt_str[len - 1] == target_newline)
4950 {
4951 /* Create a NUL-terminated string that's one char shorter
4952 than the original, stripping off the trailing '\n'. */
4953 char *newstr = alloca (len);
4954 memcpy (newstr, fmt_str, len - 1);
4955 newstr[len - 1] = 0;
4956
4957 arg = build_string_literal (len, newstr);
4958 arglist = build_tree_list (NULL_TREE, arg);
4959 fn = fn_puts;
4960 }
4961 else
4962 /* We'd like to arrange to call fputs(string,stdout) here,
4963 but we need stdout and don't have a way to get it yet. */
4964 return 0;
4965 }
4966 }
4967
4968 if (!fn)
4969 return 0;
4970 fn = build_function_call_expr (fn, arglist);
4971 if (TREE_CODE (fn) == CALL_EXPR)
4972 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4973 return expand_expr (fn, target, mode, EXPAND_NORMAL);
4974 }
4975
4976 /* Expand EXP, a call to fprintf or fprintf_unlocked.
4977 Return 0 if a normal call should be emitted rather than transforming
4978 the function inline. If convenient, the result should be placed in
4979 TARGET with mode MODE. UNLOCKED indicates this is a fprintf_unlocked
4980 call. */
4981 static rtx
4982 expand_builtin_fprintf (tree exp, rtx target, enum machine_mode mode,
4983 bool unlocked)
4984 {
4985 tree arglist = TREE_OPERAND (exp, 1);
4986 /* If we're using an unlocked function, assume the other unlocked
4987 functions exist explicitly. */
4988 tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
4989 : implicit_built_in_decls[BUILT_IN_FPUTC];
4990 tree const fn_fputs = unlocked ? built_in_decls[BUILT_IN_FPUTS_UNLOCKED]
4991 : implicit_built_in_decls[BUILT_IN_FPUTS];
4992 const char *fmt_str;
4993 tree fn, fmt, fp, arg;
4994
4995 /* If the return value is used, don't do the transformation. */
4996 if (target != const0_rtx)
4997 return 0;
4998
4999 /* Verify the required arguments in the original call. */
5000 if (! arglist)
5001 return 0;
5002 fp = TREE_VALUE (arglist);
5003 if (! POINTER_TYPE_P (TREE_TYPE (fp)))
5004 return 0;
5005 arglist = TREE_CHAIN (arglist);
5006 if (! arglist)
5007 return 0;
5008 fmt = TREE_VALUE (arglist);
5009 if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
5010 return 0;
5011 arglist = TREE_CHAIN (arglist);
5012
5013 /* Check whether the format is a literal string constant. */
5014 fmt_str = c_getstr (fmt);
5015 if (fmt_str == NULL)
5016 return 0;
5017
5018 if (!init_target_chars())
5019 return 0;
5020
5021 /* If the format specifier was "%s", call __builtin_fputs(arg,fp). */
5022 if (strcmp (fmt_str, target_percent_s) == 0)
5023 {
5024 if (! arglist
5025 || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist)))
5026 || TREE_CHAIN (arglist))
5027 return 0;
5028 arg = TREE_VALUE (arglist);
5029 arglist = build_tree_list (NULL_TREE, fp);
5030 arglist = tree_cons (NULL_TREE, arg, arglist);
5031 fn = fn_fputs;
5032 }
5033 /* If the format specifier was "%c", call __builtin_fputc(arg,fp). */
5034 else if (strcmp (fmt_str, target_percent_c) == 0)
5035 {
5036 if (! arglist
5037 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE
5038 || TREE_CHAIN (arglist))
5039 return 0;
5040 arg = TREE_VALUE (arglist);
5041 arglist = build_tree_list (NULL_TREE, fp);
5042 arglist = tree_cons (NULL_TREE, arg, arglist);
5043 fn = fn_fputc;
5044 }
5045 else
5046 {
5047 /* We can't handle anything else with % args or %% ... yet. */
5048 if (strchr (fmt_str, target_percent))
5049 return 0;
5050
5051 if (arglist)
5052 return 0;
5053
5054 /* If the format specifier was "", fprintf does nothing. */
5055 if (fmt_str[0] == '\0')
5056 {
5057 /* Evaluate and ignore FILE* argument for side-effects. */
5058 expand_expr (fp, const0_rtx, VOIDmode, EXPAND_NORMAL);
5059 return const0_rtx;
5060 }
5061
5062 /* When "string" doesn't contain %, replace all cases of
5063 fprintf(stream,string) with fputs(string,stream). The fputs
5064 builtin will take care of special cases like length == 1. */
5065 arglist = build_tree_list (NULL_TREE, fp);
5066 arglist = tree_cons (NULL_TREE, fmt, arglist);
5067 fn = fn_fputs;
5068 }
5069
5070 if (!fn)
5071 return 0;
5072 fn = build_function_call_expr (fn, arglist);
5073 if (TREE_CODE (fn) == CALL_EXPR)
5074 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
5075 return expand_expr (fn, target, mode, EXPAND_NORMAL);
5076 }
5077
5078 /* Expand a call to sprintf with argument list ARGLIST. Return 0 if
5079 a normal call should be emitted rather than expanding the function
5080 inline. If convenient, the result should be placed in TARGET with
5081 mode MODE. */
5082
5083 static rtx
5084 expand_builtin_sprintf (tree arglist, rtx target, enum machine_mode mode)
5085 {
5086 tree orig_arglist, dest, fmt;
5087 const char *fmt_str;
5088
5089 orig_arglist = arglist;
5090
5091 /* Verify the required arguments in the original call. */
5092 if (! arglist)
5093 return 0;
5094 dest = TREE_VALUE (arglist);
5095 if (! POINTER_TYPE_P (TREE_TYPE (dest)))
5096 return 0;
5097 arglist = TREE_CHAIN (arglist);
5098 if (! arglist)
5099 return 0;
5100 fmt = TREE_VALUE (arglist);
5101 if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
5102 return 0;
5103 arglist = TREE_CHAIN (arglist);
5104
5105 /* Check whether the format is a literal string constant. */
5106 fmt_str = c_getstr (fmt);
5107 if (fmt_str == NULL)
5108 return 0;
5109
5110 if (!init_target_chars())
5111 return 0;
5112
5113 /* If the format doesn't contain % args or %%, use strcpy. */
5114 if (strchr (fmt_str, target_percent) == 0)
5115 {
5116 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
5117 tree exp;
5118
5119 if (arglist || ! fn)
5120 return 0;
5121 expand_expr (build_function_call_expr (fn, orig_arglist),
5122 const0_rtx, VOIDmode, EXPAND_NORMAL);
5123 if (target == const0_rtx)
5124 return const0_rtx;
5125 exp = build_int_cst (NULL_TREE, strlen (fmt_str));
5126 return expand_expr (exp, target, mode, EXPAND_NORMAL);
5127 }
5128 /* If the format is "%s", use strcpy if the result isn't used. */
5129 else if (strcmp (fmt_str, target_percent_s) == 0)
5130 {
5131 tree fn, arg, len;
5132 fn = implicit_built_in_decls[BUILT_IN_STRCPY];
5133
5134 if (! fn)
5135 return 0;
5136
5137 if (! arglist || TREE_CHAIN (arglist))
5138 return 0;
5139 arg = TREE_VALUE (arglist);
5140 if (! POINTER_TYPE_P (TREE_TYPE (arg)))
5141 return 0;
5142
5143 if (target != const0_rtx)
5144 {
5145 len = c_strlen (arg, 1);
5146 if (! len || TREE_CODE (len) != INTEGER_CST)
5147 return 0;
5148 }
5149 else
5150 len = NULL_TREE;
5151
5152 arglist = build_tree_list (NULL_TREE, arg);
5153 arglist = tree_cons (NULL_TREE, dest, arglist);
5154 expand_expr (build_function_call_expr (fn, arglist),
5155 const0_rtx, VOIDmode, EXPAND_NORMAL);
5156
5157 if (target == const0_rtx)
5158 return const0_rtx;
5159 return expand_expr (len, target, mode, EXPAND_NORMAL);
5160 }
5161
5162 return 0;
5163 }
5164
5165 /* Expand a call to either the entry or exit function profiler. */
5166
5167 static rtx
5168 expand_builtin_profile_func (bool exitp)
5169 {
5170 rtx this, which;
5171
5172 this = DECL_RTL (current_function_decl);
5173 gcc_assert (MEM_P (this));
5174 this = XEXP (this, 0);
5175
5176 if (exitp)
5177 which = profile_function_exit_libfunc;
5178 else
5179 which = profile_function_entry_libfunc;
5180
5181 emit_library_call (which, LCT_NORMAL, VOIDmode, 2, this, Pmode,
5182 expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
5183 0),
5184 Pmode);
5185
5186 return const0_rtx;
5187 }
5188
5189 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */
5190
5191 static rtx
5192 round_trampoline_addr (rtx tramp)
5193 {
5194 rtx temp, addend, mask;
5195
5196 /* If we don't need too much alignment, we'll have been guaranteed
5197 proper alignment by get_trampoline_type. */
5198 if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY)
5199 return tramp;
5200
5201 /* Round address up to desired boundary. */
5202 temp = gen_reg_rtx (Pmode);
5203 addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
5204 mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
5205
5206 temp = expand_simple_binop (Pmode, PLUS, tramp, addend,
5207 temp, 0, OPTAB_LIB_WIDEN);
5208 tramp = expand_simple_binop (Pmode, AND, temp, mask,
5209 temp, 0, OPTAB_LIB_WIDEN);
5210
5211 return tramp;
5212 }
5213
5214 static rtx
5215 expand_builtin_init_trampoline (tree arglist)
5216 {
5217 tree t_tramp, t_func, t_chain;
5218 rtx r_tramp, r_func, r_chain;
5219 #ifdef TRAMPOLINE_TEMPLATE
5220 rtx blktramp;
5221 #endif
5222
5223 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE,
5224 POINTER_TYPE, VOID_TYPE))
5225 return NULL_RTX;
5226
5227 t_tramp = TREE_VALUE (arglist);
5228 arglist = TREE_CHAIN (arglist);
5229 t_func = TREE_VALUE (arglist);
5230 arglist = TREE_CHAIN (arglist);
5231 t_chain = TREE_VALUE (arglist);
5232
5233 r_tramp = expand_normal (t_tramp);
5234 r_func = expand_normal (t_func);
5235 r_chain = expand_normal (t_chain);
5236
5237 /* Generate insns to initialize the trampoline. */
5238 r_tramp = round_trampoline_addr (r_tramp);
5239 #ifdef TRAMPOLINE_TEMPLATE
5240 blktramp = gen_rtx_MEM (BLKmode, r_tramp);
5241 set_mem_align (blktramp, TRAMPOLINE_ALIGNMENT);
5242 emit_block_move (blktramp, assemble_trampoline_template (),
5243 GEN_INT (TRAMPOLINE_SIZE), BLOCK_OP_NORMAL);
5244 #endif
5245 trampolines_created = 1;
5246 INITIALIZE_TRAMPOLINE (r_tramp, r_func, r_chain);
5247
5248 return const0_rtx;
5249 }
5250
5251 static rtx
5252 expand_builtin_adjust_trampoline (tree arglist)
5253 {
5254 rtx tramp;
5255
5256 if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
5257 return NULL_RTX;
5258
5259 tramp = expand_normal (TREE_VALUE (arglist));
5260 tramp = round_trampoline_addr (tramp);
5261 #ifdef TRAMPOLINE_ADJUST_ADDRESS
5262 TRAMPOLINE_ADJUST_ADDRESS (tramp);
5263 #endif
5264
5265 return tramp;
5266 }
5267
5268 /* Expand a call to the built-in signbit, signbitf or signbitl function.
5269 Return NULL_RTX if a normal call should be emitted rather than expanding
5270 the function in-line. EXP is the expression that is a call to the builtin
5271 function; if convenient, the result should be placed in TARGET. */
5272
5273 static rtx
5274 expand_builtin_signbit (tree exp, rtx target)
5275 {
5276 const struct real_format *fmt;
5277 enum machine_mode fmode, imode, rmode;
5278 HOST_WIDE_INT hi, lo;
5279 tree arg, arglist;
5280 int word, bitpos;
5281 rtx temp;
5282
5283 arglist = TREE_OPERAND (exp, 1);
5284 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
5285 return 0;
5286
5287 arg = TREE_VALUE (arglist);
5288 fmode = TYPE_MODE (TREE_TYPE (arg));
5289 rmode = TYPE_MODE (TREE_TYPE (exp));
5290 fmt = REAL_MODE_FORMAT (fmode);
5291
5292 /* For floating point formats without a sign bit, implement signbit
5293 as "ARG < 0.0". */
5294 bitpos = fmt->signbit_ro;
5295 if (bitpos < 0)
5296 {
5297 /* But we can't do this if the format supports signed zero. */
5298 if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
5299 return 0;
5300
5301 arg = fold_build2 (LT_EXPR, TREE_TYPE (exp), arg,
5302 build_real (TREE_TYPE (arg), dconst0));
5303 return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5304 }
5305
5306 temp = expand_normal (arg);
5307 if (GET_MODE_SIZE (fmode) <= UNITS_PER_WORD)
5308 {
5309 imode = int_mode_for_mode (fmode);
5310 if (imode == BLKmode)
5311 return 0;
5312 temp = gen_lowpart (imode, temp);
5313 }
5314 else
5315 {
5316 imode = word_mode;
5317 /* Handle targets with different FP word orders. */
5318 if (FLOAT_WORDS_BIG_ENDIAN)
5319 word = (GET_MODE_BITSIZE (fmode) - bitpos) / BITS_PER_WORD;
5320 else
5321 word = bitpos / BITS_PER_WORD;
5322 temp = operand_subword_force (temp, word, fmode);
5323 bitpos = bitpos % BITS_PER_WORD;
5324 }
5325
5326 /* Force the intermediate word_mode (or narrower) result into a
5327 register. This avoids attempting to create paradoxical SUBREGs
5328 of floating point modes below. */
5329 temp = force_reg (imode, temp);
5330
5331 /* If the bitpos is within the "result mode" lowpart, the operation
5332 can be implement with a single bitwise AND. Otherwise, we need
5333 a right shift and an AND. */
5334
5335 if (bitpos < GET_MODE_BITSIZE (rmode))
5336 {
5337 if (bitpos < HOST_BITS_PER_WIDE_INT)
5338 {
5339 hi = 0;
5340 lo = (HOST_WIDE_INT) 1 << bitpos;
5341 }
5342 else
5343 {
5344 hi = (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT);
5345 lo = 0;
5346 }
5347
5348 if (imode != rmode)
5349 temp = gen_lowpart (rmode, temp);
5350 temp = expand_binop (rmode, and_optab, temp,
5351 immed_double_const (lo, hi, rmode),
5352 NULL_RTX, 1, OPTAB_LIB_WIDEN);
5353 }
5354 else
5355 {
5356 /* Perform a logical right shift to place the signbit in the least
5357 significant bit, then truncate the result to the desired mode
5358 and mask just this bit. */
5359 temp = expand_shift (RSHIFT_EXPR, imode, temp,
5360 build_int_cst (NULL_TREE, bitpos), NULL_RTX, 1);
5361 temp = gen_lowpart (rmode, temp);
5362 temp = expand_binop (rmode, and_optab, temp, const1_rtx,
5363 NULL_RTX, 1, OPTAB_LIB_WIDEN);
5364 }
5365
5366 return temp;
5367 }
5368
5369 /* Expand fork or exec calls. TARGET is the desired target of the
5370 call. ARGLIST is the list of arguments of the call. FN is the
5371 identificator of the actual function. IGNORE is nonzero if the
5372 value is to be ignored. */
5373
5374 static rtx
5375 expand_builtin_fork_or_exec (tree fn, tree arglist, rtx target, int ignore)
5376 {
5377 tree id, decl;
5378 tree call;
5379
5380 /* If we are not profiling, just call the function. */
5381 if (!profile_arc_flag)
5382 return NULL_RTX;
5383
5384 /* Otherwise call the wrapper. This should be equivalent for the rest of
5385 compiler, so the code does not diverge, and the wrapper may run the
5386 code necessary for keeping the profiling sane. */
5387
5388 switch (DECL_FUNCTION_CODE (fn))
5389 {
5390 case BUILT_IN_FORK:
5391 id = get_identifier ("__gcov_fork");
5392 break;
5393
5394 case BUILT_IN_EXECL:
5395 id = get_identifier ("__gcov_execl");
5396 break;
5397
5398 case BUILT_IN_EXECV:
5399 id = get_identifier ("__gcov_execv");
5400 break;
5401
5402 case BUILT_IN_EXECLP:
5403 id = get_identifier ("__gcov_execlp");
5404 break;
5405
5406 case BUILT_IN_EXECLE:
5407 id = get_identifier ("__gcov_execle");
5408 break;
5409
5410 case BUILT_IN_EXECVP:
5411 id = get_identifier ("__gcov_execvp");
5412 break;
5413
5414 case BUILT_IN_EXECVE:
5415 id = get_identifier ("__gcov_execve");
5416 break;
5417
5418 default:
5419 gcc_unreachable ();
5420 }
5421
5422 decl = build_decl (FUNCTION_DECL, id, TREE_TYPE (fn));
5423 DECL_EXTERNAL (decl) = 1;
5424 TREE_PUBLIC (decl) = 1;
5425 DECL_ARTIFICIAL (decl) = 1;
5426 TREE_NOTHROW (decl) = 1;
5427 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5428 DECL_VISIBILITY_SPECIFIED (decl) = 1;
5429 call = build_function_call_expr (decl, arglist);
5430
5431 return expand_call (call, target, ignore);
5432 }
5433
5434 \f
5435 /* Reconstitute a mode for a __sync intrinsic operation. Since the type of
5436 the pointer in these functions is void*, the tree optimizers may remove
5437 casts. The mode computed in expand_builtin isn't reliable either, due
5438 to __sync_bool_compare_and_swap.
5439
5440 FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5441 group of builtins. This gives us log2 of the mode size. */
5442
5443 static inline enum machine_mode
5444 get_builtin_sync_mode (int fcode_diff)
5445 {
5446 /* The size is not negotiable, so ask not to get BLKmode in return
5447 if the target indicates that a smaller size would be better. */
5448 return mode_for_size (BITS_PER_UNIT << fcode_diff, MODE_INT, 0);
5449 }
5450
5451 /* Expand the memory expression LOC and return the appropriate memory operand
5452 for the builtin_sync operations. */
5453
5454 static rtx
5455 get_builtin_sync_mem (tree loc, enum machine_mode mode)
5456 {
5457 rtx addr, mem;
5458
5459 addr = expand_expr (loc, NULL, Pmode, EXPAND_SUM);
5460
5461 /* Note that we explicitly do not want any alias information for this
5462 memory, so that we kill all other live memories. Otherwise we don't
5463 satisfy the full barrier semantics of the intrinsic. */
5464 mem = validize_mem (gen_rtx_MEM (mode, addr));
5465
5466 set_mem_align (mem, get_pointer_alignment (loc, BIGGEST_ALIGNMENT));
5467 set_mem_alias_set (mem, ALIAS_SET_MEMORY_BARRIER);
5468 MEM_VOLATILE_P (mem) = 1;
5469
5470 return mem;
5471 }
5472
5473 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5474 ARGLIST is the operands list to the function. CODE is the rtx code
5475 that corresponds to the arithmetic or logical operation from the name;
5476 an exception here is that NOT actually means NAND. TARGET is an optional
5477 place for us to store the results; AFTER is true if this is the
5478 fetch_and_xxx form. IGNORE is true if we don't actually care about
5479 the result of the operation at all. */
5480
5481 static rtx
5482 expand_builtin_sync_operation (enum machine_mode mode, tree arglist,
5483 enum rtx_code code, bool after,
5484 rtx target, bool ignore)
5485 {
5486 rtx val, mem;
5487
5488 /* Expand the operands. */
5489 mem = get_builtin_sync_mem (TREE_VALUE (arglist), mode);
5490
5491 arglist = TREE_CHAIN (arglist);
5492 val = expand_expr (TREE_VALUE (arglist), NULL, mode, EXPAND_NORMAL);
5493
5494 if (ignore)
5495 return expand_sync_operation (mem, val, code);
5496 else
5497 return expand_sync_fetch_operation (mem, val, code, after, target);
5498 }
5499
5500 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5501 intrinsics. ARGLIST is the operands list to the function. IS_BOOL is
5502 true if this is the boolean form. TARGET is a place for us to store the
5503 results; this is NOT optional if IS_BOOL is true. */
5504
5505 static rtx
5506 expand_builtin_compare_and_swap (enum machine_mode mode, tree arglist,
5507 bool is_bool, rtx target)
5508 {
5509 rtx old_val, new_val, mem;
5510
5511 /* Expand the operands. */
5512 mem = get_builtin_sync_mem (TREE_VALUE (arglist), mode);
5513
5514 arglist = TREE_CHAIN (arglist);
5515 old_val = expand_expr (TREE_VALUE (arglist), NULL, mode, EXPAND_NORMAL);
5516
5517 arglist = TREE_CHAIN (arglist);
5518 new_val = expand_expr (TREE_VALUE (arglist), NULL, mode, EXPAND_NORMAL);
5519
5520 if (is_bool)
5521 return expand_bool_compare_and_swap (mem, old_val, new_val, target);
5522 else
5523 return expand_val_compare_and_swap (mem, old_val, new_val, target);
5524 }
5525
5526 /* Expand the __sync_lock_test_and_set intrinsic. Note that the most
5527 general form is actually an atomic exchange, and some targets only
5528 support a reduced form with the second argument being a constant 1.
5529 ARGLIST is the operands list to the function; TARGET is an optional
5530 place for us to store the results. */
5531
5532 static rtx
5533 expand_builtin_lock_test_and_set (enum machine_mode mode, tree arglist,
5534 rtx target)
5535 {
5536 rtx val, mem;
5537
5538 /* Expand the operands. */
5539 mem = get_builtin_sync_mem (TREE_VALUE (arglist), mode);
5540
5541 arglist = TREE_CHAIN (arglist);
5542 val = expand_expr (TREE_VALUE (arglist), NULL, mode, EXPAND_NORMAL);
5543
5544 return expand_sync_lock_test_and_set (mem, val, target);
5545 }
5546
5547 /* Expand the __sync_synchronize intrinsic. */
5548
5549 static void
5550 expand_builtin_synchronize (void)
5551 {
5552 tree x;
5553
5554 #ifdef HAVE_memory_barrier
5555 if (HAVE_memory_barrier)
5556 {
5557 emit_insn (gen_memory_barrier ());
5558 return;
5559 }
5560 #endif
5561
5562 /* If no explicit memory barrier instruction is available, create an
5563 empty asm stmt with a memory clobber. */
5564 x = build4 (ASM_EXPR, void_type_node, build_string (0, ""), NULL, NULL,
5565 tree_cons (NULL, build_string (6, "memory"), NULL));
5566 ASM_VOLATILE_P (x) = 1;
5567 expand_asm_expr (x);
5568 }
5569
5570 /* Expand the __sync_lock_release intrinsic. ARGLIST is the operands list
5571 to the function. */
5572
5573 static void
5574 expand_builtin_lock_release (enum machine_mode mode, tree arglist)
5575 {
5576 enum insn_code icode;
5577 rtx mem, insn;
5578 rtx val = const0_rtx;
5579
5580 /* Expand the operands. */
5581 mem = get_builtin_sync_mem (TREE_VALUE (arglist), mode);
5582
5583 /* If there is an explicit operation in the md file, use it. */
5584 icode = sync_lock_release[mode];
5585 if (icode != CODE_FOR_nothing)
5586 {
5587 if (!insn_data[icode].operand[1].predicate (val, mode))
5588 val = force_reg (mode, val);
5589
5590 insn = GEN_FCN (icode) (mem, val);
5591 if (insn)
5592 {
5593 emit_insn (insn);
5594 return;
5595 }
5596 }
5597
5598 /* Otherwise we can implement this operation by emitting a barrier
5599 followed by a store of zero. */
5600 expand_builtin_synchronize ();
5601 emit_move_insn (mem, val);
5602 }
5603 \f
5604 /* Expand an expression EXP that calls a built-in function,
5605 with result going to TARGET if that's convenient
5606 (and in mode MODE if that's convenient).
5607 SUBTARGET may be used as the target for computing one of EXP's operands.
5608 IGNORE is nonzero if the value is to be ignored. */
5609
5610 rtx
5611 expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
5612 int ignore)
5613 {
5614 tree fndecl = get_callee_fndecl (exp);
5615 tree arglist = TREE_OPERAND (exp, 1);
5616 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5617 enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
5618
5619 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
5620 return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
5621
5622 /* When not optimizing, generate calls to library functions for a certain
5623 set of builtins. */
5624 if (!optimize
5625 && !called_as_built_in (fndecl)
5626 && DECL_ASSEMBLER_NAME_SET_P (fndecl)
5627 && fcode != BUILT_IN_ALLOCA)
5628 return expand_call (exp, target, ignore);
5629
5630 /* The built-in function expanders test for target == const0_rtx
5631 to determine whether the function's result will be ignored. */
5632 if (ignore)
5633 target = const0_rtx;
5634
5635 /* If the result of a pure or const built-in function is ignored, and
5636 none of its arguments are volatile, we can avoid expanding the
5637 built-in call and just evaluate the arguments for side-effects. */
5638 if (target == const0_rtx
5639 && (DECL_IS_PURE (fndecl) || TREE_READONLY (fndecl)))
5640 {
5641 bool volatilep = false;
5642 tree arg;
5643
5644 for (arg = arglist; arg; arg = TREE_CHAIN (arg))
5645 if (TREE_THIS_VOLATILE (TREE_VALUE (arg)))
5646 {
5647 volatilep = true;
5648 break;
5649 }
5650
5651 if (! volatilep)
5652 {
5653 for (arg = arglist; arg; arg = TREE_CHAIN (arg))
5654 expand_expr (TREE_VALUE (arg), const0_rtx,
5655 VOIDmode, EXPAND_NORMAL);
5656 return const0_rtx;
5657 }
5658 }
5659
5660 switch (fcode)
5661 {
5662 CASE_FLT_FN (BUILT_IN_FABS):
5663 target = expand_builtin_fabs (arglist, target, subtarget);
5664 if (target)
5665 return target;
5666 break;
5667
5668 CASE_FLT_FN (BUILT_IN_COPYSIGN):
5669 target = expand_builtin_copysign (arglist, target, subtarget);
5670 if (target)
5671 return target;
5672 break;
5673
5674 /* Just do a normal library call if we were unable to fold
5675 the values. */
5676 CASE_FLT_FN (BUILT_IN_CABS):
5677 break;
5678
5679 CASE_FLT_FN (BUILT_IN_EXP):
5680 CASE_FLT_FN (BUILT_IN_EXP10):
5681 CASE_FLT_FN (BUILT_IN_POW10):
5682 CASE_FLT_FN (BUILT_IN_EXP2):
5683 CASE_FLT_FN (BUILT_IN_EXPM1):
5684 CASE_FLT_FN (BUILT_IN_LOGB):
5685 CASE_FLT_FN (BUILT_IN_ILOGB):
5686 CASE_FLT_FN (BUILT_IN_LOG):
5687 CASE_FLT_FN (BUILT_IN_LOG10):
5688 CASE_FLT_FN (BUILT_IN_LOG2):
5689 CASE_FLT_FN (BUILT_IN_LOG1P):
5690 CASE_FLT_FN (BUILT_IN_TAN):
5691 CASE_FLT_FN (BUILT_IN_ASIN):
5692 CASE_FLT_FN (BUILT_IN_ACOS):
5693 CASE_FLT_FN (BUILT_IN_ATAN):
5694 /* Treat these like sqrt only if unsafe math optimizations are allowed,
5695 because of possible accuracy problems. */
5696 if (! flag_unsafe_math_optimizations)
5697 break;
5698 CASE_FLT_FN (BUILT_IN_SQRT):
5699 CASE_FLT_FN (BUILT_IN_FLOOR):
5700 CASE_FLT_FN (BUILT_IN_CEIL):
5701 CASE_FLT_FN (BUILT_IN_TRUNC):
5702 CASE_FLT_FN (BUILT_IN_ROUND):
5703 CASE_FLT_FN (BUILT_IN_NEARBYINT):
5704 CASE_FLT_FN (BUILT_IN_RINT):
5705 CASE_FLT_FN (BUILT_IN_LRINT):
5706 CASE_FLT_FN (BUILT_IN_LLRINT):
5707 target = expand_builtin_mathfn (exp, target, subtarget);
5708 if (target)
5709 return target;
5710 break;
5711
5712 CASE_FLT_FN (BUILT_IN_LCEIL):
5713 CASE_FLT_FN (BUILT_IN_LLCEIL):
5714 CASE_FLT_FN (BUILT_IN_LFLOOR):
5715 CASE_FLT_FN (BUILT_IN_LLFLOOR):
5716 target = expand_builtin_int_roundingfn (exp, target, subtarget);
5717 if (target)
5718 return target;
5719 break;
5720
5721 CASE_FLT_FN (BUILT_IN_POW):
5722 target = expand_builtin_pow (exp, target, subtarget);
5723 if (target)
5724 return target;
5725 break;
5726
5727 CASE_FLT_FN (BUILT_IN_POWI):
5728 target = expand_builtin_powi (exp, target, subtarget);
5729 if (target)
5730 return target;
5731 break;
5732
5733 CASE_FLT_FN (BUILT_IN_ATAN2):
5734 CASE_FLT_FN (BUILT_IN_LDEXP):
5735 CASE_FLT_FN (BUILT_IN_FMOD):
5736 CASE_FLT_FN (BUILT_IN_DREM):
5737 if (! flag_unsafe_math_optimizations)
5738 break;
5739 target = expand_builtin_mathfn_2 (exp, target, subtarget);
5740 if (target)
5741 return target;
5742 break;
5743
5744 CASE_FLT_FN (BUILT_IN_SIN):
5745 CASE_FLT_FN (BUILT_IN_COS):
5746 if (! flag_unsafe_math_optimizations)
5747 break;
5748 target = expand_builtin_mathfn_3 (exp, target, subtarget);
5749 if (target)
5750 return target;
5751 break;
5752
5753 CASE_FLT_FN (BUILT_IN_SINCOS):
5754 if (! flag_unsafe_math_optimizations)
5755 break;
5756 target = expand_builtin_sincos (exp);
5757 if (target)
5758 return target;
5759 break;
5760
5761 case BUILT_IN_APPLY_ARGS:
5762 return expand_builtin_apply_args ();
5763
5764 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5765 FUNCTION with a copy of the parameters described by
5766 ARGUMENTS, and ARGSIZE. It returns a block of memory
5767 allocated on the stack into which is stored all the registers
5768 that might possibly be used for returning the result of a
5769 function. ARGUMENTS is the value returned by
5770 __builtin_apply_args. ARGSIZE is the number of bytes of
5771 arguments that must be copied. ??? How should this value be
5772 computed? We'll also need a safe worst case value for varargs
5773 functions. */
5774 case BUILT_IN_APPLY:
5775 if (!validate_arglist (arglist, POINTER_TYPE,
5776 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
5777 && !validate_arglist (arglist, REFERENCE_TYPE,
5778 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
5779 return const0_rtx;
5780 else
5781 {
5782 int i;
5783 tree t;
5784 rtx ops[3];
5785
5786 for (t = arglist, i = 0; t; t = TREE_CHAIN (t), i++)
5787 ops[i] = expand_normal (TREE_VALUE (t));
5788
5789 return expand_builtin_apply (ops[0], ops[1], ops[2]);
5790 }
5791
5792 /* __builtin_return (RESULT) causes the function to return the
5793 value described by RESULT. RESULT is address of the block of
5794 memory returned by __builtin_apply. */
5795 case BUILT_IN_RETURN:
5796 if (validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
5797 expand_builtin_return (expand_normal (TREE_VALUE (arglist)));
5798 return const0_rtx;
5799
5800 case BUILT_IN_SAVEREGS:
5801 return expand_builtin_saveregs ();
5802
5803 case BUILT_IN_ARGS_INFO:
5804 return expand_builtin_args_info (arglist);
5805
5806 /* Return the address of the first anonymous stack arg. */
5807 case BUILT_IN_NEXT_ARG:
5808 if (fold_builtin_next_arg (arglist))
5809 return const0_rtx;
5810 return expand_builtin_next_arg ();
5811
5812 case BUILT_IN_CLASSIFY_TYPE:
5813 return expand_builtin_classify_type (arglist);
5814
5815 case BUILT_IN_CONSTANT_P:
5816 return const0_rtx;
5817
5818 case BUILT_IN_FRAME_ADDRESS:
5819 case BUILT_IN_RETURN_ADDRESS:
5820 return expand_builtin_frame_address (fndecl, arglist);
5821
5822 /* Returns the address of the area where the structure is returned.
5823 0 otherwise. */
5824 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
5825 if (arglist != 0
5826 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
5827 || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl))))
5828 return const0_rtx;
5829 else
5830 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
5831
5832 case BUILT_IN_ALLOCA:
5833 target = expand_builtin_alloca (arglist, target);
5834 if (target)
5835 return target;
5836 break;
5837
5838 case BUILT_IN_STACK_SAVE:
5839 return expand_stack_save ();
5840
5841 case BUILT_IN_STACK_RESTORE:
5842 expand_stack_restore (TREE_VALUE (arglist));
5843 return const0_rtx;
5844
5845 CASE_INT_FN (BUILT_IN_FFS):
5846 case BUILT_IN_FFSIMAX:
5847 target = expand_builtin_unop (target_mode, arglist, target,
5848 subtarget, ffs_optab);
5849 if (target)
5850 return target;
5851 break;
5852
5853 CASE_INT_FN (BUILT_IN_CLZ):
5854 case BUILT_IN_CLZIMAX:
5855 target = expand_builtin_unop (target_mode, arglist, target,
5856 subtarget, clz_optab);
5857 if (target)
5858 return target;
5859 break;
5860
5861 CASE_INT_FN (BUILT_IN_CTZ):
5862 case BUILT_IN_CTZIMAX:
5863 target = expand_builtin_unop (target_mode, arglist, target,
5864 subtarget, ctz_optab);
5865 if (target)
5866 return target;
5867 break;
5868
5869 CASE_INT_FN (BUILT_IN_POPCOUNT):
5870 case BUILT_IN_POPCOUNTIMAX:
5871 target = expand_builtin_unop (target_mode, arglist, target,
5872 subtarget, popcount_optab);
5873 if (target)
5874 return target;
5875 break;
5876
5877 CASE_INT_FN (BUILT_IN_PARITY):
5878 case BUILT_IN_PARITYIMAX:
5879 target = expand_builtin_unop (target_mode, arglist, target,
5880 subtarget, parity_optab);
5881 if (target)
5882 return target;
5883 break;
5884
5885 case BUILT_IN_STRLEN:
5886 target = expand_builtin_strlen (arglist, target, target_mode);
5887 if (target)
5888 return target;
5889 break;
5890
5891 case BUILT_IN_STRCPY:
5892 target = expand_builtin_strcpy (fndecl, arglist, target, mode);
5893 if (target)
5894 return target;
5895 break;
5896
5897 case BUILT_IN_STRNCPY:
5898 target = expand_builtin_strncpy (exp, target, mode);
5899 if (target)
5900 return target;
5901 break;
5902
5903 case BUILT_IN_STPCPY:
5904 target = expand_builtin_stpcpy (exp, target, mode);
5905 if (target)
5906 return target;
5907 break;
5908
5909 case BUILT_IN_STRCAT:
5910 target = expand_builtin_strcat (fndecl, arglist, target, mode);
5911 if (target)
5912 return target;
5913 break;
5914
5915 case BUILT_IN_STRNCAT:
5916 target = expand_builtin_strncat (arglist, target, mode);
5917 if (target)
5918 return target;
5919 break;
5920
5921 case BUILT_IN_STRSPN:
5922 target = expand_builtin_strspn (arglist, target, mode);
5923 if (target)
5924 return target;
5925 break;
5926
5927 case BUILT_IN_STRCSPN:
5928 target = expand_builtin_strcspn (arglist, target, mode);
5929 if (target)
5930 return target;
5931 break;
5932
5933 case BUILT_IN_STRSTR:
5934 target = expand_builtin_strstr (arglist, TREE_TYPE (exp), target, mode);
5935 if (target)
5936 return target;
5937 break;
5938
5939 case BUILT_IN_STRPBRK:
5940 target = expand_builtin_strpbrk (arglist, TREE_TYPE (exp), target, mode);
5941 if (target)
5942 return target;
5943 break;
5944
5945 case BUILT_IN_INDEX:
5946 case BUILT_IN_STRCHR:
5947 target = expand_builtin_strchr (arglist, TREE_TYPE (exp), target, mode);
5948 if (target)
5949 return target;
5950 break;
5951
5952 case BUILT_IN_RINDEX:
5953 case BUILT_IN_STRRCHR:
5954 target = expand_builtin_strrchr (arglist, TREE_TYPE (exp), target, mode);
5955 if (target)
5956 return target;
5957 break;
5958
5959 case BUILT_IN_MEMCPY:
5960 target = expand_builtin_memcpy (exp, target, mode);
5961 if (target)
5962 return target;
5963 break;
5964
5965 case BUILT_IN_MEMPCPY:
5966 target = expand_builtin_mempcpy (arglist, TREE_TYPE (exp), target, mode, /*endp=*/ 1);
5967 if (target)
5968 return target;
5969 break;
5970
5971 case BUILT_IN_MEMMOVE:
5972 target = expand_builtin_memmove (arglist, TREE_TYPE (exp), target,
5973 mode, exp);
5974 if (target)
5975 return target;
5976 break;
5977
5978 case BUILT_IN_BCOPY:
5979 target = expand_builtin_bcopy (exp);
5980 if (target)
5981 return target;
5982 break;
5983
5984 case BUILT_IN_MEMSET:
5985 target = expand_builtin_memset (arglist, target, mode, exp);
5986 if (target)
5987 return target;
5988 break;
5989
5990 case BUILT_IN_BZERO:
5991 target = expand_builtin_bzero (exp);
5992 if (target)
5993 return target;
5994 break;
5995
5996 case BUILT_IN_STRCMP:
5997 target = expand_builtin_strcmp (exp, target, mode);
5998 if (target)
5999 return target;
6000 break;
6001
6002 case BUILT_IN_STRNCMP:
6003 target = expand_builtin_strncmp (exp, target, mode);
6004 if (target)
6005 return target;
6006 break;
6007
6008 case BUILT_IN_BCMP:
6009 case BUILT_IN_MEMCMP:
6010 target = expand_builtin_memcmp (exp, arglist, target, mode);
6011 if (target)
6012 return target;
6013 break;
6014
6015 case BUILT_IN_SETJMP:
6016 /* This should have been lowered to the builtins below. */
6017 gcc_unreachable ();
6018
6019 case BUILT_IN_SETJMP_SETUP:
6020 /* __builtin_setjmp_setup is passed a pointer to an array of five words
6021 and the receiver label. */
6022 if (validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6023 {
6024 rtx buf_addr = expand_expr (TREE_VALUE (arglist), subtarget,
6025 VOIDmode, EXPAND_NORMAL);
6026 tree label = TREE_OPERAND (TREE_VALUE (TREE_CHAIN (arglist)), 0);
6027 rtx label_r = label_rtx (label);
6028
6029 /* This is copied from the handling of non-local gotos. */
6030 expand_builtin_setjmp_setup (buf_addr, label_r);
6031 nonlocal_goto_handler_labels
6032 = gen_rtx_EXPR_LIST (VOIDmode, label_r,
6033 nonlocal_goto_handler_labels);
6034 /* ??? Do not let expand_label treat us as such since we would
6035 not want to be both on the list of non-local labels and on
6036 the list of forced labels. */
6037 FORCED_LABEL (label) = 0;
6038 return const0_rtx;
6039 }
6040 break;
6041
6042 case BUILT_IN_SETJMP_DISPATCHER:
6043 /* __builtin_setjmp_dispatcher is passed the dispatcher label. */
6044 if (validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
6045 {
6046 tree label = TREE_OPERAND (TREE_VALUE (arglist), 0);
6047 rtx label_r = label_rtx (label);
6048
6049 /* Remove the dispatcher label from the list of non-local labels
6050 since the receiver labels have been added to it above. */
6051 remove_node_from_expr_list (label_r, &nonlocal_goto_handler_labels);
6052 return const0_rtx;
6053 }
6054 break;
6055
6056 case BUILT_IN_SETJMP_RECEIVER:
6057 /* __builtin_setjmp_receiver is passed the receiver label. */
6058 if (validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
6059 {
6060 tree label = TREE_OPERAND (TREE_VALUE (arglist), 0);
6061 rtx label_r = label_rtx (label);
6062
6063 expand_builtin_setjmp_receiver (label_r);
6064 return const0_rtx;
6065 }
6066 break;
6067
6068 /* __builtin_longjmp is passed a pointer to an array of five words.
6069 It's similar to the C library longjmp function but works with
6070 __builtin_setjmp above. */
6071 case BUILT_IN_LONGJMP:
6072 if (validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6073 {
6074 rtx buf_addr = expand_expr (TREE_VALUE (arglist), subtarget,
6075 VOIDmode, EXPAND_NORMAL);
6076 rtx value = expand_normal (TREE_VALUE (TREE_CHAIN (arglist)));
6077
6078 if (value != const1_rtx)
6079 {
6080 error ("%<__builtin_longjmp%> second argument must be 1");
6081 return const0_rtx;
6082 }
6083
6084 expand_builtin_longjmp (buf_addr, value);
6085 return const0_rtx;
6086 }
6087 break;
6088
6089 case BUILT_IN_NONLOCAL_GOTO:
6090 target = expand_builtin_nonlocal_goto (arglist);
6091 if (target)
6092 return target;
6093 break;
6094
6095 /* This updates the setjmp buffer that is its argument with the value
6096 of the current stack pointer. */
6097 case BUILT_IN_UPDATE_SETJMP_BUF:
6098 if (validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
6099 {
6100 rtx buf_addr
6101 = expand_normal (TREE_VALUE (arglist));
6102
6103 expand_builtin_update_setjmp_buf (buf_addr);
6104 return const0_rtx;
6105 }
6106 break;
6107
6108 case BUILT_IN_TRAP:
6109 expand_builtin_trap ();
6110 return const0_rtx;
6111
6112 case BUILT_IN_PRINTF:
6113 target = expand_builtin_printf (exp, target, mode, false);
6114 if (target)
6115 return target;
6116 break;
6117
6118 case BUILT_IN_PRINTF_UNLOCKED:
6119 target = expand_builtin_printf (exp, target, mode, true);
6120 if (target)
6121 return target;
6122 break;
6123
6124 case BUILT_IN_FPUTS:
6125 target = expand_builtin_fputs (arglist, target, false);
6126 if (target)
6127 return target;
6128 break;
6129 case BUILT_IN_FPUTS_UNLOCKED:
6130 target = expand_builtin_fputs (arglist, target, true);
6131 if (target)
6132 return target;
6133 break;
6134
6135 case BUILT_IN_FPRINTF:
6136 target = expand_builtin_fprintf (exp, target, mode, false);
6137 if (target)
6138 return target;
6139 break;
6140
6141 case BUILT_IN_FPRINTF_UNLOCKED:
6142 target = expand_builtin_fprintf (exp, target, mode, true);
6143 if (target)
6144 return target;
6145 break;
6146
6147 case BUILT_IN_SPRINTF:
6148 target = expand_builtin_sprintf (arglist, target, mode);
6149 if (target)
6150 return target;
6151 break;
6152
6153 CASE_FLT_FN (BUILT_IN_SIGNBIT):
6154 target = expand_builtin_signbit (exp, target);
6155 if (target)
6156 return target;
6157 break;
6158
6159 /* Various hooks for the DWARF 2 __throw routine. */
6160 case BUILT_IN_UNWIND_INIT:
6161 expand_builtin_unwind_init ();
6162 return const0_rtx;
6163 case BUILT_IN_DWARF_CFA:
6164 return virtual_cfa_rtx;
6165 #ifdef DWARF2_UNWIND_INFO
6166 case BUILT_IN_DWARF_SP_COLUMN:
6167 return expand_builtin_dwarf_sp_column ();
6168 case BUILT_IN_INIT_DWARF_REG_SIZES:
6169 expand_builtin_init_dwarf_reg_sizes (TREE_VALUE (arglist));
6170 return const0_rtx;
6171 #endif
6172 case BUILT_IN_FROB_RETURN_ADDR:
6173 return expand_builtin_frob_return_addr (TREE_VALUE (arglist));
6174 case BUILT_IN_EXTRACT_RETURN_ADDR:
6175 return expand_builtin_extract_return_addr (TREE_VALUE (arglist));
6176 case BUILT_IN_EH_RETURN:
6177 expand_builtin_eh_return (TREE_VALUE (arglist),
6178 TREE_VALUE (TREE_CHAIN (arglist)));
6179 return const0_rtx;
6180 #ifdef EH_RETURN_DATA_REGNO
6181 case BUILT_IN_EH_RETURN_DATA_REGNO:
6182 return expand_builtin_eh_return_data_regno (arglist);
6183 #endif
6184 case BUILT_IN_EXTEND_POINTER:
6185 return expand_builtin_extend_pointer (TREE_VALUE (arglist));
6186
6187 case BUILT_IN_VA_START:
6188 case BUILT_IN_STDARG_START:
6189 return expand_builtin_va_start (arglist);
6190 case BUILT_IN_VA_END:
6191 return expand_builtin_va_end (arglist);
6192 case BUILT_IN_VA_COPY:
6193 return expand_builtin_va_copy (arglist);
6194 case BUILT_IN_EXPECT:
6195 return expand_builtin_expect (arglist, target);
6196 case BUILT_IN_PREFETCH:
6197 expand_builtin_prefetch (arglist);
6198 return const0_rtx;
6199
6200 case BUILT_IN_PROFILE_FUNC_ENTER:
6201 return expand_builtin_profile_func (false);
6202 case BUILT_IN_PROFILE_FUNC_EXIT:
6203 return expand_builtin_profile_func (true);
6204
6205 case BUILT_IN_INIT_TRAMPOLINE:
6206 return expand_builtin_init_trampoline (arglist);
6207 case BUILT_IN_ADJUST_TRAMPOLINE:
6208 return expand_builtin_adjust_trampoline (arglist);
6209
6210 case BUILT_IN_FORK:
6211 case BUILT_IN_EXECL:
6212 case BUILT_IN_EXECV:
6213 case BUILT_IN_EXECLP:
6214 case BUILT_IN_EXECLE:
6215 case BUILT_IN_EXECVP:
6216 case BUILT_IN_EXECVE:
6217 target = expand_builtin_fork_or_exec (fndecl, arglist, target, ignore);
6218 if (target)
6219 return target;
6220 break;
6221
6222 case BUILT_IN_FETCH_AND_ADD_1:
6223 case BUILT_IN_FETCH_AND_ADD_2:
6224 case BUILT_IN_FETCH_AND_ADD_4:
6225 case BUILT_IN_FETCH_AND_ADD_8:
6226 case BUILT_IN_FETCH_AND_ADD_16:
6227 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_ADD_1);
6228 target = expand_builtin_sync_operation (mode, arglist, PLUS,
6229 false, target, ignore);
6230 if (target)
6231 return target;
6232 break;
6233
6234 case BUILT_IN_FETCH_AND_SUB_1:
6235 case BUILT_IN_FETCH_AND_SUB_2:
6236 case BUILT_IN_FETCH_AND_SUB_4:
6237 case BUILT_IN_FETCH_AND_SUB_8:
6238 case BUILT_IN_FETCH_AND_SUB_16:
6239 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_SUB_1);
6240 target = expand_builtin_sync_operation (mode, arglist, MINUS,
6241 false, target, ignore);
6242 if (target)
6243 return target;
6244 break;
6245
6246 case BUILT_IN_FETCH_AND_OR_1:
6247 case BUILT_IN_FETCH_AND_OR_2:
6248 case BUILT_IN_FETCH_AND_OR_4:
6249 case BUILT_IN_FETCH_AND_OR_8:
6250 case BUILT_IN_FETCH_AND_OR_16:
6251 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_OR_1);
6252 target = expand_builtin_sync_operation (mode, arglist, IOR,
6253 false, target, ignore);
6254 if (target)
6255 return target;
6256 break;
6257
6258 case BUILT_IN_FETCH_AND_AND_1:
6259 case BUILT_IN_FETCH_AND_AND_2:
6260 case BUILT_IN_FETCH_AND_AND_4:
6261 case BUILT_IN_FETCH_AND_AND_8:
6262 case BUILT_IN_FETCH_AND_AND_16:
6263 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_AND_1);
6264 target = expand_builtin_sync_operation (mode, arglist, AND,
6265 false, target, ignore);
6266 if (target)
6267 return target;
6268 break;
6269
6270 case BUILT_IN_FETCH_AND_XOR_1:
6271 case BUILT_IN_FETCH_AND_XOR_2:
6272 case BUILT_IN_FETCH_AND_XOR_4:
6273 case BUILT_IN_FETCH_AND_XOR_8:
6274 case BUILT_IN_FETCH_AND_XOR_16:
6275 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_XOR_1);
6276 target = expand_builtin_sync_operation (mode, arglist, XOR,
6277 false, target, ignore);
6278 if (target)
6279 return target;
6280 break;
6281
6282 case BUILT_IN_FETCH_AND_NAND_1:
6283 case BUILT_IN_FETCH_AND_NAND_2:
6284 case BUILT_IN_FETCH_AND_NAND_4:
6285 case BUILT_IN_FETCH_AND_NAND_8:
6286 case BUILT_IN_FETCH_AND_NAND_16:
6287 mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_NAND_1);
6288 target = expand_builtin_sync_operation (mode, arglist, NOT,
6289 false, target, ignore);
6290 if (target)
6291 return target;
6292 break;
6293
6294 case BUILT_IN_ADD_AND_FETCH_1:
6295 case BUILT_IN_ADD_AND_FETCH_2:
6296 case BUILT_IN_ADD_AND_FETCH_4:
6297 case BUILT_IN_ADD_AND_FETCH_8:
6298 case BUILT_IN_ADD_AND_FETCH_16:
6299 mode = get_builtin_sync_mode (fcode - BUILT_IN_ADD_AND_FETCH_1);
6300 target = expand_builtin_sync_operation (mode, arglist, PLUS,
6301 true, target, ignore);
6302 if (target)
6303 return target;
6304 break;
6305
6306 case BUILT_IN_SUB_AND_FETCH_1:
6307 case BUILT_IN_SUB_AND_FETCH_2:
6308 case BUILT_IN_SUB_AND_FETCH_4:
6309 case BUILT_IN_SUB_AND_FETCH_8:
6310 case BUILT_IN_SUB_AND_FETCH_16:
6311 mode = get_builtin_sync_mode (fcode - BUILT_IN_SUB_AND_FETCH_1);
6312 target = expand_builtin_sync_operation (mode, arglist, MINUS,
6313 true, target, ignore);
6314 if (target)
6315 return target;
6316 break;
6317
6318 case BUILT_IN_OR_AND_FETCH_1:
6319 case BUILT_IN_OR_AND_FETCH_2:
6320 case BUILT_IN_OR_AND_FETCH_4:
6321 case BUILT_IN_OR_AND_FETCH_8:
6322 case BUILT_IN_OR_AND_FETCH_16:
6323 mode = get_builtin_sync_mode (fcode - BUILT_IN_OR_AND_FETCH_1);
6324 target = expand_builtin_sync_operation (mode, arglist, IOR,
6325 true, target, ignore);
6326 if (target)
6327 return target;
6328 break;
6329
6330 case BUILT_IN_AND_AND_FETCH_1:
6331 case BUILT_IN_AND_AND_FETCH_2:
6332 case BUILT_IN_AND_AND_FETCH_4:
6333 case BUILT_IN_AND_AND_FETCH_8:
6334 case BUILT_IN_AND_AND_FETCH_16:
6335 mode = get_builtin_sync_mode (fcode - BUILT_IN_AND_AND_FETCH_1);
6336 target = expand_builtin_sync_operation (mode, arglist, AND,
6337 true, target, ignore);
6338 if (target)
6339 return target;
6340 break;
6341
6342 case BUILT_IN_XOR_AND_FETCH_1:
6343 case BUILT_IN_XOR_AND_FETCH_2:
6344 case BUILT_IN_XOR_AND_FETCH_4:
6345 case BUILT_IN_XOR_AND_FETCH_8:
6346 case BUILT_IN_XOR_AND_FETCH_16:
6347 mode = get_builtin_sync_mode (fcode - BUILT_IN_XOR_AND_FETCH_1);
6348 target = expand_builtin_sync_operation (mode, arglist, XOR,
6349 true, target, ignore);
6350 if (target)
6351 return target;
6352 break;
6353
6354 case BUILT_IN_NAND_AND_FETCH_1:
6355 case BUILT_IN_NAND_AND_FETCH_2:
6356 case BUILT_IN_NAND_AND_FETCH_4:
6357 case BUILT_IN_NAND_AND_FETCH_8:
6358 case BUILT_IN_NAND_AND_FETCH_16:
6359 mode = get_builtin_sync_mode (fcode - BUILT_IN_NAND_AND_FETCH_1);
6360 target = expand_builtin_sync_operation (mode, arglist, NOT,
6361 true, target, ignore);
6362 if (target)
6363 return target;
6364 break;
6365
6366 case BUILT_IN_BOOL_COMPARE_AND_SWAP_1:
6367 case BUILT_IN_BOOL_COMPARE_AND_SWAP_2:
6368 case BUILT_IN_BOOL_COMPARE_AND_SWAP_4:
6369 case BUILT_IN_BOOL_COMPARE_AND_SWAP_8:
6370 case BUILT_IN_BOOL_COMPARE_AND_SWAP_16:
6371 if (mode == VOIDmode)
6372 mode = TYPE_MODE (boolean_type_node);
6373 if (!target || !register_operand (target, mode))
6374 target = gen_reg_rtx (mode);
6375
6376 mode = get_builtin_sync_mode (fcode - BUILT_IN_BOOL_COMPARE_AND_SWAP_1);
6377 target = expand_builtin_compare_and_swap (mode, arglist, true, target);
6378 if (target)
6379 return target;
6380 break;
6381
6382 case BUILT_IN_VAL_COMPARE_AND_SWAP_1:
6383 case BUILT_IN_VAL_COMPARE_AND_SWAP_2:
6384 case BUILT_IN_VAL_COMPARE_AND_SWAP_4:
6385 case BUILT_IN_VAL_COMPARE_AND_SWAP_8:
6386 case BUILT_IN_VAL_COMPARE_AND_SWAP_16:
6387 mode = get_builtin_sync_mode (fcode - BUILT_IN_VAL_COMPARE_AND_SWAP_1);
6388 target = expand_builtin_compare_and_swap (mode, arglist, false, target);
6389 if (target)
6390 return target;
6391 break;
6392
6393 case BUILT_IN_LOCK_TEST_AND_SET_1:
6394 case BUILT_IN_LOCK_TEST_AND_SET_2:
6395 case BUILT_IN_LOCK_TEST_AND_SET_4:
6396 case BUILT_IN_LOCK_TEST_AND_SET_8:
6397 case BUILT_IN_LOCK_TEST_AND_SET_16:
6398 mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_TEST_AND_SET_1);
6399 target = expand_builtin_lock_test_and_set (mode, arglist, target);
6400 if (target)
6401 return target;
6402 break;
6403
6404 case BUILT_IN_LOCK_RELEASE_1:
6405 case BUILT_IN_LOCK_RELEASE_2:
6406 case BUILT_IN_LOCK_RELEASE_4:
6407 case BUILT_IN_LOCK_RELEASE_8:
6408 case BUILT_IN_LOCK_RELEASE_16:
6409 mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_RELEASE_1);
6410 expand_builtin_lock_release (mode, arglist);
6411 return const0_rtx;
6412
6413 case BUILT_IN_SYNCHRONIZE:
6414 expand_builtin_synchronize ();
6415 return const0_rtx;
6416
6417 case BUILT_IN_OBJECT_SIZE:
6418 return expand_builtin_object_size (exp);
6419
6420 case BUILT_IN_MEMCPY_CHK:
6421 case BUILT_IN_MEMPCPY_CHK:
6422 case BUILT_IN_MEMMOVE_CHK:
6423 case BUILT_IN_MEMSET_CHK:
6424 target = expand_builtin_memory_chk (exp, target, mode, fcode);
6425 if (target)
6426 return target;
6427 break;
6428
6429 case BUILT_IN_STRCPY_CHK:
6430 case BUILT_IN_STPCPY_CHK:
6431 case BUILT_IN_STRNCPY_CHK:
6432 case BUILT_IN_STRCAT_CHK:
6433 case BUILT_IN_SNPRINTF_CHK:
6434 case BUILT_IN_VSNPRINTF_CHK:
6435 maybe_emit_chk_warning (exp, fcode);
6436 break;
6437
6438 case BUILT_IN_SPRINTF_CHK:
6439 case BUILT_IN_VSPRINTF_CHK:
6440 maybe_emit_sprintf_chk_warning (exp, fcode);
6441 break;
6442
6443 default: /* just do library call, if unknown builtin */
6444 break;
6445 }
6446
6447 /* The switch statement above can drop through to cause the function
6448 to be called normally. */
6449 return expand_call (exp, target, ignore);
6450 }
6451
6452 /* Determine whether a tree node represents a call to a built-in
6453 function. If the tree T is a call to a built-in function with
6454 the right number of arguments of the appropriate types, return
6455 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6456 Otherwise the return value is END_BUILTINS. */
6457
6458 enum built_in_function
6459 builtin_mathfn_code (tree t)
6460 {
6461 tree fndecl, arglist, parmlist;
6462 tree argtype, parmtype;
6463
6464 if (TREE_CODE (t) != CALL_EXPR
6465 || TREE_CODE (TREE_OPERAND (t, 0)) != ADDR_EXPR)
6466 return END_BUILTINS;
6467
6468 fndecl = get_callee_fndecl (t);
6469 if (fndecl == NULL_TREE
6470 || TREE_CODE (fndecl) != FUNCTION_DECL
6471 || ! DECL_BUILT_IN (fndecl)
6472 || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6473 return END_BUILTINS;
6474
6475 arglist = TREE_OPERAND (t, 1);
6476 parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6477 for (; parmlist; parmlist = TREE_CHAIN (parmlist))
6478 {
6479 /* If a function doesn't take a variable number of arguments,
6480 the last element in the list will have type `void'. */
6481 parmtype = TREE_VALUE (parmlist);
6482 if (VOID_TYPE_P (parmtype))
6483 {
6484 if (arglist)
6485 return END_BUILTINS;
6486 return DECL_FUNCTION_CODE (fndecl);
6487 }
6488
6489 if (! arglist)
6490 return END_BUILTINS;
6491
6492 argtype = TREE_TYPE (TREE_VALUE (arglist));
6493
6494 if (SCALAR_FLOAT_TYPE_P (parmtype))
6495 {
6496 if (! SCALAR_FLOAT_TYPE_P (argtype))
6497 return END_BUILTINS;
6498 }
6499 else if (COMPLEX_FLOAT_TYPE_P (parmtype))
6500 {
6501 if (! COMPLEX_FLOAT_TYPE_P (argtype))
6502 return END_BUILTINS;
6503 }
6504 else if (POINTER_TYPE_P (parmtype))
6505 {
6506 if (! POINTER_TYPE_P (argtype))
6507 return END_BUILTINS;
6508 }
6509 else if (INTEGRAL_TYPE_P (parmtype))
6510 {
6511 if (! INTEGRAL_TYPE_P (argtype))
6512 return END_BUILTINS;
6513 }
6514 else
6515 return END_BUILTINS;
6516
6517 arglist = TREE_CHAIN (arglist);
6518 }
6519
6520 /* Variable-length argument list. */
6521 return DECL_FUNCTION_CODE (fndecl);
6522 }
6523
6524 /* Fold a call to __builtin_constant_p, if we know it will evaluate to a
6525 constant. ARGLIST is the argument list of the call. */
6526
6527 static tree
6528 fold_builtin_constant_p (tree arglist)
6529 {
6530 if (arglist == 0)
6531 return 0;
6532
6533 arglist = TREE_VALUE (arglist);
6534
6535 /* We return 1 for a numeric type that's known to be a constant
6536 value at compile-time or for an aggregate type that's a
6537 literal constant. */
6538 STRIP_NOPS (arglist);
6539
6540 /* If we know this is a constant, emit the constant of one. */
6541 if (CONSTANT_CLASS_P (arglist)
6542 || (TREE_CODE (arglist) == CONSTRUCTOR
6543 && TREE_CONSTANT (arglist)))
6544 return integer_one_node;
6545 if (TREE_CODE (arglist) == ADDR_EXPR)
6546 {
6547 tree op = TREE_OPERAND (arglist, 0);
6548 if (TREE_CODE (op) == STRING_CST
6549 || (TREE_CODE (op) == ARRAY_REF
6550 && integer_zerop (TREE_OPERAND (op, 1))
6551 && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST))
6552 return integer_one_node;
6553 }
6554
6555 /* If this expression has side effects, show we don't know it to be a
6556 constant. Likewise if it's a pointer or aggregate type since in
6557 those case we only want literals, since those are only optimized
6558 when generating RTL, not later.
6559 And finally, if we are compiling an initializer, not code, we
6560 need to return a definite result now; there's not going to be any
6561 more optimization done. */
6562 if (TREE_SIDE_EFFECTS (arglist)
6563 || AGGREGATE_TYPE_P (TREE_TYPE (arglist))
6564 || POINTER_TYPE_P (TREE_TYPE (arglist))
6565 || cfun == 0
6566 || folding_initializer)
6567 return integer_zero_node;
6568
6569 return 0;
6570 }
6571
6572 /* Fold a call to __builtin_expect, if we expect that a comparison against
6573 the argument will fold to a constant. In practice, this means a true
6574 constant or the address of a non-weak symbol. ARGLIST is the argument
6575 list of the call. */
6576
6577 static tree
6578 fold_builtin_expect (tree arglist)
6579 {
6580 tree arg, inner;
6581
6582 if (arglist == 0)
6583 return 0;
6584
6585 arg = TREE_VALUE (arglist);
6586
6587 /* If the argument isn't invariant, then there's nothing we can do. */
6588 if (!TREE_INVARIANT (arg))
6589 return 0;
6590
6591 /* If we're looking at an address of a weak decl, then do not fold. */
6592 inner = arg;
6593 STRIP_NOPS (inner);
6594 if (TREE_CODE (inner) == ADDR_EXPR)
6595 {
6596 do
6597 {
6598 inner = TREE_OPERAND (inner, 0);
6599 }
6600 while (TREE_CODE (inner) == COMPONENT_REF
6601 || TREE_CODE (inner) == ARRAY_REF);
6602 if (DECL_P (inner) && DECL_WEAK (inner))
6603 return 0;
6604 }
6605
6606 /* Otherwise, ARG already has the proper type for the return value. */
6607 return arg;
6608 }
6609
6610 /* Fold a call to __builtin_classify_type. */
6611
6612 static tree
6613 fold_builtin_classify_type (tree arglist)
6614 {
6615 if (arglist == 0)
6616 return build_int_cst (NULL_TREE, no_type_class);
6617
6618 return build_int_cst (NULL_TREE,
6619 type_to_class (TREE_TYPE (TREE_VALUE (arglist))));
6620 }
6621
6622 /* Fold a call to __builtin_strlen. */
6623
6624 static tree
6625 fold_builtin_strlen (tree arglist)
6626 {
6627 if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
6628 return NULL_TREE;
6629 else
6630 {
6631 tree len = c_strlen (TREE_VALUE (arglist), 0);
6632
6633 if (len)
6634 {
6635 /* Convert from the internal "sizetype" type to "size_t". */
6636 if (size_type_node)
6637 len = fold_convert (size_type_node, len);
6638 return len;
6639 }
6640
6641 return NULL_TREE;
6642 }
6643 }
6644
6645 /* Fold a call to __builtin_inf or __builtin_huge_val. */
6646
6647 static tree
6648 fold_builtin_inf (tree type, int warn)
6649 {
6650 REAL_VALUE_TYPE real;
6651
6652 /* __builtin_inff is intended to be usable to define INFINITY on all
6653 targets. If an infinity is not available, INFINITY expands "to a
6654 positive constant of type float that overflows at translation
6655 time", footnote "In this case, using INFINITY will violate the
6656 constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
6657 Thus we pedwarn to ensure this constraint violation is
6658 diagnosed. */
6659 if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
6660 pedwarn ("target format does not support infinity");
6661
6662 real_inf (&real);
6663 return build_real (type, real);
6664 }
6665
6666 /* Fold a call to __builtin_nan or __builtin_nans. */
6667
6668 static tree
6669 fold_builtin_nan (tree arglist, tree type, int quiet)
6670 {
6671 REAL_VALUE_TYPE real;
6672 const char *str;
6673
6674 if (!validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
6675 return 0;
6676 str = c_getstr (TREE_VALUE (arglist));
6677 if (!str)
6678 return 0;
6679
6680 if (!real_nan (&real, str, quiet, TYPE_MODE (type)))
6681 return 0;
6682
6683 return build_real (type, real);
6684 }
6685
6686 /* Return true if the floating point expression T has an integer value.
6687 We also allow +Inf, -Inf and NaN to be considered integer values. */
6688
6689 static bool
6690 integer_valued_real_p (tree t)
6691 {
6692 switch (TREE_CODE (t))
6693 {
6694 case FLOAT_EXPR:
6695 return true;
6696
6697 case ABS_EXPR:
6698 case SAVE_EXPR:
6699 case NON_LVALUE_EXPR:
6700 return integer_valued_real_p (TREE_OPERAND (t, 0));
6701
6702 case COMPOUND_EXPR:
6703 case MODIFY_EXPR:
6704 case BIND_EXPR:
6705 return integer_valued_real_p (TREE_OPERAND (t, 1));
6706
6707 case PLUS_EXPR:
6708 case MINUS_EXPR:
6709 case MULT_EXPR:
6710 case MIN_EXPR:
6711 case MAX_EXPR:
6712 return integer_valued_real_p (TREE_OPERAND (t, 0))
6713 && integer_valued_real_p (TREE_OPERAND (t, 1));
6714
6715 case COND_EXPR:
6716 return integer_valued_real_p (TREE_OPERAND (t, 1))
6717 && integer_valued_real_p (TREE_OPERAND (t, 2));
6718
6719 case REAL_CST:
6720 if (! TREE_CONSTANT_OVERFLOW (t))
6721 {
6722 REAL_VALUE_TYPE c, cint;
6723
6724 c = TREE_REAL_CST (t);
6725 real_trunc (&cint, TYPE_MODE (TREE_TYPE (t)), &c);
6726 return real_identical (&c, &cint);
6727 }
6728 break;
6729
6730 case NOP_EXPR:
6731 {
6732 tree type = TREE_TYPE (TREE_OPERAND (t, 0));
6733 if (TREE_CODE (type) == INTEGER_TYPE)
6734 return true;
6735 if (TREE_CODE (type) == REAL_TYPE)
6736 return integer_valued_real_p (TREE_OPERAND (t, 0));
6737 break;
6738 }
6739
6740 case CALL_EXPR:
6741 switch (builtin_mathfn_code (t))
6742 {
6743 CASE_FLT_FN (BUILT_IN_CEIL):
6744 CASE_FLT_FN (BUILT_IN_FLOOR):
6745 CASE_FLT_FN (BUILT_IN_NEARBYINT):
6746 CASE_FLT_FN (BUILT_IN_RINT):
6747 CASE_FLT_FN (BUILT_IN_ROUND):
6748 CASE_FLT_FN (BUILT_IN_TRUNC):
6749 return true;
6750
6751 default:
6752 break;
6753 }
6754 break;
6755
6756 default:
6757 break;
6758 }
6759 return false;
6760 }
6761
6762 /* EXP is assumed to be builtin call where truncation can be propagated
6763 across (for instance floor((double)f) == (double)floorf (f).
6764 Do the transformation. */
6765
6766 static tree
6767 fold_trunc_transparent_mathfn (tree fndecl, tree arglist)
6768 {
6769 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6770 tree arg;
6771
6772 if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6773 return 0;
6774
6775 arg = TREE_VALUE (arglist);
6776 /* Integer rounding functions are idempotent. */
6777 if (fcode == builtin_mathfn_code (arg))
6778 return arg;
6779
6780 /* If argument is already integer valued, and we don't need to worry
6781 about setting errno, there's no need to perform rounding. */
6782 if (! flag_errno_math && integer_valued_real_p (arg))
6783 return arg;
6784
6785 if (optimize)
6786 {
6787 tree arg0 = strip_float_extensions (arg);
6788 tree ftype = TREE_TYPE (TREE_TYPE (fndecl));
6789 tree newtype = TREE_TYPE (arg0);
6790 tree decl;
6791
6792 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
6793 && (decl = mathfn_built_in (newtype, fcode)))
6794 {
6795 arglist =
6796 build_tree_list (NULL_TREE, fold_convert (newtype, arg0));
6797 return fold_convert (ftype,
6798 build_function_call_expr (decl, arglist));
6799 }
6800 }
6801 return 0;
6802 }
6803
6804 /* EXP is assumed to be builtin call which can narrow the FP type of
6805 the argument, for instance lround((double)f) -> lroundf (f). */
6806
6807 static tree
6808 fold_fixed_mathfn (tree fndecl, tree arglist)
6809 {
6810 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6811 tree arg;
6812
6813 if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6814 return 0;
6815
6816 arg = TREE_VALUE (arglist);
6817
6818 /* If argument is already integer valued, and we don't need to worry
6819 about setting errno, there's no need to perform rounding. */
6820 if (! flag_errno_math && integer_valued_real_p (arg))
6821 return fold_build1 (FIX_TRUNC_EXPR, TREE_TYPE (TREE_TYPE (fndecl)), arg);
6822
6823 if (optimize)
6824 {
6825 tree ftype = TREE_TYPE (arg);
6826 tree arg0 = strip_float_extensions (arg);
6827 tree newtype = TREE_TYPE (arg0);
6828 tree decl;
6829
6830 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
6831 && (decl = mathfn_built_in (newtype, fcode)))
6832 {
6833 arglist =
6834 build_tree_list (NULL_TREE, fold_convert (newtype, arg0));
6835 return build_function_call_expr (decl, arglist);
6836 }
6837 }
6838
6839 /* Canonicalize llround (x) to lround (x) on LP64 targets where
6840 sizeof (long long) == sizeof (long). */
6841 if (TYPE_PRECISION (long_long_integer_type_node)
6842 == TYPE_PRECISION (long_integer_type_node))
6843 {
6844 tree newfn = NULL_TREE;
6845 switch (fcode)
6846 {
6847 CASE_FLT_FN (BUILT_IN_LLCEIL):
6848 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LCEIL);
6849 break;
6850
6851 CASE_FLT_FN (BUILT_IN_LLFLOOR):
6852 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LFLOOR);
6853 break;
6854
6855 CASE_FLT_FN (BUILT_IN_LLROUND):
6856 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LROUND);
6857 break;
6858
6859 CASE_FLT_FN (BUILT_IN_LLRINT):
6860 newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LRINT);
6861 break;
6862
6863 default:
6864 break;
6865 }
6866
6867 if (newfn)
6868 {
6869 tree newcall = build_function_call_expr (newfn, arglist);
6870 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), newcall);
6871 }
6872 }
6873
6874 return 0;
6875 }
6876
6877 /* Fold function call to builtin cabs, cabsf or cabsl. ARGLIST
6878 is the argument list, TYPE is the return type and FNDECL is the
6879 original function DECL. Return NULL_TREE if no if no simplification
6880 can be made. */
6881
6882 static tree
6883 fold_builtin_cabs (tree arglist, tree type, tree fndecl)
6884 {
6885 tree arg;
6886
6887 if (!arglist || TREE_CHAIN (arglist))
6888 return NULL_TREE;
6889
6890 arg = TREE_VALUE (arglist);
6891 if (TREE_CODE (TREE_TYPE (arg)) != COMPLEX_TYPE
6892 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
6893 return NULL_TREE;
6894
6895 /* Evaluate cabs of a constant at compile-time. */
6896 if (flag_unsafe_math_optimizations
6897 && TREE_CODE (arg) == COMPLEX_CST
6898 && TREE_CODE (TREE_REALPART (arg)) == REAL_CST
6899 && TREE_CODE (TREE_IMAGPART (arg)) == REAL_CST
6900 && ! TREE_CONSTANT_OVERFLOW (TREE_REALPART (arg))
6901 && ! TREE_CONSTANT_OVERFLOW (TREE_IMAGPART (arg)))
6902 {
6903 REAL_VALUE_TYPE r, i;
6904
6905 r = TREE_REAL_CST (TREE_REALPART (arg));
6906 i = TREE_REAL_CST (TREE_IMAGPART (arg));
6907
6908 real_arithmetic (&r, MULT_EXPR, &r, &r);
6909 real_arithmetic (&i, MULT_EXPR, &i, &i);
6910 real_arithmetic (&r, PLUS_EXPR, &r, &i);
6911 if (real_sqrt (&r, TYPE_MODE (type), &r)
6912 || ! flag_trapping_math)
6913 return build_real (type, r);
6914 }
6915
6916 /* If either part is zero, cabs is fabs of the other. */
6917 if (TREE_CODE (arg) == COMPLEX_EXPR
6918 && real_zerop (TREE_OPERAND (arg, 0)))
6919 return fold_build1 (ABS_EXPR, type, TREE_OPERAND (arg, 1));
6920 if (TREE_CODE (arg) == COMPLEX_EXPR
6921 && real_zerop (TREE_OPERAND (arg, 1)))
6922 return fold_build1 (ABS_EXPR, type, TREE_OPERAND (arg, 0));
6923
6924 /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z). */
6925 if (TREE_CODE (arg) == NEGATE_EXPR
6926 || TREE_CODE (arg) == CONJ_EXPR)
6927 {
6928 tree arglist = build_tree_list (NULL_TREE, TREE_OPERAND (arg, 0));
6929 return build_function_call_expr (fndecl, arglist);
6930 }
6931
6932 /* Don't do this when optimizing for size. */
6933 if (flag_unsafe_math_optimizations
6934 && optimize && !optimize_size)
6935 {
6936 tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
6937
6938 if (sqrtfn != NULL_TREE)
6939 {
6940 tree rpart, ipart, result, arglist;
6941
6942 arg = builtin_save_expr (arg);
6943
6944 rpart = fold_build1 (REALPART_EXPR, type, arg);
6945 ipart = fold_build1 (IMAGPART_EXPR, type, arg);
6946
6947 rpart = builtin_save_expr (rpart);
6948 ipart = builtin_save_expr (ipart);
6949
6950 result = fold_build2 (PLUS_EXPR, type,
6951 fold_build2 (MULT_EXPR, type,
6952 rpart, rpart),
6953 fold_build2 (MULT_EXPR, type,
6954 ipart, ipart));
6955
6956 arglist = build_tree_list (NULL_TREE, result);
6957 return build_function_call_expr (sqrtfn, arglist);
6958 }
6959 }
6960
6961 return NULL_TREE;
6962 }
6963
6964 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl. Return
6965 NULL_TREE if no simplification can be made. */
6966
6967 static tree
6968 fold_builtin_sqrt (tree arglist, tree type)
6969 {
6970
6971 enum built_in_function fcode;
6972 tree arg = TREE_VALUE (arglist);
6973
6974 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
6975 return NULL_TREE;
6976
6977 /* Optimize sqrt of constant value. */
6978 if (TREE_CODE (arg) == REAL_CST
6979 && ! TREE_CONSTANT_OVERFLOW (arg))
6980 {
6981 REAL_VALUE_TYPE r, x;
6982
6983 x = TREE_REAL_CST (arg);
6984 if (real_sqrt (&r, TYPE_MODE (type), &x)
6985 || (!flag_trapping_math && !flag_errno_math))
6986 return build_real (type, r);
6987 }
6988
6989 /* Optimize sqrt(expN(x)) = expN(x*0.5). */
6990 fcode = builtin_mathfn_code (arg);
6991 if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
6992 {
6993 tree expfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
6994 arg = fold_build2 (MULT_EXPR, type,
6995 TREE_VALUE (TREE_OPERAND (arg, 1)),
6996 build_real (type, dconsthalf));
6997 arglist = build_tree_list (NULL_TREE, arg);
6998 return build_function_call_expr (expfn, arglist);
6999 }
7000
7001 /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)). */
7002 if (flag_unsafe_math_optimizations && BUILTIN_ROOT_P (fcode))
7003 {
7004 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7005
7006 if (powfn)
7007 {
7008 tree arg0 = TREE_VALUE (TREE_OPERAND (arg, 1));
7009 tree tree_root;
7010 /* The inner root was either sqrt or cbrt. */
7011 REAL_VALUE_TYPE dconstroot =
7012 BUILTIN_SQRT_P (fcode) ? dconsthalf : dconstthird;
7013
7014 /* Adjust for the outer root. */
7015 SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7016 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7017 tree_root = build_real (type, dconstroot);
7018 arglist = tree_cons (NULL_TREE, arg0,
7019 build_tree_list (NULL_TREE, tree_root));
7020 return build_function_call_expr (powfn, arglist);
7021 }
7022 }
7023
7024 /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5). */
7025 if (flag_unsafe_math_optimizations
7026 && (fcode == BUILT_IN_POW
7027 || fcode == BUILT_IN_POWF
7028 || fcode == BUILT_IN_POWL))
7029 {
7030 tree powfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
7031 tree arg0 = TREE_VALUE (TREE_OPERAND (arg, 1));
7032 tree arg1 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg, 1)));
7033 tree narg1;
7034 if (!tree_expr_nonnegative_p (arg0))
7035 arg0 = build1 (ABS_EXPR, type, arg0);
7036 narg1 = fold_build2 (MULT_EXPR, type, arg1,
7037 build_real (type, dconsthalf));
7038 arglist = tree_cons (NULL_TREE, arg0,
7039 build_tree_list (NULL_TREE, narg1));
7040 return build_function_call_expr (powfn, arglist);
7041 }
7042
7043 return NULL_TREE;
7044 }
7045
7046 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl. Return
7047 NULL_TREE if no simplification can be made. */
7048 static tree
7049 fold_builtin_cbrt (tree arglist, tree type)
7050 {
7051 tree arg = TREE_VALUE (arglist);
7052 const enum built_in_function fcode = builtin_mathfn_code (arg);
7053
7054 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7055 return NULL_TREE;
7056
7057 /* Optimize cbrt of constant value. */
7058 if (real_zerop (arg) || real_onep (arg) || real_minus_onep (arg))
7059 return arg;
7060
7061 if (flag_unsafe_math_optimizations)
7062 {
7063 /* Optimize cbrt(expN(x)) -> expN(x/3). */
7064 if (BUILTIN_EXPONENT_P (fcode))
7065 {
7066 tree expfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
7067 const REAL_VALUE_TYPE third_trunc =
7068 real_value_truncate (TYPE_MODE (type), dconstthird);
7069 arg = fold_build2 (MULT_EXPR, type,
7070 TREE_VALUE (TREE_OPERAND (arg, 1)),
7071 build_real (type, third_trunc));
7072 arglist = build_tree_list (NULL_TREE, arg);
7073 return build_function_call_expr (expfn, arglist);
7074 }
7075
7076 /* Optimize cbrt(sqrt(x)) -> pow(x,1/6). */
7077 if (BUILTIN_SQRT_P (fcode))
7078 {
7079 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7080
7081 if (powfn)
7082 {
7083 tree arg0 = TREE_VALUE (TREE_OPERAND (arg, 1));
7084 tree tree_root;
7085 REAL_VALUE_TYPE dconstroot = dconstthird;
7086
7087 SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7088 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7089 tree_root = build_real (type, dconstroot);
7090 arglist = tree_cons (NULL_TREE, arg0,
7091 build_tree_list (NULL_TREE, tree_root));
7092 return build_function_call_expr (powfn, arglist);
7093 }
7094 }
7095
7096 /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative. */
7097 if (BUILTIN_CBRT_P (fcode))
7098 {
7099 tree arg0 = TREE_VALUE (TREE_OPERAND (arg, 1));
7100 if (tree_expr_nonnegative_p (arg0))
7101 {
7102 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7103
7104 if (powfn)
7105 {
7106 tree tree_root;
7107 REAL_VALUE_TYPE dconstroot;
7108
7109 real_arithmetic (&dconstroot, MULT_EXPR, &dconstthird, &dconstthird);
7110 dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7111 tree_root = build_real (type, dconstroot);
7112 arglist = tree_cons (NULL_TREE, arg0,
7113 build_tree_list (NULL_TREE, tree_root));
7114 return build_function_call_expr (powfn, arglist);
7115 }
7116 }
7117 }
7118
7119 /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative. */
7120 if (fcode == BUILT_IN_POW || fcode == BUILT_IN_POWF
7121 || fcode == BUILT_IN_POWL)
7122 {
7123 tree arg00 = TREE_VALUE (TREE_OPERAND (arg, 1));
7124 tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg, 1)));
7125 if (tree_expr_nonnegative_p (arg00))
7126 {
7127 tree powfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
7128 const REAL_VALUE_TYPE dconstroot
7129 = real_value_truncate (TYPE_MODE (type), dconstthird);
7130 tree narg01 = fold_build2 (MULT_EXPR, type, arg01,
7131 build_real (type, dconstroot));
7132 arglist = tree_cons (NULL_TREE, arg00,
7133 build_tree_list (NULL_TREE, narg01));
7134 return build_function_call_expr (powfn, arglist);
7135 }
7136 }
7137 }
7138 return NULL_TREE;
7139 }
7140
7141 /* Fold function call to builtin sin, sinf, or sinl. Return
7142 NULL_TREE if no simplification can be made. */
7143 static tree
7144 fold_builtin_sin (tree arglist)
7145 {
7146 tree arg = TREE_VALUE (arglist);
7147
7148 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7149 return NULL_TREE;
7150
7151 /* Optimize sin (0.0) = 0.0. */
7152 if (real_zerop (arg))
7153 return arg;
7154
7155 return NULL_TREE;
7156 }
7157
7158 /* Fold function call to builtin cos, cosf, or cosl. Return
7159 NULL_TREE if no simplification can be made. */
7160 static tree
7161 fold_builtin_cos (tree arglist, tree type, tree fndecl)
7162 {
7163 tree arg = TREE_VALUE (arglist);
7164
7165 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7166 return NULL_TREE;
7167
7168 /* Optimize cos (0.0) = 1.0. */
7169 if (real_zerop (arg))
7170 return build_real (type, dconst1);
7171
7172 /* Optimize cos(-x) into cos (x). */
7173 if (TREE_CODE (arg) == NEGATE_EXPR)
7174 {
7175 tree args = build_tree_list (NULL_TREE,
7176 TREE_OPERAND (arg, 0));
7177 return build_function_call_expr (fndecl, args);
7178 }
7179
7180 return NULL_TREE;
7181 }
7182
7183 /* Fold function call to builtin tan, tanf, or tanl. Return
7184 NULL_TREE if no simplification can be made. */
7185 static tree
7186 fold_builtin_tan (tree arglist)
7187 {
7188 enum built_in_function fcode;
7189 tree arg = TREE_VALUE (arglist);
7190
7191 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7192 return NULL_TREE;
7193
7194 /* Optimize tan(0.0) = 0.0. */
7195 if (real_zerop (arg))
7196 return arg;
7197
7198 /* Optimize tan(atan(x)) = x. */
7199 fcode = builtin_mathfn_code (arg);
7200 if (flag_unsafe_math_optimizations
7201 && (fcode == BUILT_IN_ATAN
7202 || fcode == BUILT_IN_ATANF
7203 || fcode == BUILT_IN_ATANL))
7204 return TREE_VALUE (TREE_OPERAND (arg, 1));
7205
7206 return NULL_TREE;
7207 }
7208
7209 /* Fold function call to builtin atan, atanf, or atanl. Return
7210 NULL_TREE if no simplification can be made. */
7211
7212 static tree
7213 fold_builtin_atan (tree arglist, tree type)
7214 {
7215
7216 tree arg = TREE_VALUE (arglist);
7217
7218 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7219 return NULL_TREE;
7220
7221 /* Optimize atan(0.0) = 0.0. */
7222 if (real_zerop (arg))
7223 return arg;
7224
7225 /* Optimize atan(1.0) = pi/4. */
7226 if (real_onep (arg))
7227 {
7228 REAL_VALUE_TYPE cst;
7229
7230 real_convert (&cst, TYPE_MODE (type), &dconstpi);
7231 SET_REAL_EXP (&cst, REAL_EXP (&cst) - 2);
7232 return build_real (type, cst);
7233 }
7234
7235 return NULL_TREE;
7236 }
7237
7238 /* Fold function call to builtin trunc, truncf or truncl. Return
7239 NULL_TREE if no simplification can be made. */
7240
7241 static tree
7242 fold_builtin_trunc (tree fndecl, tree arglist)
7243 {
7244 tree arg;
7245
7246 if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7247 return 0;
7248
7249 /* Optimize trunc of constant value. */
7250 arg = TREE_VALUE (arglist);
7251 if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
7252 {
7253 REAL_VALUE_TYPE r, x;
7254 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7255
7256 x = TREE_REAL_CST (arg);
7257 real_trunc (&r, TYPE_MODE (type), &x);
7258 return build_real (type, r);
7259 }
7260
7261 return fold_trunc_transparent_mathfn (fndecl, arglist);
7262 }
7263
7264 /* Fold function call to builtin floor, floorf or floorl. Return
7265 NULL_TREE if no simplification can be made. */
7266
7267 static tree
7268 fold_builtin_floor (tree fndecl, tree arglist)
7269 {
7270 tree arg;
7271
7272 if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7273 return 0;
7274
7275 /* Optimize floor of constant value. */
7276 arg = TREE_VALUE (arglist);
7277 if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
7278 {
7279 REAL_VALUE_TYPE x;
7280
7281 x = TREE_REAL_CST (arg);
7282 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7283 {
7284 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7285 REAL_VALUE_TYPE r;
7286
7287 real_floor (&r, TYPE_MODE (type), &x);
7288 return build_real (type, r);
7289 }
7290 }
7291
7292 return fold_trunc_transparent_mathfn (fndecl, arglist);
7293 }
7294
7295 /* Fold function call to builtin ceil, ceilf or ceill. Return
7296 NULL_TREE if no simplification can be made. */
7297
7298 static tree
7299 fold_builtin_ceil (tree fndecl, tree arglist)
7300 {
7301 tree arg;
7302
7303 if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7304 return 0;
7305
7306 /* Optimize ceil of constant value. */
7307 arg = TREE_VALUE (arglist);
7308 if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
7309 {
7310 REAL_VALUE_TYPE x;
7311
7312 x = TREE_REAL_CST (arg);
7313 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7314 {
7315 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7316 REAL_VALUE_TYPE r;
7317
7318 real_ceil (&r, TYPE_MODE (type), &x);
7319 return build_real (type, r);
7320 }
7321 }
7322
7323 return fold_trunc_transparent_mathfn (fndecl, arglist);
7324 }
7325
7326 /* Fold function call to builtin round, roundf or roundl. Return
7327 NULL_TREE if no simplification can be made. */
7328
7329 static tree
7330 fold_builtin_round (tree fndecl, tree arglist)
7331 {
7332 tree arg;
7333
7334 if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7335 return 0;
7336
7337 /* Optimize round of constant value. */
7338 arg = TREE_VALUE (arglist);
7339 if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
7340 {
7341 REAL_VALUE_TYPE x;
7342
7343 x = TREE_REAL_CST (arg);
7344 if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7345 {
7346 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7347 REAL_VALUE_TYPE r;
7348
7349 real_round (&r, TYPE_MODE (type), &x);
7350 return build_real (type, r);
7351 }
7352 }
7353
7354 return fold_trunc_transparent_mathfn (fndecl, arglist);
7355 }
7356
7357 /* Fold function call to builtin lround, lroundf or lroundl (or the
7358 corresponding long long versions) and other rounding functions.
7359 Return NULL_TREE if no simplification can be made. */
7360
7361 static tree
7362 fold_builtin_int_roundingfn (tree fndecl, tree arglist)
7363 {
7364 tree arg;
7365
7366 if (! validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7367 return 0;
7368
7369 /* Optimize lround of constant value. */
7370 arg = TREE_VALUE (arglist);
7371 if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
7372 {
7373 const REAL_VALUE_TYPE x = TREE_REAL_CST (arg);
7374
7375 if (! REAL_VALUE_ISNAN (x) && ! REAL_VALUE_ISINF (x))
7376 {
7377 tree itype = TREE_TYPE (TREE_TYPE (fndecl));
7378 tree ftype = TREE_TYPE (arg), result;
7379 HOST_WIDE_INT hi, lo;
7380 REAL_VALUE_TYPE r;
7381
7382 switch (DECL_FUNCTION_CODE (fndecl))
7383 {
7384 CASE_FLT_FN (BUILT_IN_LFLOOR):
7385 CASE_FLT_FN (BUILT_IN_LLFLOOR):
7386 real_floor (&r, TYPE_MODE (ftype), &x);
7387 break;
7388
7389 CASE_FLT_FN (BUILT_IN_LCEIL):
7390 CASE_FLT_FN (BUILT_IN_LLCEIL):
7391 real_ceil (&r, TYPE_MODE (ftype), &x);
7392 break;
7393
7394 CASE_FLT_FN (BUILT_IN_LROUND):
7395 CASE_FLT_FN (BUILT_IN_LLROUND):
7396 real_round (&r, TYPE_MODE (ftype), &x);
7397 break;
7398
7399 default:
7400 gcc_unreachable ();
7401 }
7402
7403 REAL_VALUE_TO_INT (&lo, &hi, r);
7404 result = build_int_cst_wide (NULL_TREE, lo, hi);
7405 if (int_fits_type_p (result, itype))
7406 return fold_convert (itype, result);
7407 }
7408 }
7409
7410 return fold_fixed_mathfn (fndecl, arglist);
7411 }
7412
7413 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
7414 and their long and long long variants (i.e. ffsl and ffsll).
7415 Return NULL_TREE if no simplification can be made. */
7416
7417 static tree
7418 fold_builtin_bitop (tree fndecl, tree arglist)
7419 {
7420 tree arg;
7421
7422 if (! validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
7423 return NULL_TREE;
7424
7425 /* Optimize for constant argument. */
7426 arg = TREE_VALUE (arglist);
7427 if (TREE_CODE (arg) == INTEGER_CST && ! TREE_CONSTANT_OVERFLOW (arg))
7428 {
7429 HOST_WIDE_INT hi, width, result;
7430 unsigned HOST_WIDE_INT lo;
7431 tree type;
7432
7433 type = TREE_TYPE (arg);
7434 width = TYPE_PRECISION (type);
7435 lo = TREE_INT_CST_LOW (arg);
7436
7437 /* Clear all the bits that are beyond the type's precision. */
7438 if (width > HOST_BITS_PER_WIDE_INT)
7439 {
7440 hi = TREE_INT_CST_HIGH (arg);
7441 if (width < 2 * HOST_BITS_PER_WIDE_INT)
7442 hi &= ~((HOST_WIDE_INT) (-1) >> (width - HOST_BITS_PER_WIDE_INT));
7443 }
7444 else
7445 {
7446 hi = 0;
7447 if (width < HOST_BITS_PER_WIDE_INT)
7448 lo &= ~((unsigned HOST_WIDE_INT) (-1) << width);
7449 }
7450
7451 switch (DECL_FUNCTION_CODE (fndecl))
7452 {
7453 CASE_INT_FN (BUILT_IN_FFS):
7454 if (lo != 0)
7455 result = exact_log2 (lo & -lo) + 1;
7456 else if (hi != 0)
7457 result = HOST_BITS_PER_WIDE_INT + exact_log2 (hi & -hi) + 1;
7458 else
7459 result = 0;
7460 break;
7461
7462 CASE_INT_FN (BUILT_IN_CLZ):
7463 if (hi != 0)
7464 result = width - floor_log2 (hi) - 1 - HOST_BITS_PER_WIDE_INT;
7465 else if (lo != 0)
7466 result = width - floor_log2 (lo) - 1;
7467 else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7468 result = width;
7469 break;
7470
7471 CASE_INT_FN (BUILT_IN_CTZ):
7472 if (lo != 0)
7473 result = exact_log2 (lo & -lo);
7474 else if (hi != 0)
7475 result = HOST_BITS_PER_WIDE_INT + exact_log2 (hi & -hi);
7476 else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7477 result = width;
7478 break;
7479
7480 CASE_INT_FN (BUILT_IN_POPCOUNT):
7481 result = 0;
7482 while (lo)
7483 result++, lo &= lo - 1;
7484 while (hi)
7485 result++, hi &= hi - 1;
7486 break;
7487
7488 CASE_INT_FN (BUILT_IN_PARITY):
7489 result = 0;
7490 while (lo)
7491 result++, lo &= lo - 1;
7492 while (hi)
7493 result++, hi &= hi - 1;
7494 result &= 1;
7495 break;
7496
7497 default:
7498 gcc_unreachable ();
7499 }
7500
7501 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), result);
7502 }
7503
7504 return NULL_TREE;
7505 }
7506
7507 /* Return true if EXPR is the real constant contained in VALUE. */
7508
7509 static bool
7510 real_dconstp (tree expr, const REAL_VALUE_TYPE *value)
7511 {
7512 STRIP_NOPS (expr);
7513
7514 return ((TREE_CODE (expr) == REAL_CST
7515 && ! TREE_CONSTANT_OVERFLOW (expr)
7516 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), *value))
7517 || (TREE_CODE (expr) == COMPLEX_CST
7518 && real_dconstp (TREE_REALPART (expr), value)
7519 && real_zerop (TREE_IMAGPART (expr))));
7520 }
7521
7522 /* A subroutine of fold_builtin to fold the various logarithmic
7523 functions. EXP is the CALL_EXPR of a call to a builtin logN
7524 function. VALUE is the base of the logN function. */
7525
7526 static tree
7527 fold_builtin_logarithm (tree fndecl, tree arglist,
7528 const REAL_VALUE_TYPE *value)
7529 {
7530 if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7531 {
7532 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7533 tree arg = TREE_VALUE (arglist);
7534 const enum built_in_function fcode = builtin_mathfn_code (arg);
7535
7536 /* Optimize logN(1.0) = 0.0. */
7537 if (real_onep (arg))
7538 return build_real (type, dconst0);
7539
7540 /* Optimize logN(N) = 1.0. If N can't be truncated to MODE
7541 exactly, then only do this if flag_unsafe_math_optimizations. */
7542 if (exact_real_truncate (TYPE_MODE (type), value)
7543 || flag_unsafe_math_optimizations)
7544 {
7545 const REAL_VALUE_TYPE value_truncate =
7546 real_value_truncate (TYPE_MODE (type), *value);
7547 if (real_dconstp (arg, &value_truncate))
7548 return build_real (type, dconst1);
7549 }
7550
7551 /* Special case, optimize logN(expN(x)) = x. */
7552 if (flag_unsafe_math_optimizations
7553 && ((value == &dconste
7554 && (fcode == BUILT_IN_EXP
7555 || fcode == BUILT_IN_EXPF
7556 || fcode == BUILT_IN_EXPL))
7557 || (value == &dconst2
7558 && (fcode == BUILT_IN_EXP2
7559 || fcode == BUILT_IN_EXP2F
7560 || fcode == BUILT_IN_EXP2L))
7561 || (value == &dconst10 && (BUILTIN_EXP10_P (fcode)))))
7562 return fold_convert (type, TREE_VALUE (TREE_OPERAND (arg, 1)));
7563
7564 /* Optimize logN(func()) for various exponential functions. We
7565 want to determine the value "x" and the power "exponent" in
7566 order to transform logN(x**exponent) into exponent*logN(x). */
7567 if (flag_unsafe_math_optimizations)
7568 {
7569 tree exponent = 0, x = 0;
7570
7571 switch (fcode)
7572 {
7573 CASE_FLT_FN (BUILT_IN_EXP):
7574 /* Prepare to do logN(exp(exponent) -> exponent*logN(e). */
7575 x = build_real (type,
7576 real_value_truncate (TYPE_MODE (type), dconste));
7577 exponent = TREE_VALUE (TREE_OPERAND (arg, 1));
7578 break;
7579 CASE_FLT_FN (BUILT_IN_EXP2):
7580 /* Prepare to do logN(exp2(exponent) -> exponent*logN(2). */
7581 x = build_real (type, dconst2);
7582 exponent = TREE_VALUE (TREE_OPERAND (arg, 1));
7583 break;
7584 CASE_FLT_FN (BUILT_IN_EXP10):
7585 CASE_FLT_FN (BUILT_IN_POW10):
7586 /* Prepare to do logN(exp10(exponent) -> exponent*logN(10). */
7587 x = build_real (type, dconst10);
7588 exponent = TREE_VALUE (TREE_OPERAND (arg, 1));
7589 break;
7590 CASE_FLT_FN (BUILT_IN_SQRT):
7591 /* Prepare to do logN(sqrt(x) -> 0.5*logN(x). */
7592 x = TREE_VALUE (TREE_OPERAND (arg, 1));
7593 exponent = build_real (type, dconsthalf);
7594 break;
7595 CASE_FLT_FN (BUILT_IN_CBRT):
7596 /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x). */
7597 x = TREE_VALUE (TREE_OPERAND (arg, 1));
7598 exponent = build_real (type, real_value_truncate (TYPE_MODE (type),
7599 dconstthird));
7600 break;
7601 CASE_FLT_FN (BUILT_IN_POW):
7602 /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x). */
7603 x = TREE_VALUE (TREE_OPERAND (arg, 1));
7604 exponent = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg, 1)));
7605 break;
7606 default:
7607 break;
7608 }
7609
7610 /* Now perform the optimization. */
7611 if (x && exponent)
7612 {
7613 tree logfn;
7614 arglist = build_tree_list (NULL_TREE, x);
7615 logfn = build_function_call_expr (fndecl, arglist);
7616 return fold_build2 (MULT_EXPR, type, exponent, logfn);
7617 }
7618 }
7619 }
7620
7621 return 0;
7622 }
7623
7624 /* Fold a builtin function call to pow, powf, or powl. Return
7625 NULL_TREE if no simplification can be made. */
7626 static tree
7627 fold_builtin_pow (tree fndecl, tree arglist, tree type)
7628 {
7629 tree arg0 = TREE_VALUE (arglist);
7630 tree arg1 = TREE_VALUE (TREE_CHAIN (arglist));
7631
7632 if (!validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
7633 return NULL_TREE;
7634
7635 /* Optimize pow(1.0,y) = 1.0. */
7636 if (real_onep (arg0))
7637 return omit_one_operand (type, build_real (type, dconst1), arg1);
7638
7639 if (TREE_CODE (arg1) == REAL_CST
7640 && ! TREE_CONSTANT_OVERFLOW (arg1))
7641 {
7642 REAL_VALUE_TYPE cint;
7643 REAL_VALUE_TYPE c;
7644 HOST_WIDE_INT n;
7645
7646 c = TREE_REAL_CST (arg1);
7647
7648 /* Optimize pow(x,0.0) = 1.0. */
7649 if (REAL_VALUES_EQUAL (c, dconst0))
7650 return omit_one_operand (type, build_real (type, dconst1),
7651 arg0);
7652
7653 /* Optimize pow(x,1.0) = x. */
7654 if (REAL_VALUES_EQUAL (c, dconst1))
7655 return arg0;
7656
7657 /* Optimize pow(x,-1.0) = 1.0/x. */
7658 if (REAL_VALUES_EQUAL (c, dconstm1))
7659 return fold_build2 (RDIV_EXPR, type,
7660 build_real (type, dconst1), arg0);
7661
7662 /* Optimize pow(x,0.5) = sqrt(x). */
7663 if (flag_unsafe_math_optimizations
7664 && REAL_VALUES_EQUAL (c, dconsthalf))
7665 {
7666 tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
7667
7668 if (sqrtfn != NULL_TREE)
7669 {
7670 tree arglist = build_tree_list (NULL_TREE, arg0);
7671 return build_function_call_expr (sqrtfn, arglist);
7672 }
7673 }
7674
7675 /* Check for an integer exponent. */
7676 n = real_to_integer (&c);
7677 real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
7678 if (real_identical (&c, &cint))
7679 {
7680 /* Attempt to evaluate pow at compile-time. */
7681 if (TREE_CODE (arg0) == REAL_CST
7682 && ! TREE_CONSTANT_OVERFLOW (arg0))
7683 {
7684 REAL_VALUE_TYPE x;
7685 bool inexact;
7686
7687 x = TREE_REAL_CST (arg0);
7688 inexact = real_powi (&x, TYPE_MODE (type), &x, n);
7689 if (flag_unsafe_math_optimizations || !inexact)
7690 return build_real (type, x);
7691 }
7692
7693 /* Strip sign ops from even integer powers. */
7694 if ((n & 1) == 0 && flag_unsafe_math_optimizations)
7695 {
7696 tree narg0 = fold_strip_sign_ops (arg0);
7697 if (narg0)
7698 {
7699 arglist = build_tree_list (NULL_TREE, arg1);
7700 arglist = tree_cons (NULL_TREE, narg0, arglist);
7701 return build_function_call_expr (fndecl, arglist);
7702 }
7703 }
7704 }
7705 }
7706
7707 if (flag_unsafe_math_optimizations)
7708 {
7709 const enum built_in_function fcode = builtin_mathfn_code (arg0);
7710
7711 /* Optimize pow(expN(x),y) = expN(x*y). */
7712 if (BUILTIN_EXPONENT_P (fcode))
7713 {
7714 tree expfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7715 tree arg = TREE_VALUE (TREE_OPERAND (arg0, 1));
7716 arg = fold_build2 (MULT_EXPR, type, arg, arg1);
7717 arglist = build_tree_list (NULL_TREE, arg);
7718 return build_function_call_expr (expfn, arglist);
7719 }
7720
7721 /* Optimize pow(sqrt(x),y) = pow(x,y*0.5). */
7722 if (BUILTIN_SQRT_P (fcode))
7723 {
7724 tree narg0 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7725 tree narg1 = fold_build2 (MULT_EXPR, type, arg1,
7726 build_real (type, dconsthalf));
7727
7728 arglist = tree_cons (NULL_TREE, narg0,
7729 build_tree_list (NULL_TREE, narg1));
7730 return build_function_call_expr (fndecl, arglist);
7731 }
7732
7733 /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative. */
7734 if (BUILTIN_CBRT_P (fcode))
7735 {
7736 tree arg = TREE_VALUE (TREE_OPERAND (arg0, 1));
7737 if (tree_expr_nonnegative_p (arg))
7738 {
7739 const REAL_VALUE_TYPE dconstroot
7740 = real_value_truncate (TYPE_MODE (type), dconstthird);
7741 tree narg1 = fold_build2 (MULT_EXPR, type, arg1,
7742 build_real (type, dconstroot));
7743 arglist = tree_cons (NULL_TREE, arg,
7744 build_tree_list (NULL_TREE, narg1));
7745 return build_function_call_expr (fndecl, arglist);
7746 }
7747 }
7748
7749 /* Optimize pow(pow(x,y),z) = pow(x,y*z). */
7750 if (fcode == BUILT_IN_POW || fcode == BUILT_IN_POWF
7751 || fcode == BUILT_IN_POWL)
7752 {
7753 tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7754 tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0, 1)));
7755 tree narg1 = fold_build2 (MULT_EXPR, type, arg01, arg1);
7756 arglist = tree_cons (NULL_TREE, arg00,
7757 build_tree_list (NULL_TREE, narg1));
7758 return build_function_call_expr (fndecl, arglist);
7759 }
7760 }
7761
7762 return NULL_TREE;
7763 }
7764
7765 /* Fold a builtin function call to powi, powif, or powil. Return
7766 NULL_TREE if no simplification can be made. */
7767 static tree
7768 fold_builtin_powi (tree fndecl ATTRIBUTE_UNUSED, tree arglist, tree type)
7769 {
7770 tree arg0 = TREE_VALUE (arglist);
7771 tree arg1 = TREE_VALUE (TREE_CHAIN (arglist));
7772
7773 if (!validate_arglist (arglist, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
7774 return NULL_TREE;
7775
7776 /* Optimize pow(1.0,y) = 1.0. */
7777 if (real_onep (arg0))
7778 return omit_one_operand (type, build_real (type, dconst1), arg1);
7779
7780 if (host_integerp (arg1, 0))
7781 {
7782 HOST_WIDE_INT c = TREE_INT_CST_LOW (arg1);
7783
7784 /* Evaluate powi at compile-time. */
7785 if (TREE_CODE (arg0) == REAL_CST
7786 && ! TREE_CONSTANT_OVERFLOW (arg0))
7787 {
7788 REAL_VALUE_TYPE x;
7789 x = TREE_REAL_CST (arg0);
7790 real_powi (&x, TYPE_MODE (type), &x, c);
7791 return build_real (type, x);
7792 }
7793
7794 /* Optimize pow(x,0) = 1.0. */
7795 if (c == 0)
7796 return omit_one_operand (type, build_real (type, dconst1),
7797 arg0);
7798
7799 /* Optimize pow(x,1) = x. */
7800 if (c == 1)
7801 return arg0;
7802
7803 /* Optimize pow(x,-1) = 1.0/x. */
7804 if (c == -1)
7805 return fold_build2 (RDIV_EXPR, type,
7806 build_real (type, dconst1), arg0);
7807 }
7808
7809 return NULL_TREE;
7810 }
7811
7812 /* A subroutine of fold_builtin to fold the various exponent
7813 functions. EXP is the CALL_EXPR of a call to a builtin function.
7814 VALUE is the value which will be raised to a power. */
7815
7816 static tree
7817 fold_builtin_exponent (tree fndecl, tree arglist,
7818 const REAL_VALUE_TYPE *value)
7819 {
7820 if (validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
7821 {
7822 tree type = TREE_TYPE (TREE_TYPE (fndecl));
7823 tree arg = TREE_VALUE (arglist);
7824
7825 /* Optimize exp*(0.0) = 1.0. */
7826 if (real_zerop (arg))
7827 return build_real (type, dconst1);
7828
7829 /* Optimize expN(1.0) = N. */
7830 if (real_onep (arg))
7831 {
7832 REAL_VALUE_TYPE cst;
7833
7834 real_convert (&cst, TYPE_MODE (type), value);
7835 return build_real (type, cst);
7836 }
7837
7838 /* Attempt to evaluate expN(integer) at compile-time. */
7839 if (flag_unsafe_math_optimizations
7840 && TREE_CODE (arg) == REAL_CST
7841 && ! TREE_CONSTANT_OVERFLOW (arg))
7842 {
7843 REAL_VALUE_TYPE cint;
7844 REAL_VALUE_TYPE c;
7845 HOST_WIDE_INT n;
7846
7847 c = TREE_REAL_CST (arg);
7848 n = real_to_integer (&c);
7849 real_from_integer (&cint, VOIDmode, n,
7850 n < 0 ? -1 : 0, 0);
7851 if (real_identical (&c, &cint))
7852 {
7853 REAL_VALUE_TYPE x;
7854
7855 real_powi (&x, TYPE_MODE (type), value, n);
7856 return build_real (type, x);
7857 }
7858 }
7859
7860 /* Optimize expN(logN(x)) = x. */
7861 if (flag_unsafe_math_optimizations)
7862 {
7863 const enum built_in_function fcode = builtin_mathfn_code (arg);
7864
7865 if ((value == &dconste
7866 && (fcode == BUILT_IN_LOG
7867 || fcode == BUILT_IN_LOGF
7868 || fcode == BUILT_IN_LOGL))
7869 || (value == &dconst2
7870 && (fcode == BUILT_IN_LOG2
7871 || fcode == BUILT_IN_LOG2F
7872 || fcode == BUILT_IN_LOG2L))
7873 || (value == &dconst10
7874 && (fcode == BUILT_IN_LOG10
7875 || fcode == BUILT_IN_LOG10F
7876 || fcode == BUILT_IN_LOG10L)))
7877 return fold_convert (type, TREE_VALUE (TREE_OPERAND (arg, 1)));
7878 }
7879 }
7880
7881 return 0;
7882 }
7883
7884 /* Fold function call to builtin memset. Return
7885 NULL_TREE if no simplification can be made. */
7886
7887 static tree
7888 fold_builtin_memset (tree arglist, tree type, bool ignore)
7889 {
7890 tree dest, c, len, var, ret;
7891 unsigned HOST_WIDE_INT length, cval;
7892
7893 if (!validate_arglist (arglist,
7894 POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
7895 return 0;
7896
7897 dest = TREE_VALUE (arglist);
7898 c = TREE_VALUE (TREE_CHAIN (arglist));
7899 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
7900
7901 if (! host_integerp (len, 1))
7902 return 0;
7903
7904 /* If the LEN parameter is zero, return DEST. */
7905 if (integer_zerop (len))
7906 return omit_one_operand (type, dest, c);
7907
7908 if (! host_integerp (c, 1) || TREE_SIDE_EFFECTS (dest))
7909 return 0;
7910
7911 var = dest;
7912 STRIP_NOPS (var);
7913 if (TREE_CODE (var) != ADDR_EXPR)
7914 return 0;
7915
7916 var = TREE_OPERAND (var, 0);
7917 if (TREE_THIS_VOLATILE (var))
7918 return 0;
7919
7920 if (!INTEGRAL_TYPE_P (TREE_TYPE (var))
7921 && !POINTER_TYPE_P (TREE_TYPE (var)))
7922 return 0;
7923
7924 length = tree_low_cst (len, 1);
7925 if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (var))) != length
7926 || get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT
7927 < (int) length)
7928 return 0;
7929
7930 if (length > HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT)
7931 return 0;
7932
7933 if (integer_zerop (c))
7934 cval = 0;
7935 else
7936 {
7937 if (CHAR_BIT != 8 || BITS_PER_UNIT != 8 || HOST_BITS_PER_WIDE_INT > 64)
7938 return 0;
7939
7940 cval = tree_low_cst (c, 1);
7941 cval &= 0xff;
7942 cval |= cval << 8;
7943 cval |= cval << 16;
7944 cval |= (cval << 31) << 1;
7945 }
7946
7947 ret = build_int_cst_type (TREE_TYPE (var), cval);
7948 ret = build2 (MODIFY_EXPR, TREE_TYPE (var), var, ret);
7949 if (ignore)
7950 return ret;
7951
7952 return omit_one_operand (type, dest, ret);
7953 }
7954
7955 /* Fold function call to builtin memset. Return
7956 NULL_TREE if no simplification can be made. */
7957
7958 static tree
7959 fold_builtin_bzero (tree arglist, bool ignore)
7960 {
7961 tree dest, size, newarglist;
7962
7963 if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
7964 return 0;
7965
7966 if (!ignore)
7967 return 0;
7968
7969 dest = TREE_VALUE (arglist);
7970 size = TREE_VALUE (TREE_CHAIN (arglist));
7971
7972 /* New argument list transforming bzero(ptr x, int y) to
7973 memset(ptr x, int 0, size_t y). This is done this way
7974 so that if it isn't expanded inline, we fallback to
7975 calling bzero instead of memset. */
7976
7977 newarglist = build_tree_list (NULL_TREE, fold_convert (sizetype, size));
7978 newarglist = tree_cons (NULL_TREE, integer_zero_node, newarglist);
7979 newarglist = tree_cons (NULL_TREE, dest, newarglist);
7980 return fold_builtin_memset (newarglist, void_type_node, ignore);
7981 }
7982
7983 /* Fold function call to builtin mem{{,p}cpy,move}. Return
7984 NULL_TREE if no simplification can be made.
7985 If ENDP is 0, return DEST (like memcpy).
7986 If ENDP is 1, return DEST+LEN (like mempcpy).
7987 If ENDP is 2, return DEST+LEN-1 (like stpcpy).
7988 If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap
7989 (memmove). */
7990
7991 static tree
7992 fold_builtin_memory_op (tree arglist, tree type, bool ignore, int endp)
7993 {
7994 tree dest, src, len, destvar, srcvar, expr;
7995 unsigned HOST_WIDE_INT length;
7996
7997 if (! validate_arglist (arglist,
7998 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
7999 return 0;
8000
8001 dest = TREE_VALUE (arglist);
8002 src = TREE_VALUE (TREE_CHAIN (arglist));
8003 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
8004
8005 /* If the LEN parameter is zero, return DEST. */
8006 if (integer_zerop (len))
8007 return omit_one_operand (type, dest, src);
8008
8009 /* If SRC and DEST are the same (and not volatile), return
8010 DEST{,+LEN,+LEN-1}. */
8011 if (operand_equal_p (src, dest, 0))
8012 expr = len;
8013 else
8014 {
8015 if (! host_integerp (len, 1))
8016 return 0;
8017
8018 if (TREE_SIDE_EFFECTS (dest) || TREE_SIDE_EFFECTS (src))
8019 return 0;
8020
8021 destvar = dest;
8022 STRIP_NOPS (destvar);
8023 if (TREE_CODE (destvar) != ADDR_EXPR)
8024 return 0;
8025
8026 destvar = TREE_OPERAND (destvar, 0);
8027 if (TREE_THIS_VOLATILE (destvar))
8028 return 0;
8029
8030 if (!INTEGRAL_TYPE_P (TREE_TYPE (destvar))
8031 && !POINTER_TYPE_P (TREE_TYPE (destvar))
8032 && !SCALAR_FLOAT_TYPE_P (TREE_TYPE (destvar)))
8033 return 0;
8034
8035 srcvar = src;
8036 STRIP_NOPS (srcvar);
8037 if (TREE_CODE (srcvar) != ADDR_EXPR)
8038 return 0;
8039
8040 srcvar = TREE_OPERAND (srcvar, 0);
8041 if (TREE_THIS_VOLATILE (srcvar))
8042 return 0;
8043
8044 if (!INTEGRAL_TYPE_P (TREE_TYPE (srcvar))
8045 && !POINTER_TYPE_P (TREE_TYPE (srcvar))
8046 && !SCALAR_FLOAT_TYPE_P (TREE_TYPE (srcvar)))
8047 return 0;
8048
8049 length = tree_low_cst (len, 1);
8050 if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (destvar))) != length
8051 || get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT
8052 < (int) length
8053 || GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (srcvar))) != length
8054 || get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT
8055 < (int) length)
8056 return 0;
8057
8058 if ((INTEGRAL_TYPE_P (TREE_TYPE (srcvar))
8059 || POINTER_TYPE_P (TREE_TYPE (srcvar)))
8060 && (INTEGRAL_TYPE_P (TREE_TYPE (destvar))
8061 || POINTER_TYPE_P (TREE_TYPE (destvar))))
8062 expr = fold_convert (TREE_TYPE (destvar), srcvar);
8063 else
8064 expr = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (destvar), srcvar);
8065 expr = build2 (MODIFY_EXPR, TREE_TYPE (destvar), destvar, expr);
8066 }
8067
8068 if (ignore)
8069 return expr;
8070
8071 if (endp == 0 || endp == 3)
8072 return omit_one_operand (type, dest, expr);
8073
8074 if (expr == len)
8075 expr = 0;
8076
8077 if (endp == 2)
8078 len = fold_build2 (MINUS_EXPR, TREE_TYPE (len), len,
8079 ssize_int (1));
8080
8081 len = fold_convert (TREE_TYPE (dest), len);
8082 dest = fold_build2 (PLUS_EXPR, TREE_TYPE (dest), dest, len);
8083 dest = fold_convert (type, dest);
8084 if (expr)
8085 dest = omit_one_operand (type, dest, expr);
8086 return dest;
8087 }
8088
8089 /* Fold function call to builtin bcopy. Return NULL_TREE if no
8090 simplification can be made. */
8091
8092 static tree
8093 fold_builtin_bcopy (tree arglist, bool ignore)
8094 {
8095 tree src, dest, size, newarglist;
8096
8097 if (!validate_arglist (arglist,
8098 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
8099 return 0;
8100
8101 if (! ignore)
8102 return 0;
8103
8104 src = TREE_VALUE (arglist);
8105 dest = TREE_VALUE (TREE_CHAIN (arglist));
8106 size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
8107
8108 /* New argument list transforming bcopy(ptr x, ptr y, int z) to
8109 memmove(ptr y, ptr x, size_t z). This is done this way
8110 so that if it isn't expanded inline, we fallback to
8111 calling bcopy instead of memmove. */
8112
8113 newarglist = build_tree_list (NULL_TREE, fold_convert (sizetype, size));
8114 newarglist = tree_cons (NULL_TREE, src, newarglist);
8115 newarglist = tree_cons (NULL_TREE, dest, newarglist);
8116
8117 return fold_builtin_memory_op (newarglist, void_type_node, true, /*endp=*/3);
8118 }
8119
8120 /* Fold function call to builtin strcpy. If LEN is not NULL, it represents
8121 the length of the string to be copied. Return NULL_TREE if no
8122 simplification can be made. */
8123
8124 tree
8125 fold_builtin_strcpy (tree fndecl, tree arglist, tree len)
8126 {
8127 tree dest, src, fn;
8128
8129 if (!validate_arglist (arglist,
8130 POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
8131 return 0;
8132
8133 dest = TREE_VALUE (arglist);
8134 src = TREE_VALUE (TREE_CHAIN (arglist));
8135
8136 /* If SRC and DEST are the same (and not volatile), return DEST. */
8137 if (operand_equal_p (src, dest, 0))
8138 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), dest);
8139
8140 if (optimize_size)
8141 return 0;
8142
8143 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8144 if (!fn)
8145 return 0;
8146
8147 if (!len)
8148 {
8149 len = c_strlen (src, 1);
8150 if (! len || TREE_SIDE_EFFECTS (len))
8151 return 0;
8152 }
8153
8154 len = size_binop (PLUS_EXPR, len, ssize_int (1));
8155 arglist = build_tree_list (NULL_TREE, len);
8156 arglist = tree_cons (NULL_TREE, src, arglist);
8157 arglist = tree_cons (NULL_TREE, dest, arglist);
8158 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)),
8159 build_function_call_expr (fn, arglist));
8160 }
8161
8162 /* Fold function call to builtin strncpy. If SLEN is not NULL, it represents
8163 the length of the source string. Return NULL_TREE if no simplification
8164 can be made. */
8165
8166 tree
8167 fold_builtin_strncpy (tree fndecl, tree arglist, tree slen)
8168 {
8169 tree dest, src, len, fn;
8170
8171 if (!validate_arglist (arglist,
8172 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
8173 return 0;
8174
8175 dest = TREE_VALUE (arglist);
8176 src = TREE_VALUE (TREE_CHAIN (arglist));
8177 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
8178
8179 /* If the LEN parameter is zero, return DEST. */
8180 if (integer_zerop (len))
8181 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
8182
8183 /* We can't compare slen with len as constants below if len is not a
8184 constant. */
8185 if (len == 0 || TREE_CODE (len) != INTEGER_CST)
8186 return 0;
8187
8188 if (!slen)
8189 slen = c_strlen (src, 1);
8190
8191 /* Now, we must be passed a constant src ptr parameter. */
8192 if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
8193 return 0;
8194
8195 slen = size_binop (PLUS_EXPR, slen, ssize_int (1));
8196
8197 /* We do not support simplification of this case, though we do
8198 support it when expanding trees into RTL. */
8199 /* FIXME: generate a call to __builtin_memset. */
8200 if (tree_int_cst_lt (slen, len))
8201 return 0;
8202
8203 /* OK transform into builtin memcpy. */
8204 fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8205 if (!fn)
8206 return 0;
8207 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)),
8208 build_function_call_expr (fn, arglist));
8209 }
8210
8211 /* Fold function call to builtin memcmp. Return
8212 NULL_TREE if no simplification can be made. */
8213
8214 static tree
8215 fold_builtin_memcmp (tree arglist)
8216 {
8217 tree arg1, arg2, len;
8218 const char *p1, *p2;
8219
8220 if (!validate_arglist (arglist,
8221 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
8222 return 0;
8223
8224 arg1 = TREE_VALUE (arglist);
8225 arg2 = TREE_VALUE (TREE_CHAIN (arglist));
8226 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
8227
8228 /* If the LEN parameter is zero, return zero. */
8229 if (integer_zerop (len))
8230 return omit_two_operands (integer_type_node, integer_zero_node,
8231 arg1, arg2);
8232
8233 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8234 if (operand_equal_p (arg1, arg2, 0))
8235 return omit_one_operand (integer_type_node, integer_zero_node, len);
8236
8237 p1 = c_getstr (arg1);
8238 p2 = c_getstr (arg2);
8239
8240 /* If all arguments are constant, and the value of len is not greater
8241 than the lengths of arg1 and arg2, evaluate at compile-time. */
8242 if (host_integerp (len, 1) && p1 && p2
8243 && compare_tree_int (len, strlen (p1) + 1) <= 0
8244 && compare_tree_int (len, strlen (p2) + 1) <= 0)
8245 {
8246 const int r = memcmp (p1, p2, tree_low_cst (len, 1));
8247
8248 if (r > 0)
8249 return integer_one_node;
8250 else if (r < 0)
8251 return integer_minus_one_node;
8252 else
8253 return integer_zero_node;
8254 }
8255
8256 /* If len parameter is one, return an expression corresponding to
8257 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
8258 if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
8259 {
8260 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8261 tree cst_uchar_ptr_node
8262 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8263
8264 tree ind1 = fold_convert (integer_type_node,
8265 build1 (INDIRECT_REF, cst_uchar_node,
8266 fold_convert (cst_uchar_ptr_node,
8267 arg1)));
8268 tree ind2 = fold_convert (integer_type_node,
8269 build1 (INDIRECT_REF, cst_uchar_node,
8270 fold_convert (cst_uchar_ptr_node,
8271 arg2)));
8272 return fold_build2 (MINUS_EXPR, integer_type_node, ind1, ind2);
8273 }
8274
8275 return 0;
8276 }
8277
8278 /* Fold function call to builtin strcmp. Return
8279 NULL_TREE if no simplification can be made. */
8280
8281 static tree
8282 fold_builtin_strcmp (tree arglist)
8283 {
8284 tree arg1, arg2;
8285 const char *p1, *p2;
8286
8287 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
8288 return 0;
8289
8290 arg1 = TREE_VALUE (arglist);
8291 arg2 = TREE_VALUE (TREE_CHAIN (arglist));
8292
8293 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8294 if (operand_equal_p (arg1, arg2, 0))
8295 return integer_zero_node;
8296
8297 p1 = c_getstr (arg1);
8298 p2 = c_getstr (arg2);
8299
8300 if (p1 && p2)
8301 {
8302 const int i = strcmp (p1, p2);
8303 if (i < 0)
8304 return integer_minus_one_node;
8305 else if (i > 0)
8306 return integer_one_node;
8307 else
8308 return integer_zero_node;
8309 }
8310
8311 /* If the second arg is "", return *(const unsigned char*)arg1. */
8312 if (p2 && *p2 == '\0')
8313 {
8314 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8315 tree cst_uchar_ptr_node
8316 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8317
8318 return fold_convert (integer_type_node,
8319 build1 (INDIRECT_REF, cst_uchar_node,
8320 fold_convert (cst_uchar_ptr_node,
8321 arg1)));
8322 }
8323
8324 /* If the first arg is "", return -*(const unsigned char*)arg2. */
8325 if (p1 && *p1 == '\0')
8326 {
8327 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8328 tree cst_uchar_ptr_node
8329 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8330
8331 tree temp = fold_convert (integer_type_node,
8332 build1 (INDIRECT_REF, cst_uchar_node,
8333 fold_convert (cst_uchar_ptr_node,
8334 arg2)));
8335 return fold_build1 (NEGATE_EXPR, integer_type_node, temp);
8336 }
8337
8338 return 0;
8339 }
8340
8341 /* Fold function call to builtin strncmp. Return
8342 NULL_TREE if no simplification can be made. */
8343
8344 static tree
8345 fold_builtin_strncmp (tree arglist)
8346 {
8347 tree arg1, arg2, len;
8348 const char *p1, *p2;
8349
8350 if (!validate_arglist (arglist,
8351 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
8352 return 0;
8353
8354 arg1 = TREE_VALUE (arglist);
8355 arg2 = TREE_VALUE (TREE_CHAIN (arglist));
8356 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
8357
8358 /* If the LEN parameter is zero, return zero. */
8359 if (integer_zerop (len))
8360 return omit_two_operands (integer_type_node, integer_zero_node,
8361 arg1, arg2);
8362
8363 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8364 if (operand_equal_p (arg1, arg2, 0))
8365 return omit_one_operand (integer_type_node, integer_zero_node, len);
8366
8367 p1 = c_getstr (arg1);
8368 p2 = c_getstr (arg2);
8369
8370 if (host_integerp (len, 1) && p1 && p2)
8371 {
8372 const int i = strncmp (p1, p2, tree_low_cst (len, 1));
8373 if (i > 0)
8374 return integer_one_node;
8375 else if (i < 0)
8376 return integer_minus_one_node;
8377 else
8378 return integer_zero_node;
8379 }
8380
8381 /* If the second arg is "", and the length is greater than zero,
8382 return *(const unsigned char*)arg1. */
8383 if (p2 && *p2 == '\0'
8384 && TREE_CODE (len) == INTEGER_CST
8385 && tree_int_cst_sgn (len) == 1)
8386 {
8387 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8388 tree cst_uchar_ptr_node
8389 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8390
8391 return fold_convert (integer_type_node,
8392 build1 (INDIRECT_REF, cst_uchar_node,
8393 fold_convert (cst_uchar_ptr_node,
8394 arg1)));
8395 }
8396
8397 /* If the first arg is "", and the length is greater than zero,
8398 return -*(const unsigned char*)arg2. */
8399 if (p1 && *p1 == '\0'
8400 && TREE_CODE (len) == INTEGER_CST
8401 && tree_int_cst_sgn (len) == 1)
8402 {
8403 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8404 tree cst_uchar_ptr_node
8405 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8406
8407 tree temp = fold_convert (integer_type_node,
8408 build1 (INDIRECT_REF, cst_uchar_node,
8409 fold_convert (cst_uchar_ptr_node,
8410 arg2)));
8411 return fold_build1 (NEGATE_EXPR, integer_type_node, temp);
8412 }
8413
8414 /* If len parameter is one, return an expression corresponding to
8415 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
8416 if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
8417 {
8418 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8419 tree cst_uchar_ptr_node
8420 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8421
8422 tree ind1 = fold_convert (integer_type_node,
8423 build1 (INDIRECT_REF, cst_uchar_node,
8424 fold_convert (cst_uchar_ptr_node,
8425 arg1)));
8426 tree ind2 = fold_convert (integer_type_node,
8427 build1 (INDIRECT_REF, cst_uchar_node,
8428 fold_convert (cst_uchar_ptr_node,
8429 arg2)));
8430 return fold_build2 (MINUS_EXPR, integer_type_node, ind1, ind2);
8431 }
8432
8433 return 0;
8434 }
8435
8436 /* Fold function call to builtin signbit, signbitf or signbitl. Return
8437 NULL_TREE if no simplification can be made. */
8438
8439 static tree
8440 fold_builtin_signbit (tree fndecl, tree arglist)
8441 {
8442 tree type = TREE_TYPE (TREE_TYPE (fndecl));
8443 tree arg, temp;
8444
8445 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
8446 return NULL_TREE;
8447
8448 arg = TREE_VALUE (arglist);
8449
8450 /* If ARG is a compile-time constant, determine the result. */
8451 if (TREE_CODE (arg) == REAL_CST
8452 && !TREE_CONSTANT_OVERFLOW (arg))
8453 {
8454 REAL_VALUE_TYPE c;
8455
8456 c = TREE_REAL_CST (arg);
8457 temp = REAL_VALUE_NEGATIVE (c) ? integer_one_node : integer_zero_node;
8458 return fold_convert (type, temp);
8459 }
8460
8461 /* If ARG is non-negative, the result is always zero. */
8462 if (tree_expr_nonnegative_p (arg))
8463 return omit_one_operand (type, integer_zero_node, arg);
8464
8465 /* If ARG's format doesn't have signed zeros, return "arg < 0.0". */
8466 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
8467 return fold_build2 (LT_EXPR, type, arg,
8468 build_real (TREE_TYPE (arg), dconst0));
8469
8470 return NULL_TREE;
8471 }
8472
8473 /* Fold function call to builtin copysign, copysignf or copysignl.
8474 Return NULL_TREE if no simplification can be made. */
8475
8476 static tree
8477 fold_builtin_copysign (tree fndecl, tree arglist, tree type)
8478 {
8479 tree arg1, arg2, tem;
8480
8481 if (!validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
8482 return NULL_TREE;
8483
8484 arg1 = TREE_VALUE (arglist);
8485 arg2 = TREE_VALUE (TREE_CHAIN (arglist));
8486
8487 /* copysign(X,X) is X. */
8488 if (operand_equal_p (arg1, arg2, 0))
8489 return fold_convert (type, arg1);
8490
8491 /* If ARG1 and ARG2 are compile-time constants, determine the result. */
8492 if (TREE_CODE (arg1) == REAL_CST
8493 && TREE_CODE (arg2) == REAL_CST
8494 && !TREE_CONSTANT_OVERFLOW (arg1)
8495 && !TREE_CONSTANT_OVERFLOW (arg2))
8496 {
8497 REAL_VALUE_TYPE c1, c2;
8498
8499 c1 = TREE_REAL_CST (arg1);
8500 c2 = TREE_REAL_CST (arg2);
8501 /* c1.sign := c2.sign. */
8502 real_copysign (&c1, &c2);
8503 return build_real (type, c1);
8504 }
8505
8506 /* copysign(X, Y) is fabs(X) when Y is always non-negative.
8507 Remember to evaluate Y for side-effects. */
8508 if (tree_expr_nonnegative_p (arg2))
8509 return omit_one_operand (type,
8510 fold_build1 (ABS_EXPR, type, arg1),
8511 arg2);
8512
8513 /* Strip sign changing operations for the first argument. */
8514 tem = fold_strip_sign_ops (arg1);
8515 if (tem)
8516 {
8517 arglist = tree_cons (NULL_TREE, tem, TREE_CHAIN (arglist));
8518 return build_function_call_expr (fndecl, arglist);
8519 }
8520
8521 return NULL_TREE;
8522 }
8523
8524 /* Fold a call to builtin isascii. */
8525
8526 static tree
8527 fold_builtin_isascii (tree arglist)
8528 {
8529 if (! validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
8530 return 0;
8531 else
8532 {
8533 /* Transform isascii(c) -> ((c & ~0x7f) == 0). */
8534 tree arg = TREE_VALUE (arglist);
8535
8536 arg = build2 (BIT_AND_EXPR, integer_type_node, arg,
8537 build_int_cst (NULL_TREE,
8538 ~ (unsigned HOST_WIDE_INT) 0x7f));
8539 arg = fold_build2 (EQ_EXPR, integer_type_node,
8540 arg, integer_zero_node);
8541
8542 if (in_gimple_form && !TREE_CONSTANT (arg))
8543 return NULL_TREE;
8544 else
8545 return arg;
8546 }
8547 }
8548
8549 /* Fold a call to builtin toascii. */
8550
8551 static tree
8552 fold_builtin_toascii (tree arglist)
8553 {
8554 if (! validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
8555 return 0;
8556 else
8557 {
8558 /* Transform toascii(c) -> (c & 0x7f). */
8559 tree arg = TREE_VALUE (arglist);
8560
8561 return fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
8562 build_int_cst (NULL_TREE, 0x7f));
8563 }
8564 }
8565
8566 /* Fold a call to builtin isdigit. */
8567
8568 static tree
8569 fold_builtin_isdigit (tree arglist)
8570 {
8571 if (! validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
8572 return 0;
8573 else
8574 {
8575 /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
8576 /* According to the C standard, isdigit is unaffected by locale.
8577 However, it definitely is affected by the target character set. */
8578 tree arg;
8579 unsigned HOST_WIDE_INT target_digit0
8580 = lang_hooks.to_target_charset ('0');
8581
8582 if (target_digit0 == 0)
8583 return NULL_TREE;
8584
8585 arg = fold_convert (unsigned_type_node, TREE_VALUE (arglist));
8586 arg = build2 (MINUS_EXPR, unsigned_type_node, arg,
8587 build_int_cst (unsigned_type_node, target_digit0));
8588 arg = fold_build2 (LE_EXPR, integer_type_node, arg,
8589 build_int_cst (unsigned_type_node, 9));
8590 if (in_gimple_form && !TREE_CONSTANT (arg))
8591 return NULL_TREE;
8592 else
8593 return arg;
8594 }
8595 }
8596
8597 /* Fold a call to fabs, fabsf or fabsl. */
8598
8599 static tree
8600 fold_builtin_fabs (tree arglist, tree type)
8601 {
8602 tree arg;
8603
8604 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
8605 return 0;
8606
8607 arg = TREE_VALUE (arglist);
8608 arg = fold_convert (type, arg);
8609 if (TREE_CODE (arg) == REAL_CST)
8610 return fold_abs_const (arg, type);
8611 return fold_build1 (ABS_EXPR, type, arg);
8612 }
8613
8614 /* Fold a call to abs, labs, llabs or imaxabs. */
8615
8616 static tree
8617 fold_builtin_abs (tree arglist, tree type)
8618 {
8619 tree arg;
8620
8621 if (!validate_arglist (arglist, INTEGER_TYPE, VOID_TYPE))
8622 return 0;
8623
8624 arg = TREE_VALUE (arglist);
8625 arg = fold_convert (type, arg);
8626 if (TREE_CODE (arg) == INTEGER_CST)
8627 return fold_abs_const (arg, type);
8628 return fold_build1 (ABS_EXPR, type, arg);
8629 }
8630
8631 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
8632 EXP is the CALL_EXPR for the call. */
8633
8634 static tree
8635 fold_builtin_classify (tree fndecl, tree arglist, int builtin_index)
8636 {
8637 tree type = TREE_TYPE (TREE_TYPE (fndecl));
8638 tree arg;
8639 REAL_VALUE_TYPE r;
8640
8641 if (!validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
8642 {
8643 /* Check that we have exactly one argument. */
8644 if (arglist == 0)
8645 {
8646 error ("too few arguments to function %qs",
8647 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
8648 return error_mark_node;
8649 }
8650 else if (TREE_CHAIN (arglist) != 0)
8651 {
8652 error ("too many arguments to function %qs",
8653 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
8654 return error_mark_node;
8655 }
8656 else
8657 {
8658 error ("non-floating-point argument to function %qs",
8659 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
8660 return error_mark_node;
8661 }
8662 }
8663
8664 arg = TREE_VALUE (arglist);
8665 switch (builtin_index)
8666 {
8667 case BUILT_IN_ISINF:
8668 if (!MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
8669 return omit_one_operand (type, integer_zero_node, arg);
8670
8671 if (TREE_CODE (arg) == REAL_CST)
8672 {
8673 r = TREE_REAL_CST (arg);
8674 if (real_isinf (&r))
8675 return real_compare (GT_EXPR, &r, &dconst0)
8676 ? integer_one_node : integer_minus_one_node;
8677 else
8678 return integer_zero_node;
8679 }
8680
8681 return NULL_TREE;
8682
8683 case BUILT_IN_FINITE:
8684 if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg)))
8685 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
8686 return omit_one_operand (type, integer_zero_node, arg);
8687
8688 if (TREE_CODE (arg) == REAL_CST)
8689 {
8690 r = TREE_REAL_CST (arg);
8691 return real_isinf (&r) || real_isnan (&r)
8692 ? integer_zero_node : integer_one_node;
8693 }
8694
8695 return NULL_TREE;
8696
8697 case BUILT_IN_ISNAN:
8698 if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg))))
8699 return omit_one_operand (type, integer_zero_node, arg);
8700
8701 if (TREE_CODE (arg) == REAL_CST)
8702 {
8703 r = TREE_REAL_CST (arg);
8704 return real_isnan (&r) ? integer_one_node : integer_zero_node;
8705 }
8706
8707 arg = builtin_save_expr (arg);
8708 return fold_build2 (UNORDERED_EXPR, type, arg, arg);
8709
8710 default:
8711 gcc_unreachable ();
8712 }
8713 }
8714
8715 /* Fold a call to an unordered comparison function such as
8716 __builtin_isgreater(). FNDECL is the FUNCTION_DECL for the function
8717 being called and ARGLIST is the argument list for the call.
8718 UNORDERED_CODE and ORDERED_CODE are comparison codes that give
8719 the opposite of the desired result. UNORDERED_CODE is used
8720 for modes that can hold NaNs and ORDERED_CODE is used for
8721 the rest. */
8722
8723 static tree
8724 fold_builtin_unordered_cmp (tree fndecl, tree arglist,
8725 enum tree_code unordered_code,
8726 enum tree_code ordered_code)
8727 {
8728 tree type = TREE_TYPE (TREE_TYPE (fndecl));
8729 enum tree_code code;
8730 tree arg0, arg1;
8731 tree type0, type1;
8732 enum tree_code code0, code1;
8733 tree cmp_type = NULL_TREE;
8734
8735 if (!validate_arglist (arglist, REAL_TYPE, REAL_TYPE, VOID_TYPE))
8736 {
8737 /* Check that we have exactly two arguments. */
8738 if (arglist == 0 || TREE_CHAIN (arglist) == 0)
8739 {
8740 error ("too few arguments to function %qs",
8741 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
8742 return error_mark_node;
8743 }
8744 else if (TREE_CHAIN (TREE_CHAIN (arglist)) != 0)
8745 {
8746 error ("too many arguments to function %qs",
8747 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
8748 return error_mark_node;
8749 }
8750 }
8751
8752 arg0 = TREE_VALUE (arglist);
8753 arg1 = TREE_VALUE (TREE_CHAIN (arglist));
8754
8755 type0 = TREE_TYPE (arg0);
8756 type1 = TREE_TYPE (arg1);
8757
8758 code0 = TREE_CODE (type0);
8759 code1 = TREE_CODE (type1);
8760
8761 if (code0 == REAL_TYPE && code1 == REAL_TYPE)
8762 /* Choose the wider of two real types. */
8763 cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
8764 ? type0 : type1;
8765 else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
8766 cmp_type = type0;
8767 else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
8768 cmp_type = type1;
8769 else
8770 {
8771 error ("non-floating-point argument to function %qs",
8772 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
8773 return error_mark_node;
8774 }
8775
8776 arg0 = fold_convert (cmp_type, arg0);
8777 arg1 = fold_convert (cmp_type, arg1);
8778
8779 if (unordered_code == UNORDERED_EXPR)
8780 {
8781 if (!MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8782 return omit_two_operands (type, integer_zero_node, arg0, arg1);
8783 return fold_build2 (UNORDERED_EXPR, type, arg0, arg1);
8784 }
8785
8786 code = MODE_HAS_NANS (TYPE_MODE (TREE_TYPE (arg0))) ? unordered_code
8787 : ordered_code;
8788 return fold_build1 (TRUTH_NOT_EXPR, type,
8789 fold_build2 (code, type, arg0, arg1));
8790 }
8791
8792 /* Used by constant folding to simplify calls to builtin functions. EXP is
8793 the CALL_EXPR of a call to a builtin function. IGNORE is true if the
8794 result of the function call is ignored. This function returns NULL_TREE
8795 if no simplification was possible. */
8796
8797 static tree
8798 fold_builtin_1 (tree fndecl, tree arglist, bool ignore)
8799 {
8800 tree type = TREE_TYPE (TREE_TYPE (fndecl));
8801 enum built_in_function fcode;
8802
8803 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
8804 return targetm.fold_builtin (fndecl, arglist, ignore);
8805
8806 fcode = DECL_FUNCTION_CODE (fndecl);
8807 switch (fcode)
8808 {
8809 case BUILT_IN_FPUTS:
8810 return fold_builtin_fputs (arglist, ignore, false, NULL_TREE);
8811
8812 case BUILT_IN_FPUTS_UNLOCKED:
8813 return fold_builtin_fputs (arglist, ignore, true, NULL_TREE);
8814
8815 case BUILT_IN_STRSTR:
8816 return fold_builtin_strstr (arglist, type);
8817
8818 case BUILT_IN_STRCAT:
8819 return fold_builtin_strcat (arglist);
8820
8821 case BUILT_IN_STRNCAT:
8822 return fold_builtin_strncat (arglist);
8823
8824 case BUILT_IN_STRSPN:
8825 return fold_builtin_strspn (arglist);
8826
8827 case BUILT_IN_STRCSPN:
8828 return fold_builtin_strcspn (arglist);
8829
8830 case BUILT_IN_STRCHR:
8831 case BUILT_IN_INDEX:
8832 return fold_builtin_strchr (arglist, type);
8833
8834 case BUILT_IN_STRRCHR:
8835 case BUILT_IN_RINDEX:
8836 return fold_builtin_strrchr (arglist, type);
8837
8838 case BUILT_IN_STRCPY:
8839 return fold_builtin_strcpy (fndecl, arglist, NULL_TREE);
8840
8841 case BUILT_IN_STRNCPY:
8842 return fold_builtin_strncpy (fndecl, arglist, NULL_TREE);
8843
8844 case BUILT_IN_STRCMP:
8845 return fold_builtin_strcmp (arglist);
8846
8847 case BUILT_IN_STRNCMP:
8848 return fold_builtin_strncmp (arglist);
8849
8850 case BUILT_IN_STRPBRK:
8851 return fold_builtin_strpbrk (arglist, type);
8852
8853 case BUILT_IN_BCMP:
8854 case BUILT_IN_MEMCMP:
8855 return fold_builtin_memcmp (arglist);
8856
8857 case BUILT_IN_SPRINTF:
8858 return fold_builtin_sprintf (arglist, ignore);
8859
8860 case BUILT_IN_CONSTANT_P:
8861 {
8862 tree val;
8863
8864 val = fold_builtin_constant_p (arglist);
8865 /* Gimplification will pull the CALL_EXPR for the builtin out of
8866 an if condition. When not optimizing, we'll not CSE it back.
8867 To avoid link error types of regressions, return false now. */
8868 if (!val && !optimize)
8869 val = integer_zero_node;
8870
8871 return val;
8872 }
8873
8874 case BUILT_IN_EXPECT:
8875 return fold_builtin_expect (arglist);
8876
8877 case BUILT_IN_CLASSIFY_TYPE:
8878 return fold_builtin_classify_type (arglist);
8879
8880 case BUILT_IN_STRLEN:
8881 return fold_builtin_strlen (arglist);
8882
8883 CASE_FLT_FN (BUILT_IN_FABS):
8884 return fold_builtin_fabs (arglist, type);
8885
8886 case BUILT_IN_ABS:
8887 case BUILT_IN_LABS:
8888 case BUILT_IN_LLABS:
8889 case BUILT_IN_IMAXABS:
8890 return fold_builtin_abs (arglist, type);
8891
8892 CASE_FLT_FN (BUILT_IN_CONJ):
8893 if (validate_arglist (arglist, COMPLEX_TYPE, VOID_TYPE))
8894 return fold_build1 (CONJ_EXPR, type, TREE_VALUE (arglist));
8895 break;
8896
8897 CASE_FLT_FN (BUILT_IN_CREAL):
8898 if (validate_arglist (arglist, COMPLEX_TYPE, VOID_TYPE))
8899 return non_lvalue (fold_build1 (REALPART_EXPR, type,
8900 TREE_VALUE (arglist)));
8901 break;
8902
8903 CASE_FLT_FN (BUILT_IN_CIMAG):
8904 if (validate_arglist (arglist, COMPLEX_TYPE, VOID_TYPE))
8905 return non_lvalue (fold_build1 (IMAGPART_EXPR, type,
8906 TREE_VALUE (arglist)));
8907 break;
8908
8909 CASE_FLT_FN (BUILT_IN_CABS):
8910 return fold_builtin_cabs (arglist, type, fndecl);
8911
8912 CASE_FLT_FN (BUILT_IN_SQRT):
8913 return fold_builtin_sqrt (arglist, type);
8914
8915 CASE_FLT_FN (BUILT_IN_CBRT):
8916 return fold_builtin_cbrt (arglist, type);
8917
8918 CASE_FLT_FN (BUILT_IN_SIN):
8919 return fold_builtin_sin (arglist);
8920
8921 CASE_FLT_FN (BUILT_IN_COS):
8922 return fold_builtin_cos (arglist, type, fndecl);
8923
8924 CASE_FLT_FN (BUILT_IN_EXP):
8925 return fold_builtin_exponent (fndecl, arglist, &dconste);
8926
8927 CASE_FLT_FN (BUILT_IN_EXP2):
8928 return fold_builtin_exponent (fndecl, arglist, &dconst2);
8929
8930 CASE_FLT_FN (BUILT_IN_EXP10):
8931 CASE_FLT_FN (BUILT_IN_POW10):
8932 return fold_builtin_exponent (fndecl, arglist, &dconst10);
8933
8934 CASE_FLT_FN (BUILT_IN_LOG):
8935 return fold_builtin_logarithm (fndecl, arglist, &dconste);
8936
8937 CASE_FLT_FN (BUILT_IN_LOG2):
8938 return fold_builtin_logarithm (fndecl, arglist, &dconst2);
8939
8940 CASE_FLT_FN (BUILT_IN_LOG10):
8941 return fold_builtin_logarithm (fndecl, arglist, &dconst10);
8942
8943 CASE_FLT_FN (BUILT_IN_TAN):
8944 return fold_builtin_tan (arglist);
8945
8946 CASE_FLT_FN (BUILT_IN_ATAN):
8947 return fold_builtin_atan (arglist, type);
8948
8949 CASE_FLT_FN (BUILT_IN_POW):
8950 return fold_builtin_pow (fndecl, arglist, type);
8951
8952 CASE_FLT_FN (BUILT_IN_POWI):
8953 return fold_builtin_powi (fndecl, arglist, type);
8954
8955 CASE_FLT_FN (BUILT_IN_INF):
8956 case BUILT_IN_INFD32:
8957 case BUILT_IN_INFD64:
8958 case BUILT_IN_INFD128:
8959 return fold_builtin_inf (type, true);
8960
8961 CASE_FLT_FN (BUILT_IN_HUGE_VAL):
8962 return fold_builtin_inf (type, false);
8963
8964 CASE_FLT_FN (BUILT_IN_NAN):
8965 case BUILT_IN_NAND32:
8966 case BUILT_IN_NAND64:
8967 case BUILT_IN_NAND128:
8968 return fold_builtin_nan (arglist, type, true);
8969
8970 CASE_FLT_FN (BUILT_IN_NANS):
8971 return fold_builtin_nan (arglist, type, false);
8972
8973 CASE_FLT_FN (BUILT_IN_FLOOR):
8974 return fold_builtin_floor (fndecl, arglist);
8975
8976 CASE_FLT_FN (BUILT_IN_CEIL):
8977 return fold_builtin_ceil (fndecl, arglist);
8978
8979 CASE_FLT_FN (BUILT_IN_TRUNC):
8980 return fold_builtin_trunc (fndecl, arglist);
8981
8982 CASE_FLT_FN (BUILT_IN_ROUND):
8983 return fold_builtin_round (fndecl, arglist);
8984
8985 CASE_FLT_FN (BUILT_IN_NEARBYINT):
8986 CASE_FLT_FN (BUILT_IN_RINT):
8987 return fold_trunc_transparent_mathfn (fndecl, arglist);
8988
8989 CASE_FLT_FN (BUILT_IN_LCEIL):
8990 CASE_FLT_FN (BUILT_IN_LLCEIL):
8991 CASE_FLT_FN (BUILT_IN_LFLOOR):
8992 CASE_FLT_FN (BUILT_IN_LLFLOOR):
8993 CASE_FLT_FN (BUILT_IN_LROUND):
8994 CASE_FLT_FN (BUILT_IN_LLROUND):
8995 return fold_builtin_int_roundingfn (fndecl, arglist);
8996
8997 CASE_FLT_FN (BUILT_IN_LRINT):
8998 CASE_FLT_FN (BUILT_IN_LLRINT):
8999 return fold_fixed_mathfn (fndecl, arglist);
9000
9001 CASE_INT_FN (BUILT_IN_FFS):
9002 CASE_INT_FN (BUILT_IN_CLZ):
9003 CASE_INT_FN (BUILT_IN_CTZ):
9004 CASE_INT_FN (BUILT_IN_POPCOUNT):
9005 CASE_INT_FN (BUILT_IN_PARITY):
9006 return fold_builtin_bitop (fndecl, arglist);
9007
9008 case BUILT_IN_MEMSET:
9009 return fold_builtin_memset (arglist, type, ignore);
9010
9011 case BUILT_IN_MEMCPY:
9012 return fold_builtin_memory_op (arglist, type, ignore, /*endp=*/0);
9013
9014 case BUILT_IN_MEMPCPY:
9015 return fold_builtin_memory_op (arglist, type, ignore, /*endp=*/1);
9016
9017 case BUILT_IN_MEMMOVE:
9018 return fold_builtin_memory_op (arglist, type, ignore, /*endp=*/3);
9019
9020 case BUILT_IN_BZERO:
9021 return fold_builtin_bzero (arglist, ignore);
9022
9023 case BUILT_IN_BCOPY:
9024 return fold_builtin_bcopy (arglist, ignore);
9025
9026 CASE_FLT_FN (BUILT_IN_SIGNBIT):
9027 return fold_builtin_signbit (fndecl, arglist);
9028
9029 case BUILT_IN_ISASCII:
9030 return fold_builtin_isascii (arglist);
9031
9032 case BUILT_IN_TOASCII:
9033 return fold_builtin_toascii (arglist);
9034
9035 case BUILT_IN_ISDIGIT:
9036 return fold_builtin_isdigit (arglist);
9037
9038 CASE_FLT_FN (BUILT_IN_COPYSIGN):
9039 return fold_builtin_copysign (fndecl, arglist, type);
9040
9041 CASE_FLT_FN (BUILT_IN_FINITE):
9042 case BUILT_IN_FINITED32:
9043 case BUILT_IN_FINITED64:
9044 case BUILT_IN_FINITED128:
9045 return fold_builtin_classify (fndecl, arglist, BUILT_IN_FINITE);
9046
9047 CASE_FLT_FN (BUILT_IN_ISINF):
9048 case BUILT_IN_ISINFD32:
9049 case BUILT_IN_ISINFD64:
9050 case BUILT_IN_ISINFD128:
9051 return fold_builtin_classify (fndecl, arglist, BUILT_IN_ISINF);
9052
9053 CASE_FLT_FN (BUILT_IN_ISNAN):
9054 case BUILT_IN_ISNAND32:
9055 case BUILT_IN_ISNAND64:
9056 case BUILT_IN_ISNAND128:
9057 return fold_builtin_classify (fndecl, arglist, BUILT_IN_ISNAN);
9058
9059 case BUILT_IN_ISGREATER:
9060 return fold_builtin_unordered_cmp (fndecl, arglist, UNLE_EXPR, LE_EXPR);
9061 case BUILT_IN_ISGREATEREQUAL:
9062 return fold_builtin_unordered_cmp (fndecl, arglist, UNLT_EXPR, LT_EXPR);
9063 case BUILT_IN_ISLESS:
9064 return fold_builtin_unordered_cmp (fndecl, arglist, UNGE_EXPR, GE_EXPR);
9065 case BUILT_IN_ISLESSEQUAL:
9066 return fold_builtin_unordered_cmp (fndecl, arglist, UNGT_EXPR, GT_EXPR);
9067 case BUILT_IN_ISLESSGREATER:
9068 return fold_builtin_unordered_cmp (fndecl, arglist, UNEQ_EXPR, EQ_EXPR);
9069 case BUILT_IN_ISUNORDERED:
9070 return fold_builtin_unordered_cmp (fndecl, arglist, UNORDERED_EXPR,
9071 NOP_EXPR);
9072
9073 /* We do the folding for va_start in the expander. */
9074 case BUILT_IN_VA_START:
9075 break;
9076
9077 case BUILT_IN_OBJECT_SIZE:
9078 return fold_builtin_object_size (arglist);
9079 case BUILT_IN_MEMCPY_CHK:
9080 case BUILT_IN_MEMPCPY_CHK:
9081 case BUILT_IN_MEMMOVE_CHK:
9082 case BUILT_IN_MEMSET_CHK:
9083 return fold_builtin_memory_chk (fndecl, arglist, NULL_TREE, ignore,
9084 DECL_FUNCTION_CODE (fndecl));
9085 case BUILT_IN_STRCPY_CHK:
9086 case BUILT_IN_STPCPY_CHK:
9087 return fold_builtin_stxcpy_chk (fndecl, arglist, NULL_TREE, ignore,
9088 DECL_FUNCTION_CODE (fndecl));
9089 case BUILT_IN_STRNCPY_CHK:
9090 return fold_builtin_strncpy_chk (arglist, NULL_TREE);
9091 case BUILT_IN_STRCAT_CHK:
9092 return fold_builtin_strcat_chk (fndecl, arglist);
9093 case BUILT_IN_STRNCAT_CHK:
9094 return fold_builtin_strncat_chk (fndecl, arglist);
9095 case BUILT_IN_SPRINTF_CHK:
9096 case BUILT_IN_VSPRINTF_CHK:
9097 return fold_builtin_sprintf_chk (arglist, DECL_FUNCTION_CODE (fndecl));
9098 case BUILT_IN_SNPRINTF_CHK:
9099 case BUILT_IN_VSNPRINTF_CHK:
9100 return fold_builtin_snprintf_chk (arglist, NULL_TREE,
9101 DECL_FUNCTION_CODE (fndecl));
9102
9103 case BUILT_IN_PRINTF:
9104 case BUILT_IN_PRINTF_UNLOCKED:
9105 case BUILT_IN_VPRINTF:
9106 case BUILT_IN_PRINTF_CHK:
9107 case BUILT_IN_VPRINTF_CHK:
9108 return fold_builtin_printf (fndecl, arglist, ignore,
9109 DECL_FUNCTION_CODE (fndecl));
9110
9111 case BUILT_IN_FPRINTF:
9112 case BUILT_IN_FPRINTF_UNLOCKED:
9113 case BUILT_IN_VFPRINTF:
9114 case BUILT_IN_FPRINTF_CHK:
9115 case BUILT_IN_VFPRINTF_CHK:
9116 return fold_builtin_fprintf (fndecl, arglist, ignore,
9117 DECL_FUNCTION_CODE (fndecl));
9118
9119 default:
9120 break;
9121 }
9122
9123 return 0;
9124 }
9125
9126 /* A wrapper function for builtin folding that prevents warnings for
9127 "statement without effect" and the like, caused by removing the
9128 call node earlier than the warning is generated. */
9129
9130 tree
9131 fold_builtin (tree fndecl, tree arglist, bool ignore)
9132 {
9133 tree exp = fold_builtin_1 (fndecl, arglist, ignore);
9134 if (exp)
9135 {
9136 exp = build1 (NOP_EXPR, TREE_TYPE (exp), exp);
9137 TREE_NO_WARNING (exp) = 1;
9138 }
9139
9140 return exp;
9141 }
9142
9143 /* Conveniently construct a function call expression. */
9144
9145 tree
9146 build_function_call_expr (tree fn, tree arglist)
9147 {
9148 tree call_expr;
9149
9150 call_expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
9151 return fold_build3 (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
9152 call_expr, arglist, NULL_TREE);
9153 }
9154
9155 /* This function validates the types of a function call argument list
9156 represented as a tree chain of parameters against a specified list
9157 of tree_codes. If the last specifier is a 0, that represents an
9158 ellipses, otherwise the last specifier must be a VOID_TYPE. */
9159
9160 static int
9161 validate_arglist (tree arglist, ...)
9162 {
9163 enum tree_code code;
9164 int res = 0;
9165 va_list ap;
9166
9167 va_start (ap, arglist);
9168
9169 do
9170 {
9171 code = va_arg (ap, enum tree_code);
9172 switch (code)
9173 {
9174 case 0:
9175 /* This signifies an ellipses, any further arguments are all ok. */
9176 res = 1;
9177 goto end;
9178 case VOID_TYPE:
9179 /* This signifies an endlink, if no arguments remain, return
9180 true, otherwise return false. */
9181 res = arglist == 0;
9182 goto end;
9183 default:
9184 /* If no parameters remain or the parameter's code does not
9185 match the specified code, return false. Otherwise continue
9186 checking any remaining arguments. */
9187 if (arglist == 0)
9188 goto end;
9189 if (code == POINTER_TYPE)
9190 {
9191 if (! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist))))
9192 goto end;
9193 }
9194 else if (code != TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))))
9195 goto end;
9196 break;
9197 }
9198 arglist = TREE_CHAIN (arglist);
9199 }
9200 while (1);
9201
9202 /* We need gotos here since we can only have one VA_CLOSE in a
9203 function. */
9204 end: ;
9205 va_end (ap);
9206
9207 return res;
9208 }
9209
9210 /* Default target-specific builtin expander that does nothing. */
9211
9212 rtx
9213 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
9214 rtx target ATTRIBUTE_UNUSED,
9215 rtx subtarget ATTRIBUTE_UNUSED,
9216 enum machine_mode mode ATTRIBUTE_UNUSED,
9217 int ignore ATTRIBUTE_UNUSED)
9218 {
9219 return NULL_RTX;
9220 }
9221
9222 /* Returns true is EXP represents data that would potentially reside
9223 in a readonly section. */
9224
9225 static bool
9226 readonly_data_expr (tree exp)
9227 {
9228 STRIP_NOPS (exp);
9229
9230 if (TREE_CODE (exp) != ADDR_EXPR)
9231 return false;
9232
9233 exp = get_base_address (TREE_OPERAND (exp, 0));
9234 if (!exp)
9235 return false;
9236
9237 /* Make sure we call decl_readonly_section only for trees it
9238 can handle (since it returns true for everything it doesn't
9239 understand). */
9240 if (TREE_CODE (exp) == STRING_CST
9241 || TREE_CODE (exp) == CONSTRUCTOR
9242 || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp)))
9243 return decl_readonly_section (exp, 0);
9244 else
9245 return false;
9246 }
9247
9248 /* Simplify a call to the strstr builtin.
9249
9250 Return 0 if no simplification was possible, otherwise return the
9251 simplified form of the call as a tree.
9252
9253 The simplified form may be a constant or other expression which
9254 computes the same value, but in a more efficient manner (including
9255 calls to other builtin functions).
9256
9257 The call may contain arguments which need to be evaluated, but
9258 which are not useful to determine the result of the call. In
9259 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9260 COMPOUND_EXPR will be an argument which must be evaluated.
9261 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9262 COMPOUND_EXPR in the chain will contain the tree for the simplified
9263 form of the builtin function call. */
9264
9265 static tree
9266 fold_builtin_strstr (tree arglist, tree type)
9267 {
9268 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
9269 return 0;
9270 else
9271 {
9272 tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
9273 tree fn;
9274 const char *p1, *p2;
9275
9276 p2 = c_getstr (s2);
9277 if (p2 == NULL)
9278 return 0;
9279
9280 p1 = c_getstr (s1);
9281 if (p1 != NULL)
9282 {
9283 const char *r = strstr (p1, p2);
9284 tree tem;
9285
9286 if (r == NULL)
9287 return build_int_cst (TREE_TYPE (s1), 0);
9288
9289 /* Return an offset into the constant string argument. */
9290 tem = fold_build2 (PLUS_EXPR, TREE_TYPE (s1),
9291 s1, build_int_cst (TREE_TYPE (s1), r - p1));
9292 return fold_convert (type, tem);
9293 }
9294
9295 /* The argument is const char *, and the result is char *, so we need
9296 a type conversion here to avoid a warning. */
9297 if (p2[0] == '\0')
9298 return fold_convert (type, s1);
9299
9300 if (p2[1] != '\0')
9301 return 0;
9302
9303 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
9304 if (!fn)
9305 return 0;
9306
9307 /* New argument list transforming strstr(s1, s2) to
9308 strchr(s1, s2[0]). */
9309 arglist = build_tree_list (NULL_TREE,
9310 build_int_cst (NULL_TREE, p2[0]));
9311 arglist = tree_cons (NULL_TREE, s1, arglist);
9312 return build_function_call_expr (fn, arglist);
9313 }
9314 }
9315
9316 /* Simplify a call to the strchr builtin.
9317
9318 Return 0 if no simplification was possible, otherwise return the
9319 simplified form of the call as a tree.
9320
9321 The simplified form may be a constant or other expression which
9322 computes the same value, but in a more efficient manner (including
9323 calls to other builtin functions).
9324
9325 The call may contain arguments which need to be evaluated, but
9326 which are not useful to determine the result of the call. In
9327 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9328 COMPOUND_EXPR will be an argument which must be evaluated.
9329 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9330 COMPOUND_EXPR in the chain will contain the tree for the simplified
9331 form of the builtin function call. */
9332
9333 static tree
9334 fold_builtin_strchr (tree arglist, tree type)
9335 {
9336 if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
9337 return 0;
9338 else
9339 {
9340 tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
9341 const char *p1;
9342
9343 if (TREE_CODE (s2) != INTEGER_CST)
9344 return 0;
9345
9346 p1 = c_getstr (s1);
9347 if (p1 != NULL)
9348 {
9349 char c;
9350 const char *r;
9351 tree tem;
9352
9353 if (target_char_cast (s2, &c))
9354 return 0;
9355
9356 r = strchr (p1, c);
9357
9358 if (r == NULL)
9359 return build_int_cst (TREE_TYPE (s1), 0);
9360
9361 /* Return an offset into the constant string argument. */
9362 tem = fold_build2 (PLUS_EXPR, TREE_TYPE (s1),
9363 s1, build_int_cst (TREE_TYPE (s1), r - p1));
9364 return fold_convert (type, tem);
9365 }
9366 return 0;
9367 }
9368 }
9369
9370 /* Simplify a call to the strrchr builtin.
9371
9372 Return 0 if no simplification was possible, otherwise return the
9373 simplified form of the call as a tree.
9374
9375 The simplified form may be a constant or other expression which
9376 computes the same value, but in a more efficient manner (including
9377 calls to other builtin functions).
9378
9379 The call may contain arguments which need to be evaluated, but
9380 which are not useful to determine the result of the call. In
9381 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9382 COMPOUND_EXPR will be an argument which must be evaluated.
9383 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9384 COMPOUND_EXPR in the chain will contain the tree for the simplified
9385 form of the builtin function call. */
9386
9387 static tree
9388 fold_builtin_strrchr (tree arglist, tree type)
9389 {
9390 if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
9391 return 0;
9392 else
9393 {
9394 tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
9395 tree fn;
9396 const char *p1;
9397
9398 if (TREE_CODE (s2) != INTEGER_CST)
9399 return 0;
9400
9401 p1 = c_getstr (s1);
9402 if (p1 != NULL)
9403 {
9404 char c;
9405 const char *r;
9406 tree tem;
9407
9408 if (target_char_cast (s2, &c))
9409 return 0;
9410
9411 r = strrchr (p1, c);
9412
9413 if (r == NULL)
9414 return build_int_cst (TREE_TYPE (s1), 0);
9415
9416 /* Return an offset into the constant string argument. */
9417 tem = fold_build2 (PLUS_EXPR, TREE_TYPE (s1),
9418 s1, build_int_cst (TREE_TYPE (s1), r - p1));
9419 return fold_convert (type, tem);
9420 }
9421
9422 if (! integer_zerop (s2))
9423 return 0;
9424
9425 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
9426 if (!fn)
9427 return 0;
9428
9429 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
9430 return build_function_call_expr (fn, arglist);
9431 }
9432 }
9433
9434 /* Simplify a call to the strpbrk builtin.
9435
9436 Return 0 if no simplification was possible, otherwise return the
9437 simplified form of the call as a tree.
9438
9439 The simplified form may be a constant or other expression which
9440 computes the same value, but in a more efficient manner (including
9441 calls to other builtin functions).
9442
9443 The call may contain arguments which need to be evaluated, but
9444 which are not useful to determine the result of the call. In
9445 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9446 COMPOUND_EXPR will be an argument which must be evaluated.
9447 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9448 COMPOUND_EXPR in the chain will contain the tree for the simplified
9449 form of the builtin function call. */
9450
9451 static tree
9452 fold_builtin_strpbrk (tree arglist, tree type)
9453 {
9454 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
9455 return 0;
9456 else
9457 {
9458 tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
9459 tree fn;
9460 const char *p1, *p2;
9461
9462 p2 = c_getstr (s2);
9463 if (p2 == NULL)
9464 return 0;
9465
9466 p1 = c_getstr (s1);
9467 if (p1 != NULL)
9468 {
9469 const char *r = strpbrk (p1, p2);
9470 tree tem;
9471
9472 if (r == NULL)
9473 return build_int_cst (TREE_TYPE (s1), 0);
9474
9475 /* Return an offset into the constant string argument. */
9476 tem = fold_build2 (PLUS_EXPR, TREE_TYPE (s1),
9477 s1, build_int_cst (TREE_TYPE (s1), r - p1));
9478 return fold_convert (type, tem);
9479 }
9480
9481 if (p2[0] == '\0')
9482 /* strpbrk(x, "") == NULL.
9483 Evaluate and ignore s1 in case it had side-effects. */
9484 return omit_one_operand (TREE_TYPE (s1), integer_zero_node, s1);
9485
9486 if (p2[1] != '\0')
9487 return 0; /* Really call strpbrk. */
9488
9489 fn = implicit_built_in_decls[BUILT_IN_STRCHR];
9490 if (!fn)
9491 return 0;
9492
9493 /* New argument list transforming strpbrk(s1, s2) to
9494 strchr(s1, s2[0]). */
9495 arglist = build_tree_list (NULL_TREE,
9496 build_int_cst (NULL_TREE, p2[0]));
9497 arglist = tree_cons (NULL_TREE, s1, arglist);
9498 return build_function_call_expr (fn, arglist);
9499 }
9500 }
9501
9502 /* Simplify a call to the strcat builtin.
9503
9504 Return 0 if no simplification was possible, otherwise return the
9505 simplified form of the call as a tree.
9506
9507 The simplified form may be a constant or other expression which
9508 computes the same value, but in a more efficient manner (including
9509 calls to other builtin functions).
9510
9511 The call may contain arguments which need to be evaluated, but
9512 which are not useful to determine the result of the call. In
9513 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9514 COMPOUND_EXPR will be an argument which must be evaluated.
9515 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9516 COMPOUND_EXPR in the chain will contain the tree for the simplified
9517 form of the builtin function call. */
9518
9519 static tree
9520 fold_builtin_strcat (tree arglist)
9521 {
9522 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
9523 return 0;
9524 else
9525 {
9526 tree dst = TREE_VALUE (arglist),
9527 src = TREE_VALUE (TREE_CHAIN (arglist));
9528 const char *p = c_getstr (src);
9529
9530 /* If the string length is zero, return the dst parameter. */
9531 if (p && *p == '\0')
9532 return dst;
9533
9534 return 0;
9535 }
9536 }
9537
9538 /* Simplify a call to the strncat builtin.
9539
9540 Return 0 if no simplification was possible, otherwise return the
9541 simplified form of the call as a tree.
9542
9543 The simplified form may be a constant or other expression which
9544 computes the same value, but in a more efficient manner (including
9545 calls to other builtin functions).
9546
9547 The call may contain arguments which need to be evaluated, but
9548 which are not useful to determine the result of the call. In
9549 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9550 COMPOUND_EXPR will be an argument which must be evaluated.
9551 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9552 COMPOUND_EXPR in the chain will contain the tree for the simplified
9553 form of the builtin function call. */
9554
9555 static tree
9556 fold_builtin_strncat (tree arglist)
9557 {
9558 if (!validate_arglist (arglist,
9559 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
9560 return 0;
9561 else
9562 {
9563 tree dst = TREE_VALUE (arglist);
9564 tree src = TREE_VALUE (TREE_CHAIN (arglist));
9565 tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
9566 const char *p = c_getstr (src);
9567
9568 /* If the requested length is zero, or the src parameter string
9569 length is zero, return the dst parameter. */
9570 if (integer_zerop (len) || (p && *p == '\0'))
9571 return omit_two_operands (TREE_TYPE (dst), dst, src, len);
9572
9573 /* If the requested len is greater than or equal to the string
9574 length, call strcat. */
9575 if (TREE_CODE (len) == INTEGER_CST && p
9576 && compare_tree_int (len, strlen (p)) >= 0)
9577 {
9578 tree newarglist
9579 = tree_cons (NULL_TREE, dst, build_tree_list (NULL_TREE, src));
9580 tree fn = implicit_built_in_decls[BUILT_IN_STRCAT];
9581
9582 /* If the replacement _DECL isn't initialized, don't do the
9583 transformation. */
9584 if (!fn)
9585 return 0;
9586
9587 return build_function_call_expr (fn, newarglist);
9588 }
9589 return 0;
9590 }
9591 }
9592
9593 /* Simplify a call to the strspn builtin.
9594
9595 Return 0 if no simplification was possible, otherwise return the
9596 simplified form of the call as a tree.
9597
9598 The simplified form may be a constant or other expression which
9599 computes the same value, but in a more efficient manner (including
9600 calls to other builtin functions).
9601
9602 The call may contain arguments which need to be evaluated, but
9603 which are not useful to determine the result of the call. In
9604 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9605 COMPOUND_EXPR will be an argument which must be evaluated.
9606 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9607 COMPOUND_EXPR in the chain will contain the tree for the simplified
9608 form of the builtin function call. */
9609
9610 static tree
9611 fold_builtin_strspn (tree arglist)
9612 {
9613 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
9614 return 0;
9615 else
9616 {
9617 tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
9618 const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
9619
9620 /* If both arguments are constants, evaluate at compile-time. */
9621 if (p1 && p2)
9622 {
9623 const size_t r = strspn (p1, p2);
9624 return size_int (r);
9625 }
9626
9627 /* If either argument is "", return 0. */
9628 if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
9629 /* Evaluate and ignore both arguments in case either one has
9630 side-effects. */
9631 return omit_two_operands (integer_type_node, integer_zero_node,
9632 s1, s2);
9633 return 0;
9634 }
9635 }
9636
9637 /* Simplify a call to the strcspn builtin.
9638
9639 Return 0 if no simplification was possible, otherwise return the
9640 simplified form of the call as a tree.
9641
9642 The simplified form may be a constant or other expression which
9643 computes the same value, but in a more efficient manner (including
9644 calls to other builtin functions).
9645
9646 The call may contain arguments which need to be evaluated, but
9647 which are not useful to determine the result of the call. In
9648 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9649 COMPOUND_EXPR will be an argument which must be evaluated.
9650 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9651 COMPOUND_EXPR in the chain will contain the tree for the simplified
9652 form of the builtin function call. */
9653
9654 static tree
9655 fold_builtin_strcspn (tree arglist)
9656 {
9657 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
9658 return 0;
9659 else
9660 {
9661 tree s1 = TREE_VALUE (arglist), s2 = TREE_VALUE (TREE_CHAIN (arglist));
9662 const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
9663
9664 /* If both arguments are constants, evaluate at compile-time. */
9665 if (p1 && p2)
9666 {
9667 const size_t r = strcspn (p1, p2);
9668 return size_int (r);
9669 }
9670
9671 /* If the first argument is "", return 0. */
9672 if (p1 && *p1 == '\0')
9673 {
9674 /* Evaluate and ignore argument s2 in case it has
9675 side-effects. */
9676 return omit_one_operand (integer_type_node,
9677 integer_zero_node, s2);
9678 }
9679
9680 /* If the second argument is "", return __builtin_strlen(s1). */
9681 if (p2 && *p2 == '\0')
9682 {
9683 tree newarglist = build_tree_list (NULL_TREE, s1),
9684 fn = implicit_built_in_decls[BUILT_IN_STRLEN];
9685
9686 /* If the replacement _DECL isn't initialized, don't do the
9687 transformation. */
9688 if (!fn)
9689 return 0;
9690
9691 return build_function_call_expr (fn, newarglist);
9692 }
9693 return 0;
9694 }
9695 }
9696
9697 /* Fold a call to the fputs builtin. IGNORE is true if the value returned
9698 by the builtin will be ignored. UNLOCKED is true is true if this
9699 actually a call to fputs_unlocked. If LEN in non-NULL, it represents
9700 the known length of the string. Return NULL_TREE if no simplification
9701 was possible. */
9702
9703 tree
9704 fold_builtin_fputs (tree arglist, bool ignore, bool unlocked, tree len)
9705 {
9706 tree fn;
9707 /* If we're using an unlocked function, assume the other unlocked
9708 functions exist explicitly. */
9709 tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
9710 : implicit_built_in_decls[BUILT_IN_FPUTC];
9711 tree const fn_fwrite = unlocked ? built_in_decls[BUILT_IN_FWRITE_UNLOCKED]
9712 : implicit_built_in_decls[BUILT_IN_FWRITE];
9713
9714 /* If the return value is used, don't do the transformation. */
9715 if (!ignore)
9716 return 0;
9717
9718 /* Verify the arguments in the original call. */
9719 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
9720 return 0;
9721
9722 if (! len)
9723 len = c_strlen (TREE_VALUE (arglist), 0);
9724
9725 /* Get the length of the string passed to fputs. If the length
9726 can't be determined, punt. */
9727 if (!len
9728 || TREE_CODE (len) != INTEGER_CST)
9729 return 0;
9730
9731 switch (compare_tree_int (len, 1))
9732 {
9733 case -1: /* length is 0, delete the call entirely . */
9734 return omit_one_operand (integer_type_node, integer_zero_node,
9735 TREE_VALUE (TREE_CHAIN (arglist)));
9736
9737 case 0: /* length is 1, call fputc. */
9738 {
9739 const char *p = c_getstr (TREE_VALUE (arglist));
9740
9741 if (p != NULL)
9742 {
9743 /* New argument list transforming fputs(string, stream) to
9744 fputc(string[0], stream). */
9745 arglist = build_tree_list (NULL_TREE,
9746 TREE_VALUE (TREE_CHAIN (arglist)));
9747 arglist = tree_cons (NULL_TREE,
9748 build_int_cst (NULL_TREE, p[0]),
9749 arglist);
9750 fn = fn_fputc;
9751 break;
9752 }
9753 }
9754 /* FALLTHROUGH */
9755 case 1: /* length is greater than 1, call fwrite. */
9756 {
9757 tree string_arg;
9758
9759 /* If optimizing for size keep fputs. */
9760 if (optimize_size)
9761 return 0;
9762 string_arg = TREE_VALUE (arglist);
9763 /* New argument list transforming fputs(string, stream) to
9764 fwrite(string, 1, len, stream). */
9765 arglist = build_tree_list (NULL_TREE,
9766 TREE_VALUE (TREE_CHAIN (arglist)));
9767 arglist = tree_cons (NULL_TREE, len, arglist);
9768 arglist = tree_cons (NULL_TREE, size_one_node, arglist);
9769 arglist = tree_cons (NULL_TREE, string_arg, arglist);
9770 fn = fn_fwrite;
9771 break;
9772 }
9773 default:
9774 gcc_unreachable ();
9775 }
9776
9777 /* If the replacement _DECL isn't initialized, don't do the
9778 transformation. */
9779 if (!fn)
9780 return 0;
9781
9782 /* These optimizations are only performed when the result is ignored,
9783 hence there's no need to cast the result to integer_type_node. */
9784 return build_function_call_expr (fn, arglist);
9785 }
9786
9787 /* Fold the new_arg's arguments (ARGLIST). Returns true if there was an error
9788 produced. False otherwise. This is done so that we don't output the error
9789 or warning twice or three times. */
9790 bool
9791 fold_builtin_next_arg (tree arglist)
9792 {
9793 tree fntype = TREE_TYPE (current_function_decl);
9794
9795 if (TYPE_ARG_TYPES (fntype) == 0
9796 || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
9797 == void_type_node))
9798 {
9799 error ("%<va_start%> used in function with fixed args");
9800 return true;
9801 }
9802 else if (!arglist)
9803 {
9804 /* Evidently an out of date version of <stdarg.h>; can't validate
9805 va_start's second argument, but can still work as intended. */
9806 warning (0, "%<__builtin_next_arg%> called without an argument");
9807 return true;
9808 }
9809 /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
9810 when we checked the arguments and if needed issued a warning. */
9811 else if (!TREE_CHAIN (arglist)
9812 || !integer_zerop (TREE_VALUE (arglist))
9813 || !integer_zerop (TREE_VALUE (TREE_CHAIN (arglist)))
9814 || TREE_CHAIN (TREE_CHAIN (arglist)))
9815 {
9816 tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
9817 tree arg = TREE_VALUE (arglist);
9818
9819 if (TREE_CHAIN (arglist))
9820 {
9821 error ("%<va_start%> used with too many arguments");
9822 return true;
9823 }
9824
9825 /* Strip off all nops for the sake of the comparison. This
9826 is not quite the same as STRIP_NOPS. It does more.
9827 We must also strip off INDIRECT_EXPR for C++ reference
9828 parameters. */
9829 while (TREE_CODE (arg) == NOP_EXPR
9830 || TREE_CODE (arg) == CONVERT_EXPR
9831 || TREE_CODE (arg) == NON_LVALUE_EXPR
9832 || TREE_CODE (arg) == INDIRECT_REF)
9833 arg = TREE_OPERAND (arg, 0);
9834 if (arg != last_parm)
9835 {
9836 /* FIXME: Sometimes with the tree optimizers we can get the
9837 not the last argument even though the user used the last
9838 argument. We just warn and set the arg to be the last
9839 argument so that we will get wrong-code because of
9840 it. */
9841 warning (0, "second parameter of %<va_start%> not last named argument");
9842 }
9843 /* We want to verify the second parameter just once before the tree
9844 optimizers are run and then avoid keeping it in the tree,
9845 as otherwise we could warn even for correct code like:
9846 void foo (int i, ...)
9847 { va_list ap; i++; va_start (ap, i); va_end (ap); } */
9848 TREE_VALUE (arglist) = integer_zero_node;
9849 TREE_CHAIN (arglist) = build_tree_list (NULL, integer_zero_node);
9850 }
9851 return false;
9852 }
9853
9854
9855 /* Simplify a call to the sprintf builtin.
9856
9857 Return 0 if no simplification was possible, otherwise return the
9858 simplified form of the call as a tree. If IGNORED is true, it means that
9859 the caller does not use the returned value of the function. */
9860
9861 static tree
9862 fold_builtin_sprintf (tree arglist, int ignored)
9863 {
9864 tree call, retval, dest, fmt;
9865 const char *fmt_str = NULL;
9866
9867 /* Verify the required arguments in the original call. We deal with two
9868 types of sprintf() calls: 'sprintf (str, fmt)' and
9869 'sprintf (dest, "%s", orig)'. */
9870 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, VOID_TYPE)
9871 && !validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, POINTER_TYPE,
9872 VOID_TYPE))
9873 return NULL_TREE;
9874
9875 /* Get the destination string and the format specifier. */
9876 dest = TREE_VALUE (arglist);
9877 fmt = TREE_VALUE (TREE_CHAIN (arglist));
9878
9879 /* Check whether the format is a literal string constant. */
9880 fmt_str = c_getstr (fmt);
9881 if (fmt_str == NULL)
9882 return NULL_TREE;
9883
9884 call = NULL_TREE;
9885 retval = NULL_TREE;
9886
9887 if (!init_target_chars())
9888 return 0;
9889
9890 /* If the format doesn't contain % args or %%, use strcpy. */
9891 if (strchr (fmt_str, target_percent) == NULL)
9892 {
9893 tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
9894
9895 if (!fn)
9896 return NULL_TREE;
9897
9898 /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
9899 'format' is known to contain no % formats. */
9900 arglist = build_tree_list (NULL_TREE, fmt);
9901 arglist = tree_cons (NULL_TREE, dest, arglist);
9902 call = build_function_call_expr (fn, arglist);
9903 if (!ignored)
9904 retval = build_int_cst (NULL_TREE, strlen (fmt_str));
9905 }
9906
9907 /* If the format is "%s", use strcpy if the result isn't used. */
9908 else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
9909 {
9910 tree fn, orig;
9911 fn = implicit_built_in_decls[BUILT_IN_STRCPY];
9912
9913 if (!fn)
9914 return NULL_TREE;
9915
9916 /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2). */
9917 orig = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
9918 arglist = build_tree_list (NULL_TREE, orig);
9919 arglist = tree_cons (NULL_TREE, dest, arglist);
9920 if (!ignored)
9921 {
9922 retval = c_strlen (orig, 1);
9923 if (!retval || TREE_CODE (retval) != INTEGER_CST)
9924 return NULL_TREE;
9925 }
9926 call = build_function_call_expr (fn, arglist);
9927 }
9928
9929 if (call && retval)
9930 {
9931 retval = fold_convert
9932 (TREE_TYPE (TREE_TYPE (implicit_built_in_decls[BUILT_IN_SPRINTF])),
9933 retval);
9934 return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
9935 }
9936 else
9937 return call;
9938 }
9939
9940 /* Expand a call to __builtin_object_size. */
9941
9942 rtx
9943 expand_builtin_object_size (tree exp)
9944 {
9945 tree ost;
9946 int object_size_type;
9947 tree fndecl = get_callee_fndecl (exp);
9948 tree arglist = TREE_OPERAND (exp, 1);
9949 location_t locus = EXPR_LOCATION (exp);
9950
9951 if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
9952 {
9953 error ("%Hfirst argument of %D must be a pointer, second integer constant",
9954 &locus, fndecl);
9955 expand_builtin_trap ();
9956 return const0_rtx;
9957 }
9958
9959 ost = TREE_VALUE (TREE_CHAIN (arglist));
9960 STRIP_NOPS (ost);
9961
9962 if (TREE_CODE (ost) != INTEGER_CST
9963 || tree_int_cst_sgn (ost) < 0
9964 || compare_tree_int (ost, 3) > 0)
9965 {
9966 error ("%Hlast argument of %D is not integer constant between 0 and 3",
9967 &locus, fndecl);
9968 expand_builtin_trap ();
9969 return const0_rtx;
9970 }
9971
9972 object_size_type = tree_low_cst (ost, 0);
9973
9974 return object_size_type < 2 ? constm1_rtx : const0_rtx;
9975 }
9976
9977 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
9978 FCODE is the BUILT_IN_* to use.
9979 Return 0 if we failed; the caller should emit a normal call,
9980 otherwise try to get the result in TARGET, if convenient (and in
9981 mode MODE if that's convenient). */
9982
9983 static rtx
9984 expand_builtin_memory_chk (tree exp, rtx target, enum machine_mode mode,
9985 enum built_in_function fcode)
9986 {
9987 tree arglist = TREE_OPERAND (exp, 1);
9988 tree dest, src, len, size;
9989
9990 if (!validate_arglist (arglist,
9991 POINTER_TYPE,
9992 fcode == BUILT_IN_MEMSET_CHK
9993 ? INTEGER_TYPE : POINTER_TYPE,
9994 INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
9995 return 0;
9996
9997 dest = TREE_VALUE (arglist);
9998 src = TREE_VALUE (TREE_CHAIN (arglist));
9999 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
10000 size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist))));
10001
10002 if (! host_integerp (size, 1))
10003 return 0;
10004
10005 if (host_integerp (len, 1) || integer_all_onesp (size))
10006 {
10007 tree fn;
10008
10009 if (! integer_all_onesp (size) && tree_int_cst_lt (size, len))
10010 {
10011 location_t locus = EXPR_LOCATION (exp);
10012 warning (0, "%Hcall to %D will always overflow destination buffer",
10013 &locus, get_callee_fndecl (exp));
10014 return 0;
10015 }
10016
10017 arglist = build_tree_list (NULL_TREE, len);
10018 arglist = tree_cons (NULL_TREE, src, arglist);
10019 arglist = tree_cons (NULL_TREE, dest, arglist);
10020
10021 fn = NULL_TREE;
10022 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
10023 mem{cpy,pcpy,move,set} is available. */
10024 switch (fcode)
10025 {
10026 case BUILT_IN_MEMCPY_CHK:
10027 fn = built_in_decls[BUILT_IN_MEMCPY];
10028 break;
10029 case BUILT_IN_MEMPCPY_CHK:
10030 fn = built_in_decls[BUILT_IN_MEMPCPY];
10031 break;
10032 case BUILT_IN_MEMMOVE_CHK:
10033 fn = built_in_decls[BUILT_IN_MEMMOVE];
10034 break;
10035 case BUILT_IN_MEMSET_CHK:
10036 fn = built_in_decls[BUILT_IN_MEMSET];
10037 break;
10038 default:
10039 break;
10040 }
10041
10042 if (! fn)
10043 return 0;
10044
10045 fn = build_function_call_expr (fn, arglist);
10046 if (TREE_CODE (fn) == CALL_EXPR)
10047 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
10048 return expand_expr (fn, target, mode, EXPAND_NORMAL);
10049 }
10050 else if (fcode == BUILT_IN_MEMSET_CHK)
10051 return 0;
10052 else
10053 {
10054 unsigned int dest_align
10055 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
10056
10057 /* If DEST is not a pointer type, call the normal function. */
10058 if (dest_align == 0)
10059 return 0;
10060
10061 /* If SRC and DEST are the same (and not volatile), do nothing. */
10062 if (operand_equal_p (src, dest, 0))
10063 {
10064 tree expr;
10065
10066 if (fcode != BUILT_IN_MEMPCPY_CHK)
10067 {
10068 /* Evaluate and ignore LEN in case it has side-effects. */
10069 expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
10070 return expand_expr (dest, target, mode, EXPAND_NORMAL);
10071 }
10072
10073 len = fold_convert (TREE_TYPE (dest), len);
10074 expr = fold_build2 (PLUS_EXPR, TREE_TYPE (dest), dest, len);
10075 return expand_expr (expr, target, mode, EXPAND_NORMAL);
10076 }
10077
10078 /* __memmove_chk special case. */
10079 if (fcode == BUILT_IN_MEMMOVE_CHK)
10080 {
10081 unsigned int src_align
10082 = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
10083
10084 if (src_align == 0)
10085 return 0;
10086
10087 /* If src is categorized for a readonly section we can use
10088 normal __memcpy_chk. */
10089 if (readonly_data_expr (src))
10090 {
10091 tree fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
10092 if (!fn)
10093 return 0;
10094 fn = build_function_call_expr (fn, arglist);
10095 if (TREE_CODE (fn) == CALL_EXPR)
10096 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
10097 return expand_expr (fn, target, mode, EXPAND_NORMAL);
10098 }
10099 }
10100 return 0;
10101 }
10102 }
10103
10104 /* Emit warning if a buffer overflow is detected at compile time. */
10105
10106 static void
10107 maybe_emit_chk_warning (tree exp, enum built_in_function fcode)
10108 {
10109 int arg_mask, is_strlen = 0;
10110 tree arglist = TREE_OPERAND (exp, 1), a;
10111 tree len, size;
10112 location_t locus;
10113
10114 switch (fcode)
10115 {
10116 case BUILT_IN_STRCPY_CHK:
10117 case BUILT_IN_STPCPY_CHK:
10118 /* For __strcat_chk the warning will be emitted only if overflowing
10119 by at least strlen (dest) + 1 bytes. */
10120 case BUILT_IN_STRCAT_CHK:
10121 arg_mask = 6;
10122 is_strlen = 1;
10123 break;
10124 case BUILT_IN_STRNCPY_CHK:
10125 arg_mask = 12;
10126 break;
10127 case BUILT_IN_SNPRINTF_CHK:
10128 case BUILT_IN_VSNPRINTF_CHK:
10129 arg_mask = 10;
10130 break;
10131 default:
10132 gcc_unreachable ();
10133 }
10134
10135 len = NULL_TREE;
10136 size = NULL_TREE;
10137 for (a = arglist; a && arg_mask; a = TREE_CHAIN (a), arg_mask >>= 1)
10138 if (arg_mask & 1)
10139 {
10140 if (len)
10141 size = a;
10142 else
10143 len = a;
10144 }
10145
10146 if (!len || !size)
10147 return;
10148
10149 len = TREE_VALUE (len);
10150 size = TREE_VALUE (size);
10151
10152 if (! host_integerp (size, 1) || integer_all_onesp (size))
10153 return;
10154
10155 if (is_strlen)
10156 {
10157 len = c_strlen (len, 1);
10158 if (! len || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
10159 return;
10160 }
10161 else if (! host_integerp (len, 1) || ! tree_int_cst_lt (size, len))
10162 return;
10163
10164 locus = EXPR_LOCATION (exp);
10165 warning (0, "%Hcall to %D will always overflow destination buffer",
10166 &locus, get_callee_fndecl (exp));
10167 }
10168
10169 /* Emit warning if a buffer overflow is detected at compile time
10170 in __sprintf_chk/__vsprintf_chk calls. */
10171
10172 static void
10173 maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode)
10174 {
10175 tree arglist = TREE_OPERAND (exp, 1);
10176 tree dest, size, len, fmt, flag;
10177 const char *fmt_str;
10178
10179 /* Verify the required arguments in the original call. */
10180 if (! arglist)
10181 return;
10182 dest = TREE_VALUE (arglist);
10183 arglist = TREE_CHAIN (arglist);
10184 if (! arglist)
10185 return;
10186 flag = TREE_VALUE (arglist);
10187 arglist = TREE_CHAIN (arglist);
10188 if (! arglist)
10189 return;
10190 size = TREE_VALUE (arglist);
10191 arglist = TREE_CHAIN (arglist);
10192 if (! arglist)
10193 return;
10194 fmt = TREE_VALUE (arglist);
10195 arglist = TREE_CHAIN (arglist);
10196
10197 if (! host_integerp (size, 1) || integer_all_onesp (size))
10198 return;
10199
10200 /* Check whether the format is a literal string constant. */
10201 fmt_str = c_getstr (fmt);
10202 if (fmt_str == NULL)
10203 return;
10204
10205 if (!init_target_chars())
10206 return;
10207
10208 /* If the format doesn't contain % args or %%, we know its size. */
10209 if (strchr (fmt_str, target_percent) == 0)
10210 len = build_int_cstu (size_type_node, strlen (fmt_str));
10211 /* If the format is "%s" and first ... argument is a string literal,
10212 we know it too. */
10213 else if (fcode == BUILT_IN_SPRINTF_CHK && strcmp (fmt_str, target_percent_s) == 0)
10214 {
10215 tree arg;
10216
10217 if (! arglist)
10218 return;
10219 arg = TREE_VALUE (arglist);
10220 if (! POINTER_TYPE_P (TREE_TYPE (arg)))
10221 return;
10222
10223 len = c_strlen (arg, 1);
10224 if (!len || ! host_integerp (len, 1))
10225 return;
10226 }
10227 else
10228 return;
10229
10230 if (! tree_int_cst_lt (len, size))
10231 {
10232 location_t locus = EXPR_LOCATION (exp);
10233 warning (0, "%Hcall to %D will always overflow destination buffer",
10234 &locus, get_callee_fndecl (exp));
10235 }
10236 }
10237
10238 /* Fold a call to __builtin_object_size, if possible. */
10239
10240 tree
10241 fold_builtin_object_size (tree arglist)
10242 {
10243 tree ptr, ost, ret = 0;
10244 int object_size_type;
10245
10246 if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
10247 return 0;
10248
10249 ptr = TREE_VALUE (arglist);
10250 ost = TREE_VALUE (TREE_CHAIN (arglist));
10251 STRIP_NOPS (ost);
10252
10253 if (TREE_CODE (ost) != INTEGER_CST
10254 || tree_int_cst_sgn (ost) < 0
10255 || compare_tree_int (ost, 3) > 0)
10256 return 0;
10257
10258 object_size_type = tree_low_cst (ost, 0);
10259
10260 /* __builtin_object_size doesn't evaluate side-effects in its arguments;
10261 if there are any side-effects, it returns (size_t) -1 for types 0 and 1
10262 and (size_t) 0 for types 2 and 3. */
10263 if (TREE_SIDE_EFFECTS (ptr))
10264 return fold_convert (size_type_node,
10265 object_size_type < 2
10266 ? integer_minus_one_node : integer_zero_node);
10267
10268 if (TREE_CODE (ptr) == ADDR_EXPR)
10269 ret = build_int_cstu (size_type_node,
10270 compute_builtin_object_size (ptr, object_size_type));
10271
10272 else if (TREE_CODE (ptr) == SSA_NAME)
10273 {
10274 unsigned HOST_WIDE_INT bytes;
10275
10276 /* If object size is not known yet, delay folding until
10277 later. Maybe subsequent passes will help determining
10278 it. */
10279 bytes = compute_builtin_object_size (ptr, object_size_type);
10280 if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2
10281 ? -1 : 0))
10282 ret = build_int_cstu (size_type_node, bytes);
10283 }
10284
10285 if (ret)
10286 {
10287 ret = force_fit_type (ret, -1, false, false);
10288 if (TREE_CONSTANT_OVERFLOW (ret))
10289 ret = 0;
10290 }
10291
10292 return ret;
10293 }
10294
10295 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
10296 IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_*
10297 code of the builtin. If MAXLEN is not NULL, it is maximum length
10298 passed as third argument. */
10299
10300 tree
10301 fold_builtin_memory_chk (tree fndecl, tree arglist, tree maxlen, bool ignore,
10302 enum built_in_function fcode)
10303 {
10304 tree dest, src, len, size, fn;
10305
10306 if (!validate_arglist (arglist,
10307 POINTER_TYPE,
10308 fcode == BUILT_IN_MEMSET_CHK
10309 ? INTEGER_TYPE : POINTER_TYPE,
10310 INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
10311 return 0;
10312
10313 dest = TREE_VALUE (arglist);
10314 /* Actually val for __memset_chk, but it doesn't matter. */
10315 src = TREE_VALUE (TREE_CHAIN (arglist));
10316 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
10317 size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist))));
10318
10319 /* If SRC and DEST are the same (and not volatile), return DEST
10320 (resp. DEST+LEN for __mempcpy_chk). */
10321 if (fcode != BUILT_IN_MEMSET_CHK && operand_equal_p (src, dest, 0))
10322 {
10323 if (fcode != BUILT_IN_MEMPCPY_CHK)
10324 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
10325 else
10326 {
10327 tree temp = fold_convert (TREE_TYPE (dest), len);
10328 temp = fold_build2 (PLUS_EXPR, TREE_TYPE (dest), dest, temp);
10329 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), temp);
10330 }
10331 }
10332
10333 if (! host_integerp (size, 1))
10334 return 0;
10335
10336 if (! integer_all_onesp (size))
10337 {
10338 if (! host_integerp (len, 1))
10339 {
10340 /* If LEN is not constant, try MAXLEN too.
10341 For MAXLEN only allow optimizing into non-_ocs function
10342 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
10343 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
10344 {
10345 if (fcode == BUILT_IN_MEMPCPY_CHK && ignore)
10346 {
10347 /* (void) __mempcpy_chk () can be optimized into
10348 (void) __memcpy_chk (). */
10349 fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
10350 if (!fn)
10351 return 0;
10352
10353 return build_function_call_expr (fn, arglist);
10354 }
10355 return 0;
10356 }
10357 }
10358 else
10359 maxlen = len;
10360
10361 if (tree_int_cst_lt (size, maxlen))
10362 return 0;
10363 }
10364
10365 arglist = build_tree_list (NULL_TREE, len);
10366 arglist = tree_cons (NULL_TREE, src, arglist);
10367 arglist = tree_cons (NULL_TREE, dest, arglist);
10368
10369 fn = NULL_TREE;
10370 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
10371 mem{cpy,pcpy,move,set} is available. */
10372 switch (fcode)
10373 {
10374 case BUILT_IN_MEMCPY_CHK:
10375 fn = built_in_decls[BUILT_IN_MEMCPY];
10376 break;
10377 case BUILT_IN_MEMPCPY_CHK:
10378 fn = built_in_decls[BUILT_IN_MEMPCPY];
10379 break;
10380 case BUILT_IN_MEMMOVE_CHK:
10381 fn = built_in_decls[BUILT_IN_MEMMOVE];
10382 break;
10383 case BUILT_IN_MEMSET_CHK:
10384 fn = built_in_decls[BUILT_IN_MEMSET];
10385 break;
10386 default:
10387 break;
10388 }
10389
10390 if (!fn)
10391 return 0;
10392
10393 return build_function_call_expr (fn, arglist);
10394 }
10395
10396 /* Fold a call to the __st[rp]cpy_chk builtin.
10397 IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_*
10398 code of the builtin. If MAXLEN is not NULL, it is maximum length of
10399 strings passed as second argument. */
10400
10401 tree
10402 fold_builtin_stxcpy_chk (tree fndecl, tree arglist, tree maxlen, bool ignore,
10403 enum built_in_function fcode)
10404 {
10405 tree dest, src, size, len, fn;
10406
10407 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE,
10408 VOID_TYPE))
10409 return 0;
10410
10411 dest = TREE_VALUE (arglist);
10412 src = TREE_VALUE (TREE_CHAIN (arglist));
10413 size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
10414
10415 /* If SRC and DEST are the same (and not volatile), return DEST. */
10416 if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0))
10417 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), dest);
10418
10419 if (! host_integerp (size, 1))
10420 return 0;
10421
10422 if (! integer_all_onesp (size))
10423 {
10424 len = c_strlen (src, 1);
10425 if (! len || ! host_integerp (len, 1))
10426 {
10427 /* If LEN is not constant, try MAXLEN too.
10428 For MAXLEN only allow optimizing into non-_ocs function
10429 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
10430 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
10431 {
10432 if (fcode == BUILT_IN_STPCPY_CHK)
10433 {
10434 if (! ignore)
10435 return 0;
10436
10437 /* If return value of __stpcpy_chk is ignored,
10438 optimize into __strcpy_chk. */
10439 fn = built_in_decls[BUILT_IN_STRCPY_CHK];
10440 if (!fn)
10441 return 0;
10442
10443 return build_function_call_expr (fn, arglist);
10444 }
10445
10446 if (! len || TREE_SIDE_EFFECTS (len))
10447 return 0;
10448
10449 /* If c_strlen returned something, but not a constant,
10450 transform __strcpy_chk into __memcpy_chk. */
10451 fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
10452 if (!fn)
10453 return 0;
10454
10455 len = size_binop (PLUS_EXPR, len, ssize_int (1));
10456 arglist = build_tree_list (NULL_TREE, size);
10457 arglist = tree_cons (NULL_TREE, len, arglist);
10458 arglist = tree_cons (NULL_TREE, src, arglist);
10459 arglist = tree_cons (NULL_TREE, dest, arglist);
10460 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)),
10461 build_function_call_expr (fn, arglist));
10462 }
10463 }
10464 else
10465 maxlen = len;
10466
10467 if (! tree_int_cst_lt (maxlen, size))
10468 return 0;
10469 }
10470
10471 arglist = build_tree_list (NULL_TREE, src);
10472 arglist = tree_cons (NULL_TREE, dest, arglist);
10473
10474 /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available. */
10475 fn = built_in_decls[fcode == BUILT_IN_STPCPY_CHK
10476 ? BUILT_IN_STPCPY : BUILT_IN_STRCPY];
10477 if (!fn)
10478 return 0;
10479
10480 return build_function_call_expr (fn, arglist);
10481 }
10482
10483 /* Fold a call to the __strncpy_chk builtin.
10484 If MAXLEN is not NULL, it is maximum length passed as third argument. */
10485
10486 tree
10487 fold_builtin_strncpy_chk (tree arglist, tree maxlen)
10488 {
10489 tree dest, src, size, len, fn;
10490
10491 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE,
10492 INTEGER_TYPE, VOID_TYPE))
10493 return 0;
10494
10495 dest = TREE_VALUE (arglist);
10496 src = TREE_VALUE (TREE_CHAIN (arglist));
10497 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
10498 size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist))));
10499
10500 if (! host_integerp (size, 1))
10501 return 0;
10502
10503 if (! integer_all_onesp (size))
10504 {
10505 if (! host_integerp (len, 1))
10506 {
10507 /* If LEN is not constant, try MAXLEN too.
10508 For MAXLEN only allow optimizing into non-_ocs function
10509 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
10510 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
10511 return 0;
10512 }
10513 else
10514 maxlen = len;
10515
10516 if (tree_int_cst_lt (size, maxlen))
10517 return 0;
10518 }
10519
10520 arglist = build_tree_list (NULL_TREE, len);
10521 arglist = tree_cons (NULL_TREE, src, arglist);
10522 arglist = tree_cons (NULL_TREE, dest, arglist);
10523
10524 /* If __builtin_strncpy_chk is used, assume strncpy is available. */
10525 fn = built_in_decls[BUILT_IN_STRNCPY];
10526 if (!fn)
10527 return 0;
10528
10529 return build_function_call_expr (fn, arglist);
10530 }
10531
10532 /* Fold a call to the __strcat_chk builtin FNDECL with ARGLIST. */
10533
10534 static tree
10535 fold_builtin_strcat_chk (tree fndecl, tree arglist)
10536 {
10537 tree dest, src, size, fn;
10538 const char *p;
10539
10540 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE,
10541 VOID_TYPE))
10542 return 0;
10543
10544 dest = TREE_VALUE (arglist);
10545 src = TREE_VALUE (TREE_CHAIN (arglist));
10546 size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
10547
10548 p = c_getstr (src);
10549 /* If the SRC parameter is "", return DEST. */
10550 if (p && *p == '\0')
10551 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
10552
10553 if (! host_integerp (size, 1) || ! integer_all_onesp (size))
10554 return 0;
10555
10556 arglist = build_tree_list (NULL_TREE, src);
10557 arglist = tree_cons (NULL_TREE, dest, arglist);
10558
10559 /* If __builtin_strcat_chk is used, assume strcat is available. */
10560 fn = built_in_decls[BUILT_IN_STRCAT];
10561 if (!fn)
10562 return 0;
10563
10564 return build_function_call_expr (fn, arglist);
10565 }
10566
10567 /* Fold a call to the __strncat_chk builtin EXP. */
10568
10569 static tree
10570 fold_builtin_strncat_chk (tree fndecl, tree arglist)
10571 {
10572 tree dest, src, size, len, fn;
10573 const char *p;
10574
10575 if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE,
10576 INTEGER_TYPE, VOID_TYPE))
10577 return 0;
10578
10579 dest = TREE_VALUE (arglist);
10580 src = TREE_VALUE (TREE_CHAIN (arglist));
10581 len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
10582 size = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist))));
10583
10584 p = c_getstr (src);
10585 /* If the SRC parameter is "" or if LEN is 0, return DEST. */
10586 if (p && *p == '\0')
10587 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
10588 else if (integer_zerop (len))
10589 return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
10590
10591 if (! host_integerp (size, 1))
10592 return 0;
10593
10594 if (! integer_all_onesp (size))
10595 {
10596 tree src_len = c_strlen (src, 1);
10597 if (src_len
10598 && host_integerp (src_len, 1)
10599 && host_integerp (len, 1)
10600 && ! tree_int_cst_lt (len, src_len))
10601 {
10602 /* If LEN >= strlen (SRC), optimize into __strcat_chk. */
10603 fn = built_in_decls[BUILT_IN_STRCAT_CHK];
10604 if (!fn)
10605 return 0;
10606
10607 arglist = build_tree_list (NULL_TREE, size);
10608 arglist = tree_cons (NULL_TREE, src, arglist);
10609 arglist = tree_cons (NULL_TREE, dest, arglist);
10610 return build_function_call_expr (fn, arglist);
10611 }
10612 return 0;
10613 }
10614
10615 arglist = build_tree_list (NULL_TREE, len);
10616 arglist = tree_cons (NULL_TREE, src, arglist);
10617 arglist = tree_cons (NULL_TREE, dest, arglist);
10618
10619 /* If __builtin_strncat_chk is used, assume strncat is available. */
10620 fn = built_in_decls[BUILT_IN_STRNCAT];
10621 if (!fn)
10622 return 0;
10623
10624 return build_function_call_expr (fn, arglist);
10625 }
10626
10627 /* Fold a call to __{,v}sprintf_chk with argument list ARGLIST. Return 0 if
10628 a normal call should be emitted rather than expanding the function
10629 inline. FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK. */
10630
10631 static tree
10632 fold_builtin_sprintf_chk (tree arglist, enum built_in_function fcode)
10633 {
10634 tree dest, size, len, fn, fmt, flag;
10635 const char *fmt_str;
10636
10637 /* Verify the required arguments in the original call. */
10638 if (! arglist)
10639 return 0;
10640 dest = TREE_VALUE (arglist);
10641 if (! POINTER_TYPE_P (TREE_TYPE (dest)))
10642 return 0;
10643 arglist = TREE_CHAIN (arglist);
10644 if (! arglist)
10645 return 0;
10646 flag = TREE_VALUE (arglist);
10647 if (TREE_CODE (TREE_TYPE (flag)) != INTEGER_TYPE)
10648 return 0;
10649 arglist = TREE_CHAIN (arglist);
10650 if (! arglist)
10651 return 0;
10652 size = TREE_VALUE (arglist);
10653 if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE)
10654 return 0;
10655 arglist = TREE_CHAIN (arglist);
10656 if (! arglist)
10657 return 0;
10658 fmt = TREE_VALUE (arglist);
10659 if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
10660 return 0;
10661 arglist = TREE_CHAIN (arglist);
10662
10663 if (! host_integerp (size, 1))
10664 return 0;
10665
10666 len = NULL_TREE;
10667
10668 if (!init_target_chars())
10669 return 0;
10670
10671 /* Check whether the format is a literal string constant. */
10672 fmt_str = c_getstr (fmt);
10673 if (fmt_str != NULL)
10674 {
10675 /* If the format doesn't contain % args or %%, we know the size. */
10676 if (strchr (fmt_str, target_percent) == 0)
10677 {
10678 if (fcode != BUILT_IN_SPRINTF_CHK || arglist == NULL_TREE)
10679 len = build_int_cstu (size_type_node, strlen (fmt_str));
10680 }
10681 /* If the format is "%s" and first ... argument is a string literal,
10682 we know the size too. */
10683 else if (fcode == BUILT_IN_SPRINTF_CHK && strcmp (fmt_str, target_percent_s) == 0)
10684 {
10685 tree arg;
10686
10687 if (arglist && !TREE_CHAIN (arglist))
10688 {
10689 arg = TREE_VALUE (arglist);
10690 if (POINTER_TYPE_P (TREE_TYPE (arg)))
10691 {
10692 len = c_strlen (arg, 1);
10693 if (! len || ! host_integerp (len, 1))
10694 len = NULL_TREE;
10695 }
10696 }
10697 }
10698 }
10699
10700 if (! integer_all_onesp (size))
10701 {
10702 if (! len || ! tree_int_cst_lt (len, size))
10703 return 0;
10704 }
10705
10706 /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
10707 or if format doesn't contain % chars or is "%s". */
10708 if (! integer_zerop (flag))
10709 {
10710 if (fmt_str == NULL)
10711 return 0;
10712 if (strchr (fmt_str, target_percent) != NULL && strcmp (fmt_str, target_percent_s))
10713 return 0;
10714 }
10715
10716 arglist = tree_cons (NULL_TREE, fmt, arglist);
10717 arglist = tree_cons (NULL_TREE, dest, arglist);
10718
10719 /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available. */
10720 fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
10721 ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
10722 if (!fn)
10723 return 0;
10724
10725 return build_function_call_expr (fn, arglist);
10726 }
10727
10728 /* Fold a call to {,v}snprintf with argument list ARGLIST. Return 0 if
10729 a normal call should be emitted rather than expanding the function
10730 inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
10731 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
10732 passed as second argument. */
10733
10734 tree
10735 fold_builtin_snprintf_chk (tree arglist, tree maxlen,
10736 enum built_in_function fcode)
10737 {
10738 tree dest, size, len, fn, fmt, flag;
10739 const char *fmt_str;
10740
10741 /* Verify the required arguments in the original call. */
10742 if (! arglist)
10743 return 0;
10744 dest = TREE_VALUE (arglist);
10745 if (! POINTER_TYPE_P (TREE_TYPE (dest)))
10746 return 0;
10747 arglist = TREE_CHAIN (arglist);
10748 if (! arglist)
10749 return 0;
10750 len = TREE_VALUE (arglist);
10751 if (TREE_CODE (TREE_TYPE (len)) != INTEGER_TYPE)
10752 return 0;
10753 arglist = TREE_CHAIN (arglist);
10754 if (! arglist)
10755 return 0;
10756 flag = TREE_VALUE (arglist);
10757 if (TREE_CODE (TREE_TYPE (len)) != INTEGER_TYPE)
10758 return 0;
10759 arglist = TREE_CHAIN (arglist);
10760 if (! arglist)
10761 return 0;
10762 size = TREE_VALUE (arglist);
10763 if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE)
10764 return 0;
10765 arglist = TREE_CHAIN (arglist);
10766 if (! arglist)
10767 return 0;
10768 fmt = TREE_VALUE (arglist);
10769 if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
10770 return 0;
10771 arglist = TREE_CHAIN (arglist);
10772
10773 if (! host_integerp (size, 1))
10774 return 0;
10775
10776 if (! integer_all_onesp (size))
10777 {
10778 if (! host_integerp (len, 1))
10779 {
10780 /* If LEN is not constant, try MAXLEN too.
10781 For MAXLEN only allow optimizing into non-_ocs function
10782 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
10783 if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
10784 return 0;
10785 }
10786 else
10787 maxlen = len;
10788
10789 if (tree_int_cst_lt (size, maxlen))
10790 return 0;
10791 }
10792
10793 if (!init_target_chars())
10794 return 0;
10795
10796 /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
10797 or if format doesn't contain % chars or is "%s". */
10798 if (! integer_zerop (flag))
10799 {
10800 fmt_str = c_getstr (fmt);
10801 if (fmt_str == NULL)
10802 return 0;
10803 if (strchr (fmt_str, target_percent) != NULL && strcmp (fmt_str, target_percent_s))
10804 return 0;
10805 }
10806
10807 arglist = tree_cons (NULL_TREE, fmt, arglist);
10808 arglist = tree_cons (NULL_TREE, len, arglist);
10809 arglist = tree_cons (NULL_TREE, dest, arglist);
10810
10811 /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
10812 available. */
10813 fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
10814 ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
10815 if (!fn)
10816 return 0;
10817
10818 return build_function_call_expr (fn, arglist);
10819 }
10820
10821 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
10822
10823 Return 0 if no simplification was possible, otherwise return the
10824 simplified form of the call as a tree. FCODE is the BUILT_IN_*
10825 code of the function to be simplified. */
10826
10827 static tree
10828 fold_builtin_printf (tree fndecl, tree arglist, bool ignore,
10829 enum built_in_function fcode)
10830 {
10831 tree fmt, fn = NULL_TREE, fn_putchar, fn_puts, arg, call;
10832 const char *fmt_str = NULL;
10833
10834 /* If the return value is used, don't do the transformation. */
10835 if (! ignore)
10836 return 0;
10837
10838 /* Verify the required arguments in the original call. */
10839 if (fcode == BUILT_IN_PRINTF_CHK || fcode == BUILT_IN_VPRINTF_CHK)
10840 {
10841 tree flag;
10842
10843 if (! arglist)
10844 return 0;
10845 flag = TREE_VALUE (arglist);
10846 if (TREE_CODE (TREE_TYPE (flag)) != INTEGER_TYPE
10847 || TREE_SIDE_EFFECTS (flag))
10848 return 0;
10849 arglist = TREE_CHAIN (arglist);
10850 }
10851
10852 if (! arglist)
10853 return 0;
10854 fmt = TREE_VALUE (arglist);
10855 if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
10856 return 0;
10857 arglist = TREE_CHAIN (arglist);
10858
10859 /* Check whether the format is a literal string constant. */
10860 fmt_str = c_getstr (fmt);
10861 if (fmt_str == NULL)
10862 return NULL_TREE;
10863
10864 if (fcode == BUILT_IN_PRINTF_UNLOCKED)
10865 {
10866 /* If we're using an unlocked function, assume the other
10867 unlocked functions exist explicitly. */
10868 fn_putchar = built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED];
10869 fn_puts = built_in_decls[BUILT_IN_PUTS_UNLOCKED];
10870 }
10871 else
10872 {
10873 fn_putchar = implicit_built_in_decls[BUILT_IN_PUTCHAR];
10874 fn_puts = implicit_built_in_decls[BUILT_IN_PUTS];
10875 }
10876
10877 if (!init_target_chars())
10878 return 0;
10879
10880 if (strcmp (fmt_str, target_percent_s) == 0 || strchr (fmt_str, target_percent) == NULL)
10881 {
10882 const char *str;
10883
10884 if (strcmp (fmt_str, target_percent_s) == 0)
10885 {
10886 if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
10887 return 0;
10888
10889 if (! arglist
10890 || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist)))
10891 || TREE_CHAIN (arglist))
10892 return 0;
10893
10894 str = c_getstr (TREE_VALUE (arglist));
10895 if (str == NULL)
10896 return 0;
10897 }
10898 else
10899 {
10900 /* The format specifier doesn't contain any '%' characters. */
10901 if (fcode != BUILT_IN_VPRINTF && fcode != BUILT_IN_VPRINTF_CHK
10902 && arglist)
10903 return 0;
10904 str = fmt_str;
10905 }
10906
10907 /* If the string was "", printf does nothing. */
10908 if (str[0] == '\0')
10909 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
10910
10911 /* If the string has length of 1, call putchar. */
10912 if (str[1] == '\0')
10913 {
10914 /* Given printf("c"), (where c is any one character,)
10915 convert "c"[0] to an int and pass that to the replacement
10916 function. */
10917 arg = build_int_cst (NULL_TREE, str[0]);
10918 arglist = build_tree_list (NULL_TREE, arg);
10919 fn = fn_putchar;
10920 }
10921 else
10922 {
10923 /* If the string was "string\n", call puts("string"). */
10924 size_t len = strlen (str);
10925 if ((unsigned char)str[len - 1] == target_newline)
10926 {
10927 /* Create a NUL-terminated string that's one char shorter
10928 than the original, stripping off the trailing '\n'. */
10929 char *newstr = alloca (len);
10930 memcpy (newstr, str, len - 1);
10931 newstr[len - 1] = 0;
10932
10933 arg = build_string_literal (len, newstr);
10934 arglist = build_tree_list (NULL_TREE, arg);
10935 fn = fn_puts;
10936 }
10937 else
10938 /* We'd like to arrange to call fputs(string,stdout) here,
10939 but we need stdout and don't have a way to get it yet. */
10940 return 0;
10941 }
10942 }
10943
10944 /* The other optimizations can be done only on the non-va_list variants. */
10945 else if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
10946 return 0;
10947
10948 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
10949 else if (strcmp (fmt_str, target_percent_s_newline) == 0)
10950 {
10951 if (! arglist
10952 || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist)))
10953 || TREE_CHAIN (arglist))
10954 return 0;
10955 fn = fn_puts;
10956 }
10957
10958 /* If the format specifier was "%c", call __builtin_putchar(arg). */
10959 else if (strcmp (fmt_str, target_percent_c) == 0)
10960 {
10961 if (! arglist
10962 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE
10963 || TREE_CHAIN (arglist))
10964 return 0;
10965 fn = fn_putchar;
10966 }
10967
10968 if (!fn)
10969 return 0;
10970
10971 call = build_function_call_expr (fn, arglist);
10972 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), call);
10973 }
10974
10975 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
10976
10977 Return 0 if no simplification was possible, otherwise return the
10978 simplified form of the call as a tree. FCODE is the BUILT_IN_*
10979 code of the function to be simplified. */
10980
10981 static tree
10982 fold_builtin_fprintf (tree fndecl, tree arglist, bool ignore,
10983 enum built_in_function fcode)
10984 {
10985 tree fp, fmt, fn = NULL_TREE, fn_fputc, fn_fputs, arg, call;
10986 const char *fmt_str = NULL;
10987
10988 /* If the return value is used, don't do the transformation. */
10989 if (! ignore)
10990 return 0;
10991
10992 /* Verify the required arguments in the original call. */
10993 if (! arglist)
10994 return 0;
10995 fp = TREE_VALUE (arglist);
10996 if (! POINTER_TYPE_P (TREE_TYPE (fp)))
10997 return 0;
10998 arglist = TREE_CHAIN (arglist);
10999
11000 if (fcode == BUILT_IN_FPRINTF_CHK || fcode == BUILT_IN_VFPRINTF_CHK)
11001 {
11002 tree flag;
11003
11004 if (! arglist)
11005 return 0;
11006 flag = TREE_VALUE (arglist);
11007 if (TREE_CODE (TREE_TYPE (flag)) != INTEGER_TYPE
11008 || TREE_SIDE_EFFECTS (flag))
11009 return 0;
11010 arglist = TREE_CHAIN (arglist);
11011 }
11012
11013 if (! arglist)
11014 return 0;
11015 fmt = TREE_VALUE (arglist);
11016 if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
11017 return 0;
11018 arglist = TREE_CHAIN (arglist);
11019
11020 /* Check whether the format is a literal string constant. */
11021 fmt_str = c_getstr (fmt);
11022 if (fmt_str == NULL)
11023 return NULL_TREE;
11024
11025 if (fcode == BUILT_IN_FPRINTF_UNLOCKED)
11026 {
11027 /* If we're using an unlocked function, assume the other
11028 unlocked functions exist explicitly. */
11029 fn_fputc = built_in_decls[BUILT_IN_FPUTC_UNLOCKED];
11030 fn_fputs = built_in_decls[BUILT_IN_FPUTS_UNLOCKED];
11031 }
11032 else
11033 {
11034 fn_fputc = implicit_built_in_decls[BUILT_IN_FPUTC];
11035 fn_fputs = implicit_built_in_decls[BUILT_IN_FPUTS];
11036 }
11037
11038 if (!init_target_chars())
11039 return 0;
11040
11041 /* If the format doesn't contain % args or %%, use strcpy. */
11042 if (strchr (fmt_str, target_percent) == NULL)
11043 {
11044 if (fcode != BUILT_IN_VFPRINTF && fcode != BUILT_IN_VFPRINTF_CHK
11045 && arglist)
11046 return 0;
11047
11048 /* If the format specifier was "", fprintf does nothing. */
11049 if (fmt_str[0] == '\0')
11050 {
11051 /* If FP has side-effects, just wait until gimplification is
11052 done. */
11053 if (TREE_SIDE_EFFECTS (fp))
11054 return 0;
11055
11056 return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
11057 }
11058
11059 /* When "string" doesn't contain %, replace all cases of
11060 fprintf (fp, string) with fputs (string, fp). The fputs
11061 builtin will take care of special cases like length == 1. */
11062 arglist = build_tree_list (NULL_TREE, fp);
11063 arglist = tree_cons (NULL_TREE, fmt, arglist);
11064 fn = fn_fputs;
11065 }
11066
11067 /* The other optimizations can be done only on the non-va_list variants. */
11068 else if (fcode == BUILT_IN_VFPRINTF || fcode == BUILT_IN_VFPRINTF_CHK)
11069 return 0;
11070
11071 /* If the format specifier was "%s", call __builtin_fputs (arg, fp). */
11072 else if (strcmp (fmt_str, target_percent_s) == 0)
11073 {
11074 if (! arglist
11075 || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist)))
11076 || TREE_CHAIN (arglist))
11077 return 0;
11078 arg = TREE_VALUE (arglist);
11079 arglist = build_tree_list (NULL_TREE, fp);
11080 arglist = tree_cons (NULL_TREE, arg, arglist);
11081 fn = fn_fputs;
11082 }
11083
11084 /* If the format specifier was "%c", call __builtin_fputc (arg, fp). */
11085 else if (strcmp (fmt_str, target_percent_c) == 0)
11086 {
11087 if (! arglist
11088 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE
11089 || TREE_CHAIN (arglist))
11090 return 0;
11091 arg = TREE_VALUE (arglist);
11092 arglist = build_tree_list (NULL_TREE, fp);
11093 arglist = tree_cons (NULL_TREE, arg, arglist);
11094 fn = fn_fputc;
11095 }
11096
11097 if (!fn)
11098 return 0;
11099
11100 call = build_function_call_expr (fn, arglist);
11101 return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), call);
11102 }
11103
11104 /* Initialize format string characters in the target charset. */
11105
11106 static bool
11107 init_target_chars (void)
11108 {
11109 static bool init;
11110 if (!init)
11111 {
11112 target_newline = lang_hooks.to_target_charset ('\n');
11113 target_percent = lang_hooks.to_target_charset ('%');
11114 target_c = lang_hooks.to_target_charset ('c');
11115 target_s = lang_hooks.to_target_charset ('s');
11116 if (target_newline == 0 || target_percent == 0 || target_c == 0
11117 || target_s == 0)
11118 return false;
11119
11120 target_percent_c[0] = target_percent;
11121 target_percent_c[1] = target_c;
11122 target_percent_c[2] = '\0';
11123
11124 target_percent_s[0] = target_percent;
11125 target_percent_s[1] = target_s;
11126 target_percent_s[2] = '\0';
11127
11128 target_percent_s_newline[0] = target_percent;
11129 target_percent_s_newline[1] = target_s;
11130 target_percent_s_newline[2] = target_newline;
11131 target_percent_s_newline[3] = '\0';
11132
11133 init = true;
11134 }
11135 return true;
11136 }