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