1 /* Expand builtin functions.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
30 #include "hard-reg-set.h"
33 #include "insn-config.h"
39 #include "typeclass.h"
45 #define CALLED_AS_BUILT_IN(NODE) \
46 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
48 /* Register mappings for target machines without register windows. */
49 #ifndef INCOMING_REGNO
50 #define INCOMING_REGNO(OUT) (OUT)
52 #ifndef OUTGOING_REGNO
53 #define OUTGOING_REGNO(IN) (IN)
56 #ifndef PAD_VARARGS_DOWN
57 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
60 /* Define the names of the builtin function types and codes. */
61 const char *const built_in_class_names
[4]
62 = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
64 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA) STRINGX(X),
65 const char *const built_in_names
[(int) END_BUILTINS
] =
67 #include "builtins.def"
71 /* Setup an array of _DECL trees, make sure each element is
72 initialized to NULL_TREE. */
73 tree built_in_decls
[(int) END_BUILTINS
];
75 tree (*lang_type_promotes_to
) PARAMS ((tree
));
77 static int get_pointer_alignment
PARAMS ((tree
, unsigned int));
78 static tree c_strlen
PARAMS ((tree
));
79 static const char *c_getstr
PARAMS ((tree
));
80 static rtx c_readstr
PARAMS ((const char *,
82 static int target_char_cast
PARAMS ((tree
, char *));
83 static rtx get_memory_rtx
PARAMS ((tree
));
84 static int apply_args_size
PARAMS ((void));
85 static int apply_result_size
PARAMS ((void));
86 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
87 static rtx result_vector
PARAMS ((int, rtx
));
89 static rtx expand_builtin_setjmp
PARAMS ((tree
, rtx
));
90 static void expand_builtin_prefetch
PARAMS ((tree
));
91 static rtx expand_builtin_apply_args
PARAMS ((void));
92 static rtx expand_builtin_apply_args_1
PARAMS ((void));
93 static rtx expand_builtin_apply
PARAMS ((rtx
, rtx
, rtx
));
94 static void expand_builtin_return
PARAMS ((rtx
));
95 static enum type_class type_to_class
PARAMS ((tree
));
96 static rtx expand_builtin_classify_type
PARAMS ((tree
));
97 static rtx expand_builtin_mathfn
PARAMS ((tree
, rtx
, rtx
));
98 static rtx expand_builtin_constant_p
PARAMS ((tree
));
99 static rtx expand_builtin_args_info
PARAMS ((tree
));
100 static rtx expand_builtin_next_arg
PARAMS ((tree
));
101 static rtx expand_builtin_va_start
PARAMS ((int, tree
));
102 static rtx expand_builtin_va_end
PARAMS ((tree
));
103 static rtx expand_builtin_va_copy
PARAMS ((tree
));
104 static rtx expand_builtin_memcmp
PARAMS ((tree
, tree
, rtx
,
106 static rtx expand_builtin_strcmp
PARAMS ((tree
, rtx
,
108 static rtx expand_builtin_strncmp
PARAMS ((tree
, rtx
,
110 static rtx builtin_memcpy_read_str
PARAMS ((PTR
, HOST_WIDE_INT
,
112 static rtx expand_builtin_strcat
PARAMS ((tree
, rtx
,
114 static rtx expand_builtin_strncat
PARAMS ((tree
, rtx
,
116 static rtx expand_builtin_strspn
PARAMS ((tree
, rtx
,
118 static rtx expand_builtin_strcspn
PARAMS ((tree
, rtx
,
120 static rtx expand_builtin_memcpy
PARAMS ((tree
, rtx
,
122 static rtx expand_builtin_strcpy
PARAMS ((tree
, rtx
,
124 static rtx builtin_strncpy_read_str
PARAMS ((PTR
, HOST_WIDE_INT
,
126 static rtx expand_builtin_strncpy
PARAMS ((tree
, rtx
,
128 static rtx builtin_memset_read_str
PARAMS ((PTR
, HOST_WIDE_INT
,
130 static rtx expand_builtin_memset
PARAMS ((tree
, rtx
,
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
,
136 static rtx expand_builtin_strpbrk
PARAMS ((tree
, rtx
,
138 static rtx expand_builtin_strchr
PARAMS ((tree
, rtx
,
140 static rtx expand_builtin_strrchr
PARAMS ((tree
, rtx
,
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, 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 static tree fold_builtin_classify_type
PARAMS ((tree
));
150 static tree build_function_call_expr
PARAMS ((tree
, tree
));
151 static int validate_arglist
PARAMS ((tree
, ...));
153 /* Return the alignment in bits of EXP, a pointer valued expression.
154 But don't return more than MAX_ALIGN no matter what.
155 The alignment returned is, by default, the alignment of the thing that
156 EXP points to. If it is not a POINTER_TYPE, 0 is returned.
158 Otherwise, look at the expression to see if we can do better, i.e., if the
159 expression is actually pointing at an object whose alignment is tighter. */
162 get_pointer_alignment (exp
, max_align
)
164 unsigned int max_align
;
166 unsigned int align
, inner
;
168 if (TREE_CODE (TREE_TYPE (exp
)) != POINTER_TYPE
)
171 align
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp
)));
172 align
= MIN (align
, max_align
);
176 switch (TREE_CODE (exp
))
180 case NON_LVALUE_EXPR
:
181 exp
= TREE_OPERAND (exp
, 0);
182 if (TREE_CODE (TREE_TYPE (exp
)) != POINTER_TYPE
)
185 inner
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp
)));
186 align
= MIN (inner
, max_align
);
190 /* If sum of pointer + int, restrict our maximum alignment to that
191 imposed by the integer. If not, we can't do any better than
193 if (! host_integerp (TREE_OPERAND (exp
, 1), 1))
196 while (((tree_low_cst (TREE_OPERAND (exp
, 1), 1))
197 & (max_align
/ BITS_PER_UNIT
- 1))
201 exp
= TREE_OPERAND (exp
, 0);
205 /* See what we are pointing at and look at its alignment. */
206 exp
= TREE_OPERAND (exp
, 0);
207 if (TREE_CODE (exp
) == FUNCTION_DECL
)
208 align
= FUNCTION_BOUNDARY
;
209 else if (DECL_P (exp
))
210 align
= DECL_ALIGN (exp
);
211 #ifdef CONSTANT_ALIGNMENT
212 else if (TREE_CODE_CLASS (TREE_CODE (exp
)) == 'c')
213 align
= CONSTANT_ALIGNMENT (exp
, align
);
215 return MIN (align
, max_align
);
223 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
224 way, because it could contain a zero byte in the middle.
225 TREE_STRING_LENGTH is the size of the character array, not the string.
227 The value returned is of type `ssizetype'.
229 Unfortunately, string_constant can't access the values of const char
230 arrays with initializers, so neither can we do so here. */
237 HOST_WIDE_INT offset
;
241 src
= string_constant (src
, &offset_node
);
245 max
= TREE_STRING_LENGTH (src
) - 1;
246 ptr
= TREE_STRING_POINTER (src
);
248 if (offset_node
&& TREE_CODE (offset_node
) != INTEGER_CST
)
250 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
251 compute the offset to the following null if we don't know where to
252 start searching for it. */
255 for (i
= 0; i
< max
; i
++)
259 /* We don't know the starting offset, but we do know that the string
260 has no internal zero bytes. We can assume that the offset falls
261 within the bounds of the string; otherwise, the programmer deserves
262 what he gets. Subtract the offset from the length of the string,
263 and return that. This would perhaps not be valid if we were dealing
264 with named arrays in addition to literal string constants. */
266 return size_diffop (size_int (max
), offset_node
);
269 /* We have a known offset into the string. Start searching there for
270 a null character if we can represent it as a single HOST_WIDE_INT. */
271 if (offset_node
== 0)
273 else if (! host_integerp (offset_node
, 0))
276 offset
= tree_low_cst (offset_node
, 0);
278 /* If the offset is known to be out of bounds, warn, and call strlen at
280 if (offset
< 0 || offset
> max
)
282 warning ("offset outside bounds of constant string");
286 /* Use strlen to search for the first zero byte. Since any strings
287 constructed with build_string will have nulls appended, we win even
288 if we get handed something like (char[4])"abcd".
290 Since OFFSET is our starting index into the string, no further
291 calculation is needed. */
292 return ssize_int (strlen (ptr
+ offset
));
295 /* Return a char pointer for a C string if it is a string constant
296 or sum of string constant and integer constant. */
304 src
= string_constant (src
, &offset_node
);
308 if (offset_node
== 0)
309 return TREE_STRING_POINTER (src
);
310 else if (!host_integerp (offset_node
, 1)
311 || compare_tree_int (offset_node
, TREE_STRING_LENGTH (src
) - 1) > 0)
314 return TREE_STRING_POINTER (src
) + tree_low_cst (offset_node
, 1);
317 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
318 GET_MODE_BITSIZE (MODE) bits from string constant STR. */
321 c_readstr (str
, mode
)
323 enum machine_mode mode
;
329 if (GET_MODE_CLASS (mode
) != MODE_INT
)
334 for (i
= 0; i
< GET_MODE_SIZE (mode
); i
++)
337 if (WORDS_BIG_ENDIAN
)
338 j
= GET_MODE_SIZE (mode
) - i
- 1;
339 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
340 && GET_MODE_SIZE (mode
) > UNITS_PER_WORD
)
341 j
= j
+ UNITS_PER_WORD
- 2 * (j
% UNITS_PER_WORD
) - 1;
343 if (j
> 2 * HOST_BITS_PER_WIDE_INT
)
346 ch
= (unsigned char) str
[i
];
347 c
[j
/ HOST_BITS_PER_WIDE_INT
] |= ch
<< (j
% HOST_BITS_PER_WIDE_INT
);
349 return immed_double_const (c
[0], c
[1], mode
);
352 /* Cast a target constant CST to target CHAR and if that value fits into
353 host char type, return zero and put that value into variable pointed by
357 target_char_cast (cst
, p
)
361 unsigned HOST_WIDE_INT val
, hostval
;
363 if (!host_integerp (cst
, 1)
364 || CHAR_TYPE_SIZE
> HOST_BITS_PER_WIDE_INT
)
367 val
= tree_low_cst (cst
, 1);
368 if (CHAR_TYPE_SIZE
< HOST_BITS_PER_WIDE_INT
)
369 val
&= (((unsigned HOST_WIDE_INT
) 1) << CHAR_TYPE_SIZE
) - 1;
372 if (HOST_BITS_PER_CHAR
< HOST_BITS_PER_WIDE_INT
)
373 hostval
&= (((unsigned HOST_WIDE_INT
) 1) << HOST_BITS_PER_CHAR
) - 1;
382 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
383 times to get the address of either a higher stack frame, or a return
384 address located within it (depending on FNDECL_CODE). */
387 expand_builtin_return_addr (fndecl_code
, count
, tem
)
388 enum built_in_function fndecl_code
;
394 /* Some machines need special handling before we can access
395 arbitrary frames. For example, on the sparc, we must first flush
396 all register windows to the stack. */
397 #ifdef SETUP_FRAME_ADDRESSES
399 SETUP_FRAME_ADDRESSES ();
402 /* On the sparc, the return address is not in the frame, it is in a
403 register. There is no way to access it off of the current frame
404 pointer, but it can be accessed off the previous frame pointer by
405 reading the value from the register window save area. */
406 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
407 if (fndecl_code
== BUILT_IN_RETURN_ADDRESS
)
411 /* Scan back COUNT frames to the specified frame. */
412 for (i
= 0; i
< count
; i
++)
414 /* Assume the dynamic chain pointer is in the word that the
415 frame address points to, unless otherwise specified. */
416 #ifdef DYNAMIC_CHAIN_ADDRESS
417 tem
= DYNAMIC_CHAIN_ADDRESS (tem
);
419 tem
= memory_address (Pmode
, tem
);
420 tem
= gen_rtx_MEM (Pmode
, tem
);
421 set_mem_alias_set (tem
, get_frame_alias_set ());
422 tem
= copy_to_reg (tem
);
425 /* For __builtin_frame_address, return what we've got. */
426 if (fndecl_code
== BUILT_IN_FRAME_ADDRESS
)
429 /* For __builtin_return_address, Get the return address from that
431 #ifdef RETURN_ADDR_RTX
432 tem
= RETURN_ADDR_RTX (count
, tem
);
434 tem
= memory_address (Pmode
,
435 plus_constant (tem
, GET_MODE_SIZE (Pmode
)));
436 tem
= gen_rtx_MEM (Pmode
, tem
);
437 set_mem_alias_set (tem
, get_frame_alias_set ());
442 /* Alias set used for setjmp buffer. */
443 static HOST_WIDE_INT setjmp_alias_set
= -1;
445 /* Construct the leading half of a __builtin_setjmp call. Control will
446 return to RECEIVER_LABEL. This is used directly by sjlj exception
450 expand_builtin_setjmp_setup (buf_addr
, receiver_label
)
454 enum machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
458 if (setjmp_alias_set
== -1)
459 setjmp_alias_set
= new_alias_set ();
461 #ifdef POINTERS_EXTEND_UNSIGNED
462 if (GET_MODE (buf_addr
) != Pmode
)
463 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
466 buf_addr
= force_reg (Pmode
, force_operand (buf_addr
, NULL_RTX
));
470 /* We store the frame pointer and the address of receiver_label in
471 the buffer and use the rest of it for the stack save area, which
472 is machine-dependent. */
474 #ifndef BUILTIN_SETJMP_FRAME_VALUE
475 #define BUILTIN_SETJMP_FRAME_VALUE virtual_stack_vars_rtx
478 mem
= gen_rtx_MEM (Pmode
, buf_addr
);
479 set_mem_alias_set (mem
, setjmp_alias_set
);
480 emit_move_insn (mem
, BUILTIN_SETJMP_FRAME_VALUE
);
482 mem
= gen_rtx_MEM (Pmode
, plus_constant (buf_addr
, GET_MODE_SIZE (Pmode
))),
483 set_mem_alias_set (mem
, setjmp_alias_set
);
485 emit_move_insn (validize_mem (mem
),
486 force_reg (Pmode
, gen_rtx_LABEL_REF (Pmode
, receiver_label
)));
488 stack_save
= gen_rtx_MEM (sa_mode
,
489 plus_constant (buf_addr
,
490 2 * GET_MODE_SIZE (Pmode
)));
491 set_mem_alias_set (stack_save
, setjmp_alias_set
);
492 emit_stack_save (SAVE_NONLOCAL
, &stack_save
, NULL_RTX
);
494 /* If there is further processing to do, do it. */
495 #ifdef HAVE_builtin_setjmp_setup
496 if (HAVE_builtin_setjmp_setup
)
497 emit_insn (gen_builtin_setjmp_setup (buf_addr
));
500 /* Tell optimize_save_area_alloca that extra work is going to
501 need to go on during alloca. */
502 current_function_calls_setjmp
= 1;
504 /* Set this so all the registers get saved in our frame; we need to be
505 able to copy the saved values for any registers from frames we unwind. */
506 current_function_has_nonlocal_label
= 1;
509 /* Construct the trailing part of a __builtin_setjmp call.
510 This is used directly by sjlj exception handling code. */
513 expand_builtin_setjmp_receiver (receiver_label
)
514 rtx receiver_label ATTRIBUTE_UNUSED
;
516 /* Clobber the FP when we get here, so we have to make sure it's
517 marked as used by this function. */
518 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
520 /* Mark the static chain as clobbered here so life information
521 doesn't get messed up for it. */
522 emit_insn (gen_rtx_CLOBBER (VOIDmode
, static_chain_rtx
));
524 /* Now put in the code to restore the frame pointer, and argument
525 pointer, if needed. The code below is from expand_end_bindings
526 in stmt.c; see detailed documentation there. */
527 #ifdef HAVE_nonlocal_goto
528 if (! HAVE_nonlocal_goto
)
530 emit_move_insn (virtual_stack_vars_rtx
, hard_frame_pointer_rtx
);
532 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
533 if (fixed_regs
[ARG_POINTER_REGNUM
])
535 #ifdef ELIMINABLE_REGS
537 static const struct elims
{const int from
, to
;} elim_regs
[] = ELIMINABLE_REGS
;
539 for (i
= 0; i
< ARRAY_SIZE (elim_regs
); i
++)
540 if (elim_regs
[i
].from
== ARG_POINTER_REGNUM
541 && elim_regs
[i
].to
== HARD_FRAME_POINTER_REGNUM
)
544 if (i
== ARRAY_SIZE (elim_regs
))
547 /* Now restore our arg pointer from the address at which it
548 was saved in our stack frame. */
549 emit_move_insn (virtual_incoming_args_rtx
,
550 copy_to_reg (get_arg_pointer_save_area (cfun
)));
555 #ifdef HAVE_builtin_setjmp_receiver
556 if (HAVE_builtin_setjmp_receiver
)
557 emit_insn (gen_builtin_setjmp_receiver (receiver_label
));
560 #ifdef HAVE_nonlocal_goto_receiver
561 if (HAVE_nonlocal_goto_receiver
)
562 emit_insn (gen_nonlocal_goto_receiver ());
567 /* @@@ This is a kludge. Not all machine descriptions define a blockage
568 insn, but we must not allow the code we just generated to be reordered
569 by scheduling. Specifically, the update of the frame pointer must
570 happen immediately, not later. So emit an ASM_INPUT to act as blockage
572 emit_insn (gen_rtx_ASM_INPUT (VOIDmode
, ""));
575 /* __builtin_setjmp is passed a pointer to an array of five words (not
576 all will be used on all machines). It operates similarly to the C
577 library function of the same name, but is more efficient. Much of
578 the code below (and for longjmp) is copied from the handling of
581 NOTE: This is intended for use by GNAT and the exception handling
582 scheme in the compiler and will only work in the method used by
586 expand_builtin_setjmp (arglist
, target
)
590 rtx buf_addr
, next_lab
, cont_lab
;
592 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
595 if (target
== 0 || GET_CODE (target
) != REG
596 || REGNO (target
) < FIRST_PSEUDO_REGISTER
)
597 target
= gen_reg_rtx (TYPE_MODE (integer_type_node
));
599 buf_addr
= expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
601 next_lab
= gen_label_rtx ();
602 cont_lab
= gen_label_rtx ();
604 expand_builtin_setjmp_setup (buf_addr
, next_lab
);
606 /* Set TARGET to zero and branch to the continue label. */
607 emit_move_insn (target
, const0_rtx
);
608 emit_jump_insn (gen_jump (cont_lab
));
610 emit_label (next_lab
);
612 expand_builtin_setjmp_receiver (next_lab
);
614 /* Set TARGET to one. */
615 emit_move_insn (target
, const1_rtx
);
616 emit_label (cont_lab
);
618 /* Tell flow about the strange goings on. Putting `next_lab' on
619 `nonlocal_goto_handler_labels' to indicates that function
620 calls may traverse the arc back to this label. */
622 current_function_has_nonlocal_label
= 1;
623 nonlocal_goto_handler_labels
624 = gen_rtx_EXPR_LIST (VOIDmode
, next_lab
, nonlocal_goto_handler_labels
);
629 /* __builtin_longjmp is passed a pointer to an array of five words (not
630 all will be used on all machines). It operates similarly to the C
631 library function of the same name, but is more efficient. Much of
632 the code below is copied from the handling of non-local gotos.
634 NOTE: This is intended for use by GNAT and the exception handling
635 scheme in the compiler and will only work in the method used by
639 expand_builtin_longjmp (buf_addr
, value
)
642 rtx fp
, lab
, stack
, insn
;
643 enum machine_mode sa_mode
= STACK_SAVEAREA_MODE (SAVE_NONLOCAL
);
645 if (setjmp_alias_set
== -1)
646 setjmp_alias_set
= new_alias_set ();
648 #ifdef POINTERS_EXTEND_UNSIGNED
649 if (GET_MODE (buf_addr
) != Pmode
)
650 buf_addr
= convert_memory_address (Pmode
, buf_addr
);
653 buf_addr
= force_reg (Pmode
, buf_addr
);
655 /* We used to store value in static_chain_rtx, but that fails if pointers
656 are smaller than integers. We instead require that the user must pass
657 a second argument of 1, because that is what builtin_setjmp will
658 return. This also makes EH slightly more efficient, since we are no
659 longer copying around a value that we don't care about. */
660 if (value
!= const1_rtx
)
663 current_function_calls_longjmp
= 1;
665 #ifdef HAVE_builtin_longjmp
666 if (HAVE_builtin_longjmp
)
667 emit_insn (gen_builtin_longjmp (buf_addr
));
671 fp
= gen_rtx_MEM (Pmode
, buf_addr
);
672 lab
= gen_rtx_MEM (Pmode
, plus_constant (buf_addr
,
673 GET_MODE_SIZE (Pmode
)));
675 stack
= gen_rtx_MEM (sa_mode
, plus_constant (buf_addr
,
676 2 * GET_MODE_SIZE (Pmode
)));
677 set_mem_alias_set (fp
, setjmp_alias_set
);
678 set_mem_alias_set (lab
, setjmp_alias_set
);
679 set_mem_alias_set (stack
, setjmp_alias_set
);
681 /* Pick up FP, label, and SP from the block and jump. This code is
682 from expand_goto in stmt.c; see there for detailed comments. */
683 #if HAVE_nonlocal_goto
684 if (HAVE_nonlocal_goto
)
685 /* We have to pass a value to the nonlocal_goto pattern that will
686 get copied into the static_chain pointer, but it does not matter
687 what that value is, because builtin_setjmp does not use it. */
688 emit_insn (gen_nonlocal_goto (value
, lab
, stack
, fp
));
692 lab
= copy_to_reg (lab
);
694 emit_move_insn (hard_frame_pointer_rtx
, fp
);
695 emit_stack_restore (SAVE_NONLOCAL
, stack
, NULL_RTX
);
697 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
698 emit_insn (gen_rtx_USE (VOIDmode
, stack_pointer_rtx
));
699 emit_indirect_jump (lab
);
703 /* Search backwards and mark the jump insn as a non-local goto.
704 Note that this precludes the use of __builtin_longjmp to a
705 __builtin_setjmp target in the same function. However, we've
706 already cautioned the user that these functions are for
707 internal exception handling use only. */
708 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
710 if (GET_CODE (insn
) == JUMP_INSN
)
712 REG_NOTES (insn
) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO
, const0_rtx
,
716 else if (GET_CODE (insn
) == CALL_INSN
)
721 /* Expand a call to __builtin_prefetch. For a target that does not support
722 data prefetch, evaluate the memory address argument in case it has side
726 expand_builtin_prefetch (arglist
)
729 tree arg0
, arg1
, arg2
;
732 if (!validate_arglist (arglist
, POINTER_TYPE
, 0))
735 arg0
= TREE_VALUE (arglist
);
736 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
737 zero (read) and argument 2 (locality) defaults to 3 (high degree of
739 if (TREE_CHAIN (arglist
))
741 arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
742 if (TREE_CHAIN (TREE_CHAIN (arglist
)))
743 arg2
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
745 arg2
= build_int_2 (3, 0);
749 arg1
= integer_zero_node
;
750 arg2
= build_int_2 (3, 0);
753 /* Argument 0 is an address. */
754 op0
= expand_expr (arg0
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
756 /* Argument 1 (read/write flag) must be a compile-time constant int. */
757 if (TREE_CODE (arg1
) != INTEGER_CST
)
759 error ("second arg to `__builtin_prefetch' must be a constant");
760 arg1
= integer_zero_node
;
762 op1
= expand_expr (arg1
, NULL_RTX
, VOIDmode
, 0);
763 /* Argument 1 must be either zero or one. */
764 if (INTVAL (op1
) != 0 && INTVAL (op1
) != 1)
766 warning ("invalid second arg to __builtin_prefetch; using zero");
770 /* Argument 2 (locality) must be a compile-time constant int. */
771 if (TREE_CODE (arg2
) != INTEGER_CST
)
773 error ("third arg to `__builtin_prefetch' must be a constant");
774 arg2
= integer_zero_node
;
776 op2
= expand_expr (arg2
, NULL_RTX
, VOIDmode
, 0);
777 /* Argument 2 must be 0, 1, 2, or 3. */
778 if (INTVAL (op2
) < 0 || INTVAL (op2
) > 3)
780 warning ("invalid third arg to __builtin_prefetch; using zero");
787 if (! (*insn_data
[(int)CODE_FOR_prefetch
].operand
[0].predicate
)
789 insn_data
[(int)CODE_FOR_prefetch
].operand
[0].mode
))
790 op0
= force_reg (Pmode
, op0
);
791 emit_insn (gen_prefetch (op0
, op1
, op2
));
795 op0
= protect_from_queue (op0
, 0);
796 /* Don't do anything with direct references to volatile memory, but
797 generate code to handle other side effects. */
798 if (GET_CODE (op0
) != MEM
&& side_effects_p (op0
))
802 /* Get a MEM rtx for expression EXP which is the address of an operand
803 to be used to be used in a string instruction (cmpstrsi, movstrsi, ..). */
809 rtx addr
= expand_expr (exp
, NULL_RTX
, ptr_mode
, EXPAND_SUM
);
812 #ifdef POINTERS_EXTEND_UNSIGNED
813 if (GET_MODE (addr
) != Pmode
)
814 addr
= convert_memory_address (Pmode
, addr
);
817 mem
= gen_rtx_MEM (BLKmode
, memory_address (BLKmode
, addr
));
819 /* Get an expression we can use to find the attributes to assign to MEM.
820 If it is an ADDR_EXPR, use the operand. Otherwise, dereference it if
821 we can. First remove any nops. */
822 while ((TREE_CODE (exp
) == NOP_EXPR
|| TREE_CODE (exp
) == CONVERT_EXPR
823 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
824 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp
, 0))))
825 exp
= TREE_OPERAND (exp
, 0);
827 if (TREE_CODE (exp
) == ADDR_EXPR
)
829 exp
= TREE_OPERAND (exp
, 0);
830 set_mem_attributes (mem
, exp
, 0);
832 else if (POINTER_TYPE_P (TREE_TYPE (exp
)))
834 exp
= build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (exp
)), exp
);
835 /* memcpy, memset and other builtin stringops can alias with anything. */
836 set_mem_alias_set (mem
, 0);
842 /* Built-in functions to perform an untyped call and return. */
844 /* For each register that may be used for calling a function, this
845 gives a mode used to copy the register's value. VOIDmode indicates
846 the register is not used for calling a function. If the machine
847 has register windows, this gives only the outbound registers.
848 INCOMING_REGNO gives the corresponding inbound register. */
849 static enum machine_mode apply_args_mode
[FIRST_PSEUDO_REGISTER
];
851 /* For each register that may be used for returning values, this gives
852 a mode used to copy the register's value. VOIDmode indicates the
853 register is not used for returning values. If the machine has
854 register windows, this gives only the outbound registers.
855 INCOMING_REGNO gives the corresponding inbound register. */
856 static enum machine_mode apply_result_mode
[FIRST_PSEUDO_REGISTER
];
858 /* For each register that may be used for calling a function, this
859 gives the offset of that register into the block returned by
860 __builtin_apply_args. 0 indicates that the register is not
861 used for calling a function. */
862 static int apply_args_reg_offset
[FIRST_PSEUDO_REGISTER
];
864 /* Return the offset of register REGNO into the block returned by
865 __builtin_apply_args. This is not declared static, since it is
866 needed in objc-act.c. */
869 apply_args_register_offset (regno
)
874 /* Arguments are always put in outgoing registers (in the argument
875 block) if such make sense. */
876 #ifdef OUTGOING_REGNO
877 regno
= OUTGOING_REGNO(regno
);
879 return apply_args_reg_offset
[regno
];
882 /* Return the size required for the block returned by __builtin_apply_args,
883 and initialize apply_args_mode. */
888 static int size
= -1;
891 enum machine_mode mode
;
893 /* The values computed by this function never change. */
896 /* The first value is the incoming arg-pointer. */
897 size
= GET_MODE_SIZE (Pmode
);
899 /* The second value is the structure value address unless this is
900 passed as an "invisible" first argument. */
901 if (struct_value_rtx
)
902 size
+= GET_MODE_SIZE (Pmode
);
904 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
905 if (FUNCTION_ARG_REGNO_P (regno
))
907 /* Search for the proper mode for copying this register's
908 value. I'm not sure this is right, but it works so far. */
909 enum machine_mode best_mode
= VOIDmode
;
911 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
913 mode
= GET_MODE_WIDER_MODE (mode
))
914 if (HARD_REGNO_MODE_OK (regno
, mode
)
915 && HARD_REGNO_NREGS (regno
, mode
) == 1)
918 if (best_mode
== VOIDmode
)
919 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_FLOAT
);
921 mode
= GET_MODE_WIDER_MODE (mode
))
922 if (HARD_REGNO_MODE_OK (regno
, mode
)
923 && have_insn_for (SET
, mode
))
926 if (best_mode
== VOIDmode
)
927 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_VECTOR_FLOAT
);
929 mode
= GET_MODE_WIDER_MODE (mode
))
930 if (HARD_REGNO_MODE_OK (regno
, mode
)
931 && have_insn_for (SET
, mode
))
934 if (best_mode
== VOIDmode
)
935 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_VECTOR_INT
);
937 mode
= GET_MODE_WIDER_MODE (mode
))
938 if (HARD_REGNO_MODE_OK (regno
, mode
)
939 && have_insn_for (SET
, mode
))
943 if (mode
== VOIDmode
)
946 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
947 if (size
% align
!= 0)
948 size
= CEIL (size
, align
) * align
;
949 apply_args_reg_offset
[regno
] = size
;
950 size
+= GET_MODE_SIZE (mode
);
951 apply_args_mode
[regno
] = mode
;
955 apply_args_mode
[regno
] = VOIDmode
;
956 apply_args_reg_offset
[regno
] = 0;
962 /* Return the size required for the block returned by __builtin_apply,
963 and initialize apply_result_mode. */
968 static int size
= -1;
970 enum machine_mode mode
;
972 /* The values computed by this function never change. */
977 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
978 if (FUNCTION_VALUE_REGNO_P (regno
))
980 /* Search for the proper mode for copying this register's
981 value. I'm not sure this is right, but it works so far. */
982 enum machine_mode best_mode
= VOIDmode
;
984 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
986 mode
= GET_MODE_WIDER_MODE (mode
))
987 if (HARD_REGNO_MODE_OK (regno
, mode
))
990 if (best_mode
== VOIDmode
)
991 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_FLOAT
);
993 mode
= GET_MODE_WIDER_MODE (mode
))
994 if (HARD_REGNO_MODE_OK (regno
, mode
)
995 && have_insn_for (SET
, mode
))
998 if (best_mode
== VOIDmode
)
999 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_VECTOR_FLOAT
);
1001 mode
= GET_MODE_WIDER_MODE (mode
))
1002 if (HARD_REGNO_MODE_OK (regno
, mode
)
1003 && have_insn_for (SET
, mode
))
1006 if (best_mode
== VOIDmode
)
1007 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_VECTOR_INT
);
1009 mode
= GET_MODE_WIDER_MODE (mode
))
1010 if (HARD_REGNO_MODE_OK (regno
, mode
)
1011 && have_insn_for (SET
, mode
))
1015 if (mode
== VOIDmode
)
1018 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1019 if (size
% align
!= 0)
1020 size
= CEIL (size
, align
) * align
;
1021 size
+= GET_MODE_SIZE (mode
);
1022 apply_result_mode
[regno
] = mode
;
1025 apply_result_mode
[regno
] = VOIDmode
;
1027 /* Allow targets that use untyped_call and untyped_return to override
1028 the size so that machine-specific information can be stored here. */
1029 #ifdef APPLY_RESULT_SIZE
1030 size
= APPLY_RESULT_SIZE
;
1036 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1037 /* Create a vector describing the result block RESULT. If SAVEP is true,
1038 the result block is used to save the values; otherwise it is used to
1039 restore the values. */
1042 result_vector (savep
, result
)
1046 int regno
, size
, align
, nelts
;
1047 enum machine_mode mode
;
1049 rtx
*savevec
= (rtx
*) alloca (FIRST_PSEUDO_REGISTER
* sizeof (rtx
));
1052 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1053 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1055 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1056 if (size
% align
!= 0)
1057 size
= CEIL (size
, align
) * align
;
1058 reg
= gen_rtx_REG (mode
, savep
? regno
: INCOMING_REGNO (regno
));
1059 mem
= adjust_address (result
, mode
, size
);
1060 savevec
[nelts
++] = (savep
1061 ? gen_rtx_SET (VOIDmode
, mem
, reg
)
1062 : gen_rtx_SET (VOIDmode
, reg
, mem
));
1063 size
+= GET_MODE_SIZE (mode
);
1065 return gen_rtx_PARALLEL (VOIDmode
, gen_rtvec_v (nelts
, savevec
));
1067 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1069 /* Save the state required to perform an untyped call with the same
1070 arguments as were passed to the current function. */
1073 expand_builtin_apply_args_1 ()
1076 int size
, align
, regno
;
1077 enum machine_mode mode
;
1079 /* Create a block where the arg-pointer, structure value address,
1080 and argument registers can be saved. */
1081 registers
= assign_stack_local (BLKmode
, apply_args_size (), -1);
1083 /* Walk past the arg-pointer and structure value address. */
1084 size
= GET_MODE_SIZE (Pmode
);
1085 if (struct_value_rtx
)
1086 size
+= GET_MODE_SIZE (Pmode
);
1088 /* Save each register used in calling a function to the block. */
1089 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1090 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1094 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1095 if (size
% align
!= 0)
1096 size
= CEIL (size
, align
) * align
;
1098 tem
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1100 emit_move_insn (adjust_address (registers
, mode
, size
), tem
);
1101 size
+= GET_MODE_SIZE (mode
);
1104 /* Save the arg pointer to the block. */
1105 emit_move_insn (adjust_address (registers
, Pmode
, 0),
1106 copy_to_reg (virtual_incoming_args_rtx
));
1107 size
= GET_MODE_SIZE (Pmode
);
1109 /* Save the structure value address unless this is passed as an
1110 "invisible" first argument. */
1111 if (struct_value_incoming_rtx
)
1113 emit_move_insn (adjust_address (registers
, Pmode
, size
),
1114 copy_to_reg (struct_value_incoming_rtx
));
1115 size
+= GET_MODE_SIZE (Pmode
);
1118 /* Return the address of the block. */
1119 return copy_addr_to_reg (XEXP (registers
, 0));
1122 /* __builtin_apply_args returns block of memory allocated on
1123 the stack into which is stored the arg pointer, structure
1124 value address, static chain, and all the registers that might
1125 possibly be used in performing a function call. The code is
1126 moved to the start of the function so the incoming values are
1130 expand_builtin_apply_args ()
1132 /* Don't do __builtin_apply_args more than once in a function.
1133 Save the result of the first call and reuse it. */
1134 if (apply_args_value
!= 0)
1135 return apply_args_value
;
1137 /* When this function is called, it means that registers must be
1138 saved on entry to this function. So we migrate the
1139 call to the first insn of this function. */
1144 temp
= expand_builtin_apply_args_1 ();
1148 apply_args_value
= temp
;
1150 /* Put the sequence after the NOTE that starts the function.
1151 If this is inside a SEQUENCE, make the outer-level insn
1152 chain current, so the code is placed at the start of the
1154 push_topmost_sequence ();
1155 emit_insns_before (seq
, NEXT_INSN (get_insns ()));
1156 pop_topmost_sequence ();
1161 /* Perform an untyped call and save the state required to perform an
1162 untyped return of whatever value was returned by the given function. */
1165 expand_builtin_apply (function
, arguments
, argsize
)
1166 rtx function
, arguments
, argsize
;
1168 int size
, align
, regno
;
1169 enum machine_mode mode
;
1170 rtx incoming_args
, result
, reg
, dest
, src
, call_insn
;
1171 rtx old_stack_level
= 0;
1172 rtx call_fusage
= 0;
1174 #ifdef POINTERS_EXTEND_UNSIGNED
1175 if (GET_MODE (arguments
) != Pmode
)
1176 arguments
= convert_memory_address (Pmode
, arguments
);
1179 /* Create a block where the return registers can be saved. */
1180 result
= assign_stack_local (BLKmode
, apply_result_size (), -1);
1182 /* Fetch the arg pointer from the ARGUMENTS block. */
1183 incoming_args
= gen_reg_rtx (Pmode
);
1184 emit_move_insn (incoming_args
, gen_rtx_MEM (Pmode
, arguments
));
1185 #ifndef STACK_GROWS_DOWNWARD
1186 incoming_args
= expand_simple_binop (Pmode
, MINUS
, incoming_args
, argsize
,
1187 incoming_args
, 0, OPTAB_LIB_WIDEN
);
1190 /* Perform postincrements before actually calling the function. */
1193 /* Push a new argument block and copy the arguments. Do not allow
1194 the (potential) memcpy call below to interfere with our stack
1196 do_pending_stack_adjust ();
1199 /* Save the stack with nonlocal if available */
1200 #ifdef HAVE_save_stack_nonlocal
1201 if (HAVE_save_stack_nonlocal
)
1202 emit_stack_save (SAVE_NONLOCAL
, &old_stack_level
, NULL_RTX
);
1205 emit_stack_save (SAVE_BLOCK
, &old_stack_level
, NULL_RTX
);
1207 /* Push a block of memory onto the stack to store the memory arguments.
1208 Save the address in a register, and copy the memory arguments. ??? I
1209 haven't figured out how the calling convention macros effect this,
1210 but it's likely that the source and/or destination addresses in
1211 the block copy will need updating in machine specific ways. */
1212 dest
= allocate_dynamic_stack_space (argsize
, 0, BITS_PER_UNIT
);
1213 dest
= gen_rtx_MEM (BLKmode
, dest
);
1214 set_mem_align (dest
, PARM_BOUNDARY
);
1215 src
= gen_rtx_MEM (BLKmode
, incoming_args
);
1216 set_mem_align (src
, PARM_BOUNDARY
);
1217 emit_block_move (dest
, src
, argsize
);
1219 /* Refer to the argument block. */
1221 arguments
= gen_rtx_MEM (BLKmode
, arguments
);
1222 set_mem_align (arguments
, PARM_BOUNDARY
);
1224 /* Walk past the arg-pointer and structure value address. */
1225 size
= GET_MODE_SIZE (Pmode
);
1226 if (struct_value_rtx
)
1227 size
+= GET_MODE_SIZE (Pmode
);
1229 /* Restore each of the registers previously saved. Make USE insns
1230 for each of these registers for use in making the call. */
1231 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1232 if ((mode
= apply_args_mode
[regno
]) != VOIDmode
)
1234 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1235 if (size
% align
!= 0)
1236 size
= CEIL (size
, align
) * align
;
1237 reg
= gen_rtx_REG (mode
, regno
);
1238 emit_move_insn (reg
, adjust_address (arguments
, mode
, size
));
1239 use_reg (&call_fusage
, reg
);
1240 size
+= GET_MODE_SIZE (mode
);
1243 /* Restore the structure value address unless this is passed as an
1244 "invisible" first argument. */
1245 size
= GET_MODE_SIZE (Pmode
);
1246 if (struct_value_rtx
)
1248 rtx value
= gen_reg_rtx (Pmode
);
1249 emit_move_insn (value
, adjust_address (arguments
, Pmode
, size
));
1250 emit_move_insn (struct_value_rtx
, value
);
1251 if (GET_CODE (struct_value_rtx
) == REG
)
1252 use_reg (&call_fusage
, struct_value_rtx
);
1253 size
+= GET_MODE_SIZE (Pmode
);
1256 /* All arguments and registers used for the call are set up by now! */
1257 function
= prepare_call_address (function
, NULL_TREE
, &call_fusage
, 0, 0);
1259 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1260 and we don't want to load it into a register as an optimization,
1261 because prepare_call_address already did it if it should be done. */
1262 if (GET_CODE (function
) != SYMBOL_REF
)
1263 function
= memory_address (FUNCTION_MODE
, function
);
1265 /* Generate the actual call instruction and save the return value. */
1266 #ifdef HAVE_untyped_call
1267 if (HAVE_untyped_call
)
1268 emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE
, function
),
1269 result
, result_vector (1, result
)));
1272 #ifdef HAVE_call_value
1273 if (HAVE_call_value
)
1277 /* Locate the unique return register. It is not possible to
1278 express a call that sets more than one return register using
1279 call_value; use untyped_call for that. In fact, untyped_call
1280 only needs to save the return registers in the given block. */
1281 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1282 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1285 abort (); /* HAVE_untyped_call required. */
1286 valreg
= gen_rtx_REG (mode
, regno
);
1289 emit_call_insn (GEN_CALL_VALUE (valreg
,
1290 gen_rtx_MEM (FUNCTION_MODE
, function
),
1291 const0_rtx
, NULL_RTX
, const0_rtx
));
1293 emit_move_insn (adjust_address (result
, GET_MODE (valreg
), 0), valreg
);
1299 /* Find the CALL insn we just emitted. */
1300 for (call_insn
= get_last_insn ();
1301 call_insn
&& GET_CODE (call_insn
) != CALL_INSN
;
1302 call_insn
= PREV_INSN (call_insn
))
1308 /* Put the register usage information on the CALL. If there is already
1309 some usage information, put ours at the end. */
1310 if (CALL_INSN_FUNCTION_USAGE (call_insn
))
1314 for (link
= CALL_INSN_FUNCTION_USAGE (call_insn
); XEXP (link
, 1) != 0;
1315 link
= XEXP (link
, 1))
1318 XEXP (link
, 1) = call_fusage
;
1321 CALL_INSN_FUNCTION_USAGE (call_insn
) = call_fusage
;
1323 /* Restore the stack. */
1324 #ifdef HAVE_save_stack_nonlocal
1325 if (HAVE_save_stack_nonlocal
)
1326 emit_stack_restore (SAVE_NONLOCAL
, old_stack_level
, NULL_RTX
);
1329 emit_stack_restore (SAVE_BLOCK
, old_stack_level
, NULL_RTX
);
1333 /* Return the address of the result block. */
1334 return copy_addr_to_reg (XEXP (result
, 0));
1337 /* Perform an untyped return. */
1340 expand_builtin_return (result
)
1343 int size
, align
, regno
;
1344 enum machine_mode mode
;
1346 rtx call_fusage
= 0;
1348 #ifdef POINTERS_EXTEND_UNSIGNED
1349 if (GET_MODE (result
) != Pmode
)
1350 result
= convert_memory_address (Pmode
, result
);
1353 apply_result_size ();
1354 result
= gen_rtx_MEM (BLKmode
, result
);
1356 #ifdef HAVE_untyped_return
1357 if (HAVE_untyped_return
)
1359 emit_jump_insn (gen_untyped_return (result
, result_vector (0, result
)));
1365 /* Restore the return value and note that each value is used. */
1367 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1368 if ((mode
= apply_result_mode
[regno
]) != VOIDmode
)
1370 align
= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
;
1371 if (size
% align
!= 0)
1372 size
= CEIL (size
, align
) * align
;
1373 reg
= gen_rtx_REG (mode
, INCOMING_REGNO (regno
));
1374 emit_move_insn (reg
, adjust_address (result
, mode
, size
));
1376 push_to_sequence (call_fusage
);
1377 emit_insn (gen_rtx_USE (VOIDmode
, reg
));
1378 call_fusage
= get_insns ();
1380 size
+= GET_MODE_SIZE (mode
);
1383 /* Put the USE insns before the return. */
1384 emit_insns (call_fusage
);
1386 /* Return whatever values was restored by jumping directly to the end
1388 expand_null_return ();
1391 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1393 static enum type_class
1394 type_to_class (type
)
1397 switch (TREE_CODE (type
))
1399 case VOID_TYPE
: return void_type_class
;
1400 case INTEGER_TYPE
: return integer_type_class
;
1401 case CHAR_TYPE
: return char_type_class
;
1402 case ENUMERAL_TYPE
: return enumeral_type_class
;
1403 case BOOLEAN_TYPE
: return boolean_type_class
;
1404 case POINTER_TYPE
: return pointer_type_class
;
1405 case REFERENCE_TYPE
: return reference_type_class
;
1406 case OFFSET_TYPE
: return offset_type_class
;
1407 case REAL_TYPE
: return real_type_class
;
1408 case COMPLEX_TYPE
: return complex_type_class
;
1409 case FUNCTION_TYPE
: return function_type_class
;
1410 case METHOD_TYPE
: return method_type_class
;
1411 case RECORD_TYPE
: return record_type_class
;
1413 case QUAL_UNION_TYPE
: return union_type_class
;
1414 case ARRAY_TYPE
: return (TYPE_STRING_FLAG (type
)
1415 ? string_type_class
: array_type_class
);
1416 case SET_TYPE
: return set_type_class
;
1417 case FILE_TYPE
: return file_type_class
;
1418 case LANG_TYPE
: return lang_type_class
;
1419 default: return no_type_class
;
1423 /* Expand a call to __builtin_classify_type with arguments found in
1427 expand_builtin_classify_type (arglist
)
1431 return GEN_INT (type_to_class (TREE_TYPE (TREE_VALUE (arglist
))));
1432 return GEN_INT (no_type_class
);
1435 /* Expand expression EXP, which is a call to __builtin_constant_p. */
1438 expand_builtin_constant_p (exp
)
1441 tree arglist
= TREE_OPERAND (exp
, 1);
1442 enum machine_mode value_mode
= TYPE_MODE (TREE_TYPE (exp
));
1447 arglist
= TREE_VALUE (arglist
);
1449 /* We have taken care of the easy cases during constant folding. This
1450 case is not obvious, so emit (constant_p_rtx (ARGLIST)) and let CSE get a
1451 chance to see if it can deduce whether ARGLIST is constant. */
1453 tmp
= expand_expr (arglist
, NULL_RTX
, VOIDmode
, 0);
1454 tmp
= gen_rtx_CONSTANT_P_RTX (value_mode
, tmp
);
1458 /* Expand a call to one of the builtin math functions (sin, cos, or sqrt).
1459 Return 0 if a normal call should be emitted rather than expanding the
1460 function in-line. EXP is the expression that is a call to the builtin
1461 function; if convenient, the result should be placed in TARGET.
1462 SUBTARGET may be used as the target for computing one of EXP's operands. */
1465 expand_builtin_mathfn (exp
, target
, subtarget
)
1467 rtx target
, subtarget
;
1469 optab builtin_optab
;
1471 tree fndecl
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
1472 tree arglist
= TREE_OPERAND (exp
, 1);
1473 enum machine_mode argmode
;
1475 if (!validate_arglist (arglist
, REAL_TYPE
, VOID_TYPE
))
1478 /* Stabilize and compute the argument. */
1479 if (TREE_CODE (TREE_VALUE (arglist
)) != VAR_DECL
1480 && TREE_CODE (TREE_VALUE (arglist
)) != PARM_DECL
)
1482 exp
= copy_node (exp
);
1483 TREE_OPERAND (exp
, 1) = arglist
;
1484 /* Wrap the computation of the argument in a SAVE_EXPR. That
1485 way, if we need to expand the argument again (as in the
1486 flag_errno_math case below where we cannot directly set
1487 errno), we will not perform side-effects more than once.
1488 Note that here we're mutating the original EXP as well as the
1489 copy; that's the right thing to do in case the original EXP
1490 is expanded later. */
1491 TREE_VALUE (arglist
) = save_expr (TREE_VALUE (arglist
));
1492 arglist
= copy_node (arglist
);
1494 op0
= expand_expr (TREE_VALUE (arglist
), subtarget
, VOIDmode
, 0);
1496 /* Make a suitable register to place result in. */
1497 target
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp
)));
1502 switch (DECL_FUNCTION_CODE (fndecl
))
1507 builtin_optab
= sin_optab
; break;
1511 builtin_optab
= cos_optab
; break;
1513 case BUILT_IN_SQRTF
:
1514 case BUILT_IN_SQRTL
:
1515 builtin_optab
= sqrt_optab
; break;
1520 /* Compute into TARGET.
1521 Set TARGET to wherever the result comes back. */
1522 argmode
= TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist
)));
1523 target
= expand_unop (argmode
, builtin_optab
, op0
, target
, 0);
1525 /* If we were unable to expand via the builtin, stop the
1526 sequence (without outputting the insns) and return 0, causing
1527 a call to the library function. */
1534 /* If errno must be maintained, we must set it to EDOM for NaN results. */
1536 if (flag_errno_math
&& HONOR_NANS (argmode
))
1540 lab1
= gen_label_rtx ();
1542 /* Test the result; if it is NaN, set errno=EDOM because
1543 the argument was not in the domain. */
1544 emit_cmp_and_jump_insns (target
, target
, EQ
, 0, GET_MODE (target
),
1549 #ifdef GEN_ERRNO_RTX
1550 rtx errno_rtx
= GEN_ERRNO_RTX
;
1553 = gen_rtx_MEM (word_mode
, gen_rtx_SYMBOL_REF (Pmode
, "errno"));
1556 emit_move_insn (errno_rtx
, GEN_INT (TARGET_EDOM
));
1559 /* We can't set errno=EDOM directly; let the library call do it.
1560 Pop the arguments right away in case the call gets deleted. */
1562 expand_call (exp
, target
, 0);
1569 /* Output the entire sequence. */
1570 insns
= get_insns ();
1577 /* Expand expression EXP which is a call to the strlen builtin. Return 0
1578 if we failed the caller should emit a normal call, otherwise
1579 try to get the result in TARGET, if convenient. */
1582 expand_builtin_strlen (exp
, target
)
1586 tree arglist
= TREE_OPERAND (exp
, 1);
1587 enum machine_mode value_mode
= TYPE_MODE (TREE_TYPE (exp
));
1589 if (!validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
1594 tree src
= TREE_VALUE (arglist
);
1597 = get_pointer_alignment (src
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
1599 rtx result
, src_reg
, char_rtx
, before_strlen
;
1600 enum machine_mode insn_mode
= value_mode
, char_mode
;
1601 enum insn_code icode
= CODE_FOR_nothing
;
1603 /* If SRC is not a pointer type, don't do this operation inline. */
1607 /* Bail out if we can't compute strlen in the right mode. */
1608 while (insn_mode
!= VOIDmode
)
1610 icode
= strlen_optab
->handlers
[(int) insn_mode
].insn_code
;
1611 if (icode
!= CODE_FOR_nothing
)
1614 insn_mode
= GET_MODE_WIDER_MODE (insn_mode
);
1616 if (insn_mode
== VOIDmode
)
1619 /* Make a place to write the result of the instruction. */
1622 && GET_CODE (result
) == REG
1623 && GET_MODE (result
) == insn_mode
1624 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
1625 result
= gen_reg_rtx (insn_mode
);
1627 /* Make a place to hold the source address. We will not expand
1628 the actual source until we are sure that the expansion will
1629 not fail -- there are trees that cannot be expanded twice. */
1630 src_reg
= gen_reg_rtx (Pmode
);
1632 /* Mark the beginning of the strlen sequence so we can emit the
1633 source operand later. */
1634 before_strlen
= get_last_insn();
1636 char_rtx
= const0_rtx
;
1637 char_mode
= insn_data
[(int) icode
].operand
[2].mode
;
1638 if (! (*insn_data
[(int) icode
].operand
[2].predicate
) (char_rtx
,
1640 char_rtx
= copy_to_mode_reg (char_mode
, char_rtx
);
1642 pat
= GEN_FCN (icode
) (result
, gen_rtx_MEM (BLKmode
, src_reg
),
1643 char_rtx
, GEN_INT (align
));
1648 /* Now that we are assured of success, expand the source. */
1650 pat
= memory_address (BLKmode
,
1651 expand_expr (src
, src_reg
, ptr_mode
, EXPAND_SUM
));
1653 emit_move_insn (src_reg
, pat
);
1654 pat
= gen_sequence ();
1658 emit_insn_after (pat
, before_strlen
);
1660 emit_insn_before (pat
, get_insns ());
1662 /* Return the value in the proper mode for this function. */
1663 if (GET_MODE (result
) == value_mode
)
1665 else if (target
!= 0)
1666 convert_move (target
, result
, 0);
1668 target
= convert_to_mode (value_mode
, result
, 0);
1674 /* Expand a call to the strstr builtin. Return 0 if we failed the
1675 caller should emit a normal call, otherwise try to get the result
1676 in TARGET, if convenient (and in mode MODE if that's convenient). */
1679 expand_builtin_strstr (arglist
, target
, mode
)
1682 enum machine_mode mode
;
1684 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
1688 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
1690 const char *p1
, *p2
;
1699 const char *r
= strstr (p1
, p2
);
1704 /* Return an offset into the constant string argument. */
1705 return expand_expr (fold (build (PLUS_EXPR
, TREE_TYPE (s1
),
1706 s1
, ssize_int (r
- p1
))),
1707 target
, mode
, EXPAND_NORMAL
);
1711 return expand_expr (s1
, target
, mode
, EXPAND_NORMAL
);
1716 fn
= built_in_decls
[BUILT_IN_STRCHR
];
1720 /* New argument list transforming strstr(s1, s2) to
1721 strchr(s1, s2[0]). */
1723 build_tree_list (NULL_TREE
, build_int_2 (p2
[0], 0));
1724 arglist
= tree_cons (NULL_TREE
, s1
, arglist
);
1725 return expand_expr (build_function_call_expr (fn
, arglist
),
1726 target
, mode
, EXPAND_NORMAL
);
1730 /* Expand a call to the strchr builtin. Return 0 if we failed the
1731 caller should emit a normal call, otherwise try to get the result
1732 in TARGET, if convenient (and in mode MODE if that's convenient). */
1735 expand_builtin_strchr (arglist
, target
, mode
)
1738 enum machine_mode mode
;
1740 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
1744 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
1747 if (TREE_CODE (s2
) != INTEGER_CST
)
1756 if (target_char_cast (s2
, &c
))
1764 /* Return an offset into the constant string argument. */
1765 return expand_expr (fold (build (PLUS_EXPR
, TREE_TYPE (s1
),
1766 s1
, ssize_int (r
- p1
))),
1767 target
, mode
, EXPAND_NORMAL
);
1770 /* FIXME: Should use here strchrM optab so that ports can optimize
1776 /* Expand a call to the strrchr builtin. Return 0 if we failed the
1777 caller should emit a normal call, otherwise try to get the result
1778 in TARGET, if convenient (and in mode MODE if that's convenient). */
1781 expand_builtin_strrchr (arglist
, target
, mode
)
1784 enum machine_mode mode
;
1786 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
1790 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
1794 if (TREE_CODE (s2
) != INTEGER_CST
)
1803 if (target_char_cast (s2
, &c
))
1806 r
= strrchr (p1
, c
);
1811 /* Return an offset into the constant string argument. */
1812 return expand_expr (fold (build (PLUS_EXPR
, TREE_TYPE (s1
),
1813 s1
, ssize_int (r
- p1
))),
1814 target
, mode
, EXPAND_NORMAL
);
1817 if (! integer_zerop (s2
))
1820 fn
= built_in_decls
[BUILT_IN_STRCHR
];
1824 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */
1825 return expand_expr (build_function_call_expr (fn
, arglist
),
1826 target
, mode
, EXPAND_NORMAL
);
1830 /* Expand a call to the strpbrk builtin. Return 0 if we failed the
1831 caller should emit a normal call, otherwise try to get the result
1832 in TARGET, if convenient (and in mode MODE if that's convenient). */
1835 expand_builtin_strpbrk (arglist
, target
, mode
)
1838 enum machine_mode mode
;
1840 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
1844 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
1846 const char *p1
, *p2
;
1855 const char *r
= strpbrk (p1
, p2
);
1860 /* Return an offset into the constant string argument. */
1861 return expand_expr (fold (build (PLUS_EXPR
, TREE_TYPE (s1
),
1862 s1
, ssize_int (r
- p1
))),
1863 target
, mode
, EXPAND_NORMAL
);
1868 /* strpbrk(x, "") == NULL.
1869 Evaluate and ignore the arguments in case they had
1871 expand_expr (s1
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
1876 return 0; /* Really call strpbrk. */
1878 fn
= built_in_decls
[BUILT_IN_STRCHR
];
1882 /* New argument list transforming strpbrk(s1, s2) to
1883 strchr(s1, s2[0]). */
1885 build_tree_list (NULL_TREE
, build_int_2 (p2
[0], 0));
1886 arglist
= tree_cons (NULL_TREE
, s1
, arglist
);
1887 return expand_expr (build_function_call_expr (fn
, arglist
),
1888 target
, mode
, EXPAND_NORMAL
);
1892 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
1893 bytes from constant string DATA + OFFSET and return it as target
1897 builtin_memcpy_read_str (data
, offset
, mode
)
1899 HOST_WIDE_INT offset
;
1900 enum machine_mode mode
;
1902 const char *str
= (const char *) data
;
1905 || ((unsigned HOST_WIDE_INT
) offset
+ GET_MODE_SIZE (mode
)
1906 > strlen (str
) + 1))
1907 abort (); /* Attempt to read past the end of constant string. */
1909 return c_readstr (str
+ offset
, mode
);
1912 /* Expand a call to the memcpy builtin, with arguments in ARGLIST.
1913 Return 0 if we failed, the caller should emit a normal call, otherwise
1914 try to get the result in TARGET, if convenient (and in mode MODE if
1915 that's convenient). */
1918 expand_builtin_memcpy (arglist
, target
, mode
)
1921 enum machine_mode mode
;
1923 if (!validate_arglist (arglist
,
1924 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
1928 tree dest
= TREE_VALUE (arglist
);
1929 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
1930 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
1931 const char *src_str
;
1933 unsigned int src_align
= get_pointer_alignment (src
, BIGGEST_ALIGNMENT
);
1934 unsigned int dest_align
1935 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
1936 rtx dest_mem
, src_mem
, dest_addr
, len_rtx
;
1938 /* If DEST is not a pointer type, call the normal function. */
1939 if (dest_align
== 0)
1942 /* If the LEN parameter is zero, return DEST. */
1943 if (host_integerp (len
, 1) && tree_low_cst (len
, 1) == 0)
1945 /* Evaluate and ignore SRC in case it has side-effects. */
1946 expand_expr (src
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
1947 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
1950 /* If either SRC is not a pointer type, don't do this
1951 operation in-line. */
1955 dest_mem
= get_memory_rtx (dest
);
1956 set_mem_align (dest_mem
, dest_align
);
1957 len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
1958 src_str
= c_getstr (src
);
1960 /* If SRC is a string constant and block move would be done
1961 by pieces, we can avoid loading the string from memory
1962 and only stored the computed constants. */
1964 && GET_CODE (len_rtx
) == CONST_INT
1965 && (unsigned HOST_WIDE_INT
) INTVAL (len_rtx
) <= strlen (src_str
) + 1
1966 && can_store_by_pieces (INTVAL (len_rtx
), builtin_memcpy_read_str
,
1967 (PTR
) src_str
, dest_align
))
1969 store_by_pieces (dest_mem
, INTVAL (len_rtx
),
1970 builtin_memcpy_read_str
,
1971 (PTR
) src_str
, dest_align
);
1972 return force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
1975 src_mem
= get_memory_rtx (src
);
1976 set_mem_align (src_mem
, src_align
);
1978 /* Copy word part most expediently. */
1979 dest_addr
= emit_block_move (dest_mem
, src_mem
, len_rtx
);
1982 dest_addr
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
1988 /* Expand expression EXP, which is a call to the strcpy builtin. Return 0
1989 if we failed the caller should emit a normal call, otherwise try to get
1990 the result in TARGET, if convenient (and in mode MODE if that's
1994 expand_builtin_strcpy (exp
, target
, mode
)
1997 enum machine_mode mode
;
1999 tree arglist
= TREE_OPERAND (exp
, 1);
2002 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2005 fn
= built_in_decls
[BUILT_IN_MEMCPY
];
2009 len
= c_strlen (TREE_VALUE (TREE_CHAIN (arglist
)));
2013 len
= size_binop (PLUS_EXPR
, len
, ssize_int (1));
2014 chainon (arglist
, build_tree_list (NULL_TREE
, len
));
2015 return expand_expr (build_function_call_expr (fn
, arglist
),
2016 target
, mode
, EXPAND_NORMAL
);
2019 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
2020 bytes from constant string DATA + OFFSET and return it as target
2024 builtin_strncpy_read_str (data
, offset
, mode
)
2026 HOST_WIDE_INT offset
;
2027 enum machine_mode mode
;
2029 const char *str
= (const char *) data
;
2031 if ((unsigned HOST_WIDE_INT
) offset
> strlen (str
))
2034 return c_readstr (str
+ offset
, mode
);
2037 /* Expand expression EXP, which is a call to the strncpy builtin. Return 0
2038 if we failed the caller should emit a normal call. */
2041 expand_builtin_strncpy (arglist
, target
, mode
)
2044 enum machine_mode mode
;
2046 if (!validate_arglist (arglist
,
2047 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2051 tree slen
= c_strlen (TREE_VALUE (TREE_CHAIN (arglist
)));
2052 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2055 /* We must be passed a constant len parameter. */
2056 if (TREE_CODE (len
) != INTEGER_CST
)
2059 /* If the len parameter is zero, return the dst parameter. */
2060 if (integer_zerop (len
))
2062 /* Evaluate and ignore the src argument in case it has
2064 expand_expr (TREE_VALUE (TREE_CHAIN (arglist
)), const0_rtx
,
2065 VOIDmode
, EXPAND_NORMAL
);
2066 /* Return the dst parameter. */
2067 return expand_expr (TREE_VALUE (arglist
), target
, mode
,
2071 /* Now, we must be passed a constant src ptr parameter. */
2072 if (slen
== 0 || TREE_CODE (slen
) != INTEGER_CST
)
2075 slen
= size_binop (PLUS_EXPR
, slen
, ssize_int (1));
2077 /* We're required to pad with trailing zeros if the requested
2078 len is greater than strlen(s2)+1. In that case try to
2079 use store_by_pieces, if it fails, punt. */
2080 if (tree_int_cst_lt (slen
, len
))
2082 tree dest
= TREE_VALUE (arglist
);
2083 unsigned int dest_align
2084 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
2085 const char *p
= c_getstr (TREE_VALUE (TREE_CHAIN (arglist
)));
2088 if (!p
|| dest_align
== 0 || !host_integerp (len
, 1)
2089 || !can_store_by_pieces (tree_low_cst (len
, 1),
2090 builtin_strncpy_read_str
,
2091 (PTR
) p
, dest_align
))
2094 dest_mem
= get_memory_rtx (dest
);
2095 store_by_pieces (dest_mem
, tree_low_cst (len
, 1),
2096 builtin_strncpy_read_str
,
2097 (PTR
) p
, dest_align
);
2098 return force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2101 /* OK transform into builtin memcpy. */
2102 fn
= built_in_decls
[BUILT_IN_MEMCPY
];
2105 return expand_expr (build_function_call_expr (fn
, arglist
),
2106 target
, mode
, EXPAND_NORMAL
);
2110 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
2111 bytes from constant string DATA + OFFSET and return it as target
2115 builtin_memset_read_str (data
, offset
, mode
)
2117 HOST_WIDE_INT offset ATTRIBUTE_UNUSED
;
2118 enum machine_mode mode
;
2120 const char *c
= (const char *) data
;
2121 char *p
= alloca (GET_MODE_SIZE (mode
));
2123 memset (p
, *c
, GET_MODE_SIZE (mode
));
2125 return c_readstr (p
, mode
);
2128 /* Expand expression EXP, which is a call to the memset builtin. Return 0
2129 if we failed the caller should emit a normal call, otherwise try to get
2130 the result in TARGET, if convenient (and in mode MODE if that's
2134 expand_builtin_memset (exp
, target
, mode
)
2137 enum machine_mode mode
;
2139 tree arglist
= TREE_OPERAND (exp
, 1);
2141 if (!validate_arglist (arglist
,
2142 POINTER_TYPE
, INTEGER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2146 tree dest
= TREE_VALUE (arglist
);
2147 tree val
= TREE_VALUE (TREE_CHAIN (arglist
));
2148 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2151 unsigned int dest_align
2152 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
);
2153 rtx dest_mem
, dest_addr
, len_rtx
;
2155 /* If DEST is not a pointer type, don't do this
2156 operation in-line. */
2157 if (dest_align
== 0)
2160 /* If the LEN parameter is zero, return DEST. */
2161 if (host_integerp (len
, 1) && tree_low_cst (len
, 1) == 0)
2163 /* Evaluate and ignore VAL in case it has side-effects. */
2164 expand_expr (val
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2165 return expand_expr (dest
, target
, mode
, EXPAND_NORMAL
);
2168 if (TREE_CODE (val
) != INTEGER_CST
)
2171 if (target_char_cast (val
, &c
))
2176 if (!host_integerp (len
, 1))
2178 if (!can_store_by_pieces (tree_low_cst (len
, 1),
2179 builtin_memset_read_str
, (PTR
) &c
,
2183 dest_mem
= get_memory_rtx (dest
);
2184 store_by_pieces (dest_mem
, tree_low_cst (len
, 1),
2185 builtin_memset_read_str
,
2186 (PTR
) &c
, dest_align
);
2187 return force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2190 len_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
2192 dest_mem
= get_memory_rtx (dest
);
2193 set_mem_align (dest_mem
, dest_align
);
2194 dest_addr
= clear_storage (dest_mem
, len_rtx
);
2197 dest_addr
= force_operand (XEXP (dest_mem
, 0), NULL_RTX
);
2203 /* Expand expression EXP, which is a call to the bzero builtin. Return 0
2204 if we failed the caller should emit a normal call. */
2207 expand_builtin_bzero (exp
)
2210 tree arglist
= TREE_OPERAND (exp
, 1);
2211 tree dest
, size
, newarglist
;
2214 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2217 dest
= TREE_VALUE (arglist
);
2218 size
= TREE_VALUE (TREE_CHAIN (arglist
));
2220 /* New argument list transforming bzero(ptr x, int y) to
2221 memset(ptr x, int 0, size_t y). This is done this way
2222 so that if it isn't expanded inline, we fallback to
2223 calling bzero instead of memset. */
2225 newarglist
= build_tree_list (NULL_TREE
, convert (sizetype
, size
));
2226 newarglist
= tree_cons (NULL_TREE
, integer_zero_node
, newarglist
);
2227 newarglist
= tree_cons (NULL_TREE
, dest
, newarglist
);
2229 TREE_OPERAND (exp
, 1) = newarglist
;
2230 result
= expand_builtin_memset (exp
, const0_rtx
, VOIDmode
);
2232 /* Always restore the original arguments. */
2233 TREE_OPERAND (exp
, 1) = arglist
;
2238 /* Expand expression EXP, which is a call to the memcmp or the strcmp builtin.
2239 ARGLIST is the argument list for this call. Return 0 if we failed and the
2240 caller should emit a normal call, otherwise try to get the result in
2241 TARGET, if convenient (and in mode MODE, if that's convenient). */
2244 expand_builtin_memcmp (exp
, arglist
, target
, mode
)
2245 tree exp ATTRIBUTE_UNUSED
;
2248 enum machine_mode mode
;
2250 tree arg1
, arg2
, len
;
2251 const char *p1
, *p2
;
2253 if (!validate_arglist (arglist
,
2254 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2257 arg1
= TREE_VALUE (arglist
);
2258 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
2259 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2261 /* If the len parameter is zero, return zero. */
2262 if (host_integerp (len
, 1) && tree_low_cst (len
, 1) == 0)
2264 /* Evaluate and ignore arg1 and arg2 in case they have
2266 expand_expr (arg1
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2267 expand_expr (arg2
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2271 p1
= c_getstr (arg1
);
2272 p2
= c_getstr (arg2
);
2274 /* If all arguments are constant, and the value of len is not greater
2275 than the lengths of arg1 and arg2, evaluate at compile-time. */
2276 if (host_integerp (len
, 1) && p1
&& p2
2277 && compare_tree_int (len
, strlen (p1
) + 1) <= 0
2278 && compare_tree_int (len
, strlen (p2
) + 1) <= 0)
2280 const int r
= memcmp (p1
, p2
, tree_low_cst (len
, 1));
2282 return (r
< 0 ? constm1_rtx
: (r
> 0 ? const1_rtx
: const0_rtx
));
2285 /* If len parameter is one, return an expression corresponding to
2286 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
2287 if (host_integerp (len
, 1) && tree_low_cst (len
, 1) == 1)
2289 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
2290 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
2292 fold (build1 (CONVERT_EXPR
, integer_type_node
,
2293 build1 (INDIRECT_REF
, cst_uchar_node
,
2294 build1 (NOP_EXPR
, cst_uchar_ptr_node
, arg1
))));
2296 fold (build1 (CONVERT_EXPR
, integer_type_node
,
2297 build1 (INDIRECT_REF
, cst_uchar_node
,
2298 build1 (NOP_EXPR
, cst_uchar_ptr_node
, arg2
))));
2299 tree result
= fold (build (MINUS_EXPR
, integer_type_node
, ind1
, ind2
));
2300 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2303 #ifdef HAVE_cmpstrsi
2305 rtx arg1_rtx
, arg2_rtx
, arg3_rtx
;
2310 = get_pointer_alignment (arg1
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
2312 = get_pointer_alignment (arg2
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
2313 enum machine_mode insn_mode
2314 = insn_data
[(int) CODE_FOR_cmpstrsi
].operand
[0].mode
;
2316 /* If we don't have POINTER_TYPE, call the function. */
2317 if (arg1_align
== 0 || arg2_align
== 0)
2320 /* Make a place to write the result of the instruction. */
2323 && GET_CODE (result
) == REG
&& GET_MODE (result
) == insn_mode
2324 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
2325 result
= gen_reg_rtx (insn_mode
);
2327 arg1_rtx
= get_memory_rtx (arg1
);
2328 arg2_rtx
= get_memory_rtx (arg2
);
2329 arg3_rtx
= expand_expr (len
, NULL_RTX
, VOIDmode
, 0);
2333 insn
= gen_cmpstrsi (result
, arg1_rtx
, arg2_rtx
, arg3_rtx
,
2334 GEN_INT (MIN (arg1_align
, arg2_align
)));
2339 emit_library_call_value (memcmp_libfunc
, result
, LCT_PURE_MAKE_BLOCK
,
2340 TYPE_MODE (integer_type_node
), 3,
2341 XEXP (arg1_rtx
, 0), Pmode
,
2342 XEXP (arg2_rtx
, 0), Pmode
,
2343 convert_to_mode (TYPE_MODE (sizetype
), arg3_rtx
,
2344 TREE_UNSIGNED (sizetype
)),
2345 TYPE_MODE (sizetype
));
2347 /* Return the value in the proper mode for this function. */
2348 mode
= TYPE_MODE (TREE_TYPE (exp
));
2349 if (GET_MODE (result
) == mode
)
2351 else if (target
!= 0)
2353 convert_move (target
, result
, 0);
2357 return convert_to_mode (mode
, result
, 0);
2364 /* Expand expression EXP, which is a call to the strcmp builtin. Return 0
2365 if we failed the caller should emit a normal call, otherwise try to get
2366 the result in TARGET, if convenient. */
2369 expand_builtin_strcmp (exp
, target
, mode
)
2372 enum machine_mode mode
;
2374 tree arglist
= TREE_OPERAND (exp
, 1);
2375 tree arg1
, arg2
, len
, len2
, fn
;
2376 const char *p1
, *p2
;
2378 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2381 arg1
= TREE_VALUE (arglist
);
2382 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
2384 p1
= c_getstr (arg1
);
2385 p2
= c_getstr (arg2
);
2389 const int i
= strcmp (p1
, p2
);
2390 return (i
< 0 ? constm1_rtx
: (i
> 0 ? const1_rtx
: const0_rtx
));
2393 /* If either arg is "", return an expression corresponding to
2394 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
2395 if ((p1
&& *p1
== '\0') || (p2
&& *p2
== '\0'))
2397 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
2398 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
2400 fold (build1 (CONVERT_EXPR
, integer_type_node
,
2401 build1 (INDIRECT_REF
, cst_uchar_node
,
2402 build1 (NOP_EXPR
, cst_uchar_ptr_node
, arg1
))));
2404 fold (build1 (CONVERT_EXPR
, integer_type_node
,
2405 build1 (INDIRECT_REF
, cst_uchar_node
,
2406 build1 (NOP_EXPR
, cst_uchar_ptr_node
, arg2
))));
2407 tree result
= fold (build (MINUS_EXPR
, integer_type_node
, ind1
, ind2
));
2408 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2411 len
= c_strlen (arg1
);
2412 len2
= c_strlen (arg2
);
2415 len
= size_binop (PLUS_EXPR
, ssize_int (1), len
);
2418 len2
= size_binop (PLUS_EXPR
, ssize_int (1), len2
);
2420 /* If we don't have a constant length for the first, use the length
2421 of the second, if we know it. We don't require a constant for
2422 this case; some cost analysis could be done if both are available
2423 but neither is constant. For now, assume they're equally cheap
2424 unless one has side effects.
2426 If both strings have constant lengths, use the smaller. This
2427 could arise if optimization results in strcpy being called with
2428 two fixed strings, or if the code was machine-generated. We should
2429 add some code to the `memcmp' handler below to deal with such
2430 situations, someday. */
2432 if (!len
|| TREE_CODE (len
) != INTEGER_CST
)
2434 if (len2
&& !TREE_SIDE_EFFECTS (len2
))
2439 else if (len2
&& TREE_CODE (len2
) == INTEGER_CST
2440 && tree_int_cst_lt (len2
, len
))
2443 /* If both arguments have side effects, we cannot optimize. */
2444 if (TREE_SIDE_EFFECTS (len
))
2447 fn
= built_in_decls
[BUILT_IN_MEMCMP
];
2451 chainon (arglist
, build_tree_list (NULL_TREE
, len
));
2452 return expand_expr (build_function_call_expr (fn
, arglist
),
2453 target
, mode
, EXPAND_NORMAL
);
2456 /* Expand expression EXP, which is a call to the strncmp builtin. Return 0
2457 if we failed the caller should emit a normal call, otherwise try to get
2458 the result in TARGET, if convenient. */
2461 expand_builtin_strncmp (exp
, target
, mode
)
2464 enum machine_mode mode
;
2466 tree arglist
= TREE_OPERAND (exp
, 1);
2467 tree fn
, newarglist
, len
= 0;
2468 tree arg1
, arg2
, arg3
;
2469 const char *p1
, *p2
;
2471 if (!validate_arglist (arglist
,
2472 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2475 arg1
= TREE_VALUE (arglist
);
2476 arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
2477 arg3
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2479 /* If the len parameter is zero, return zero. */
2480 if (host_integerp (arg3
, 1) && tree_low_cst (arg3
, 1) == 0)
2482 /* Evaluate and ignore arg1 and arg2 in case they have
2484 expand_expr (arg1
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2485 expand_expr (arg2
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2489 p1
= c_getstr (arg1
);
2490 p2
= c_getstr (arg2
);
2492 /* If all arguments are constant, evaluate at compile-time. */
2493 if (host_integerp (arg3
, 1) && p1
&& p2
)
2495 const int r
= strncmp (p1
, p2
, tree_low_cst (arg3
, 1));
2496 return (r
< 0 ? constm1_rtx
: (r
> 0 ? const1_rtx
: const0_rtx
));
2499 /* If len == 1 or (either string parameter is "" and (len >= 1)),
2500 return (*(const u_char*)arg1 - *(const u_char*)arg2). */
2501 if (host_integerp (arg3
, 1)
2502 && (tree_low_cst (arg3
, 1) == 1
2503 || (tree_low_cst (arg3
, 1) > 1
2504 && ((p1
&& *p1
== '\0') || (p2
&& *p2
== '\0')))))
2506 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
2507 tree cst_uchar_ptr_node
= build_pointer_type (cst_uchar_node
);
2509 fold (build1 (CONVERT_EXPR
, integer_type_node
,
2510 build1 (INDIRECT_REF
, cst_uchar_node
,
2511 build1 (NOP_EXPR
, cst_uchar_ptr_node
, arg1
))));
2513 fold (build1 (CONVERT_EXPR
, integer_type_node
,
2514 build1 (INDIRECT_REF
, cst_uchar_node
,
2515 build1 (NOP_EXPR
, cst_uchar_ptr_node
, arg2
))));
2516 tree result
= fold (build (MINUS_EXPR
, integer_type_node
, ind1
, ind2
));
2517 return expand_expr (result
, target
, mode
, EXPAND_NORMAL
);
2520 /* If c_strlen can determine an expression for one of the string
2521 lengths, and it doesn't have side effects, then call
2522 expand_builtin_memcmp() using length MIN(strlen(string)+1, arg3). */
2524 /* Perhaps one of the strings is really constant, if so prefer
2525 that constant length over the other string's length. */
2527 len
= c_strlen (arg1
);
2529 len
= c_strlen (arg2
);
2531 /* If we still don't have a len, try either string arg as long
2532 as they don't have side effects. */
2533 if (!len
&& !TREE_SIDE_EFFECTS (arg1
))
2534 len
= c_strlen (arg1
);
2535 if (!len
&& !TREE_SIDE_EFFECTS (arg2
))
2536 len
= c_strlen (arg2
);
2537 /* If we still don't have a length, punt. */
2541 fn
= built_in_decls
[BUILT_IN_MEMCMP
];
2545 /* Add one to the string length. */
2546 len
= fold (size_binop (PLUS_EXPR
, len
, ssize_int (1)));
2548 /* The actual new length parameter is MIN(len,arg3). */
2549 len
= fold (build (MIN_EXPR
, TREE_TYPE (len
), len
, arg3
));
2551 newarglist
= build_tree_list (NULL_TREE
, len
);
2552 newarglist
= tree_cons (NULL_TREE
, arg2
, newarglist
);
2553 newarglist
= tree_cons (NULL_TREE
, arg1
, newarglist
);
2554 return expand_expr (build_function_call_expr (fn
, newarglist
),
2555 target
, mode
, EXPAND_NORMAL
);
2558 /* Expand expression EXP, which is a call to the strcat builtin.
2559 Return 0 if we failed the caller should emit a normal call,
2560 otherwise try to get the result in TARGET, if convenient. */
2563 expand_builtin_strcat (arglist
, target
, mode
)
2566 enum machine_mode mode
;
2568 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2572 tree dst
= TREE_VALUE (arglist
),
2573 src
= TREE_VALUE (TREE_CHAIN (arglist
));
2574 const char *p
= c_getstr (src
);
2576 /* If the string length is zero, return the dst parameter. */
2577 if (p
&& *p
== '\0')
2578 return expand_expr (dst
, target
, mode
, EXPAND_NORMAL
);
2584 /* Expand expression EXP, which is a call to the strncat builtin.
2585 Return 0 if we failed the caller should emit a normal call,
2586 otherwise try to get the result in TARGET, if convenient. */
2589 expand_builtin_strncat (arglist
, target
, mode
)
2592 enum machine_mode mode
;
2594 if (!validate_arglist (arglist
,
2595 POINTER_TYPE
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
2599 tree dst
= TREE_VALUE (arglist
),
2600 src
= TREE_VALUE (TREE_CHAIN (arglist
)),
2601 len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
2602 const char *p
= c_getstr (src
);
2604 /* If the requested length is zero, or the src parameter string
2605 length is zero, return the dst parameter. */
2606 if (integer_zerop (len
) || (p
&& *p
== '\0'))
2608 /* Evaluate and ignore the src and len parameters in case
2609 they have side-effects. */
2610 expand_expr (src
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2611 expand_expr (len
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2612 return expand_expr (dst
, target
, mode
, EXPAND_NORMAL
);
2615 /* If the requested len is greater than or equal to the string
2616 length, call strcat. */
2617 if (TREE_CODE (len
) == INTEGER_CST
&& p
2618 && compare_tree_int (len
, strlen (p
)) >= 0)
2621 = tree_cons (NULL_TREE
, dst
, build_tree_list (NULL_TREE
, src
));
2622 tree fn
= built_in_decls
[BUILT_IN_STRCAT
];
2624 /* If the replacement _DECL isn't initialized, don't do the
2629 return expand_expr (build_function_call_expr (fn
, newarglist
),
2630 target
, mode
, EXPAND_NORMAL
);
2636 /* Expand expression EXP, which is a call to the strspn builtin.
2637 Return 0 if we failed the caller should emit a normal call,
2638 otherwise try to get the result in TARGET, if convenient. */
2641 expand_builtin_strspn (arglist
, target
, mode
)
2644 enum machine_mode mode
;
2646 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2650 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
2651 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
2653 /* If both arguments are constants, evaluate at compile-time. */
2656 const size_t r
= strspn (p1
, p2
);
2657 return expand_expr (size_int (r
), target
, mode
, EXPAND_NORMAL
);
2660 /* If either argument is "", return 0. */
2661 if ((p1
&& *p1
== '\0') || (p2
&& *p2
== '\0'))
2663 /* Evaluate and ignore both arguments in case either one has
2665 expand_expr (s1
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2666 expand_expr (s2
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2673 /* Expand expression EXP, which is a call to the strcspn builtin.
2674 Return 0 if we failed the caller should emit a normal call,
2675 otherwise try to get the result in TARGET, if convenient. */
2678 expand_builtin_strcspn (arglist
, target
, mode
)
2681 enum machine_mode mode
;
2683 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
2687 tree s1
= TREE_VALUE (arglist
), s2
= TREE_VALUE (TREE_CHAIN (arglist
));
2688 const char *p1
= c_getstr (s1
), *p2
= c_getstr (s2
);
2690 /* If both arguments are constants, evaluate at compile-time. */
2693 const size_t r
= strcspn (p1
, p2
);
2694 return expand_expr (size_int (r
), target
, mode
, EXPAND_NORMAL
);
2697 /* If the first argument is "", return 0. */
2698 if (p1
&& *p1
== '\0')
2700 /* Evaluate and ignore argument s2 in case it has
2702 expand_expr (s2
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2706 /* If the second argument is "", return __builtin_strlen(s1). */
2707 if (p2
&& *p2
== '\0')
2709 tree newarglist
= build_tree_list (NULL_TREE
, s1
),
2710 fn
= built_in_decls
[BUILT_IN_STRLEN
];
2712 /* If the replacement _DECL isn't initialized, don't do the
2717 return expand_expr (build_function_call_expr (fn
, newarglist
),
2718 target
, mode
, EXPAND_NORMAL
);
2724 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
2725 if that's convenient. */
2728 expand_builtin_saveregs ()
2732 /* Don't do __builtin_saveregs more than once in a function.
2733 Save the result of the first call and reuse it. */
2734 if (saveregs_value
!= 0)
2735 return saveregs_value
;
2737 /* When this function is called, it means that registers must be
2738 saved on entry to this function. So we migrate the call to the
2739 first insn of this function. */
2743 #ifdef EXPAND_BUILTIN_SAVEREGS
2744 /* Do whatever the machine needs done in this case. */
2745 val
= EXPAND_BUILTIN_SAVEREGS ();
2747 /* ??? We used to try and build up a call to the out of line function,
2748 guessing about what registers needed saving etc. This became much
2749 harder with __builtin_va_start, since we don't have a tree for a
2750 call to __builtin_saveregs to fall back on. There was exactly one
2751 port (i860) that used this code, and I'm unconvinced it could actually
2752 handle the general case. So we no longer try to handle anything
2753 weird and make the backend absorb the evil. */
2755 error ("__builtin_saveregs not supported by this target");
2762 saveregs_value
= val
;
2764 /* Put the sequence after the NOTE that starts the function. If this
2765 is inside a SEQUENCE, make the outer-level insn chain current, so
2766 the code is placed at the start of the function. */
2767 push_topmost_sequence ();
2768 emit_insns_after (seq
, get_insns ());
2769 pop_topmost_sequence ();
2774 /* __builtin_args_info (N) returns word N of the arg space info
2775 for the current function. The number and meanings of words
2776 is controlled by the definition of CUMULATIVE_ARGS. */
2779 expand_builtin_args_info (exp
)
2782 tree arglist
= TREE_OPERAND (exp
, 1);
2783 int nwords
= sizeof (CUMULATIVE_ARGS
) / sizeof (int);
2784 int *word_ptr
= (int *) ¤t_function_args_info
;
2786 /* These are used by the code below that is if 0'ed away */
2788 tree type
, elts
, result
;
2791 if (sizeof (CUMULATIVE_ARGS
) % sizeof (int) != 0)
2796 if (!host_integerp (TREE_VALUE (arglist
), 0))
2797 error ("argument of `__builtin_args_info' must be constant");
2800 HOST_WIDE_INT wordnum
= tree_low_cst (TREE_VALUE (arglist
), 0);
2802 if (wordnum
< 0 || wordnum
>= nwords
)
2803 error ("argument of `__builtin_args_info' out of range");
2805 return GEN_INT (word_ptr
[wordnum
]);
2809 error ("missing argument in `__builtin_args_info'");
2814 for (i
= 0; i
< nwords
; i
++)
2815 elts
= tree_cons (NULL_TREE
, build_int_2 (word_ptr
[i
], 0));
2817 type
= build_array_type (integer_type_node
,
2818 build_index_type (build_int_2 (nwords
, 0)));
2819 result
= build (CONSTRUCTOR
, type
, NULL_TREE
, nreverse (elts
));
2820 TREE_CONSTANT (result
) = 1;
2821 TREE_STATIC (result
) = 1;
2822 result
= build1 (INDIRECT_REF
, build_pointer_type (type
), result
);
2823 TREE_CONSTANT (result
) = 1;
2824 return expand_expr (result
, NULL_RTX
, VOIDmode
, 0);
2828 /* Expand ARGLIST, from a call to __builtin_next_arg. */
2831 expand_builtin_next_arg (arglist
)
2834 tree fntype
= TREE_TYPE (current_function_decl
);
2836 if ((TYPE_ARG_TYPES (fntype
) == 0
2837 || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype
)))
2839 && ! current_function_varargs
)
2841 error ("`va_start' used in function with fixed args");
2847 tree last_parm
= tree_last (DECL_ARGUMENTS (current_function_decl
));
2848 tree arg
= TREE_VALUE (arglist
);
2850 /* Strip off all nops for the sake of the comparison. This
2851 is not quite the same as STRIP_NOPS. It does more.
2852 We must also strip off INDIRECT_EXPR for C++ reference
2854 while (TREE_CODE (arg
) == NOP_EXPR
2855 || TREE_CODE (arg
) == CONVERT_EXPR
2856 || TREE_CODE (arg
) == NON_LVALUE_EXPR
2857 || TREE_CODE (arg
) == INDIRECT_REF
)
2858 arg
= TREE_OPERAND (arg
, 0);
2859 if (arg
!= last_parm
)
2860 warning ("second parameter of `va_start' not last named argument");
2862 else if (! current_function_varargs
)
2863 /* Evidently an out of date version of <stdarg.h>; can't validate
2864 va_start's second argument, but can still work as intended. */
2865 warning ("`__builtin_next_arg' called without an argument");
2867 return expand_binop (Pmode
, add_optab
,
2868 current_function_internal_arg_pointer
,
2869 current_function_arg_offset_rtx
,
2870 NULL_RTX
, 0, OPTAB_LIB_WIDEN
);
2873 /* Make it easier for the backends by protecting the valist argument
2874 from multiple evaluations. */
2877 stabilize_va_list (valist
, needs_lvalue
)
2881 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
2883 if (TREE_SIDE_EFFECTS (valist
))
2884 valist
= save_expr (valist
);
2886 /* For this case, the backends will be expecting a pointer to
2887 TREE_TYPE (va_list_type_node), but it's possible we've
2888 actually been given an array (an actual va_list_type_node).
2890 if (TREE_CODE (TREE_TYPE (valist
)) == ARRAY_TYPE
)
2892 tree p1
= build_pointer_type (TREE_TYPE (va_list_type_node
));
2893 tree p2
= build_pointer_type (va_list_type_node
);
2895 valist
= build1 (ADDR_EXPR
, p2
, valist
);
2896 valist
= fold (build1 (NOP_EXPR
, p1
, valist
));
2905 if (! TREE_SIDE_EFFECTS (valist
))
2908 pt
= build_pointer_type (va_list_type_node
);
2909 valist
= fold (build1 (ADDR_EXPR
, pt
, valist
));
2910 TREE_SIDE_EFFECTS (valist
) = 1;
2913 if (TREE_SIDE_EFFECTS (valist
))
2914 valist
= save_expr (valist
);
2915 valist
= fold (build1 (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (valist
)),
2922 /* The "standard" implementation of va_start: just assign `nextarg' to
2926 std_expand_builtin_va_start (stdarg_p
, valist
, nextarg
)
2935 /* The dummy named parameter is declared as a 'word' sized
2936 object, but if a 'word' is smaller than an 'int', it would
2937 have been promoted to int when it was added to the arglist. */
2938 int align
= PARM_BOUNDARY
/ BITS_PER_UNIT
;
2939 int size
= MAX (UNITS_PER_WORD
,
2940 GET_MODE_SIZE (TYPE_MODE (integer_type_node
)));
2941 int offset
= ((size
+ align
- 1) / align
) * align
;
2942 nextarg
= plus_constant (nextarg
, -offset
);
2945 t
= build (MODIFY_EXPR
, TREE_TYPE (valist
), valist
,
2946 make_tree (ptr_type_node
, nextarg
));
2947 TREE_SIDE_EFFECTS (t
) = 1;
2949 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2952 /* Expand ARGLIST, which from a call to __builtin_stdarg_va_start or
2953 __builtin_varargs_va_start, depending on STDARG_P. */
2956 expand_builtin_va_start (stdarg_p
, arglist
)
2961 tree chain
= arglist
, valist
;
2964 nextarg
= expand_builtin_next_arg (chain
= TREE_CHAIN (arglist
));
2966 nextarg
= expand_builtin_next_arg (NULL_TREE
);
2968 if (TREE_CHAIN (chain
))
2969 error ("too many arguments to function `va_start'");
2971 valist
= stabilize_va_list (TREE_VALUE (arglist
), 1);
2973 #ifdef EXPAND_BUILTIN_VA_START
2974 EXPAND_BUILTIN_VA_START (stdarg_p
, valist
, nextarg
);
2976 std_expand_builtin_va_start (stdarg_p
, valist
, nextarg
);
2982 /* The "standard" implementation of va_arg: read the value from the
2983 current (padded) address and increment by the (padded) size. */
2986 std_expand_builtin_va_arg (valist
, type
)
2989 tree addr_tree
, t
, type_size
= NULL
;
2990 tree align
, alignm1
;
2994 /* Compute the rounded size of the type. */
2995 align
= size_int (PARM_BOUNDARY
/ BITS_PER_UNIT
);
2996 alignm1
= size_int (PARM_BOUNDARY
/ BITS_PER_UNIT
- 1);
2997 if (type
== error_mark_node
2998 || (type_size
= TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type
))) == NULL
2999 || TREE_OVERFLOW (type_size
))
3000 rounded_size
= size_zero_node
;
3002 rounded_size
= fold (build (MULT_EXPR
, sizetype
,
3003 fold (build (TRUNC_DIV_EXPR
, sizetype
,
3004 fold (build (PLUS_EXPR
, sizetype
,
3005 type_size
, alignm1
)),
3011 if (PAD_VARARGS_DOWN
&& ! integer_zerop (rounded_size
))
3013 /* Small args are padded downward. */
3014 addr_tree
= fold (build (PLUS_EXPR
, TREE_TYPE (addr_tree
), addr_tree
,
3015 fold (build (COND_EXPR
, sizetype
,
3016 fold (build (GT_EXPR
, sizetype
,
3020 fold (build (MINUS_EXPR
, sizetype
,
3025 addr
= expand_expr (addr_tree
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
3026 addr
= copy_to_reg (addr
);
3028 /* Compute new value for AP. */
3029 if (! integer_zerop (rounded_size
))
3031 t
= build (MODIFY_EXPR
, TREE_TYPE (valist
), valist
,
3032 build (PLUS_EXPR
, TREE_TYPE (valist
), valist
,
3034 TREE_SIDE_EFFECTS (t
) = 1;
3035 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3041 /* Expand __builtin_va_arg, which is not really a builtin function, but
3042 a very special sort of operator. */
3045 expand_builtin_va_arg (valist
, type
)
3049 tree promoted_type
, want_va_type
, have_va_type
;
3051 /* Verify that valist is of the proper type. */
3053 want_va_type
= va_list_type_node
;
3054 have_va_type
= TREE_TYPE (valist
);
3055 if (TREE_CODE (want_va_type
) == ARRAY_TYPE
)
3057 /* If va_list is an array type, the argument may have decayed
3058 to a pointer type, e.g. by being passed to another function.
3059 In that case, unwrap both types so that we can compare the
3060 underlying records. */
3061 if (TREE_CODE (have_va_type
) == ARRAY_TYPE
3062 || TREE_CODE (have_va_type
) == POINTER_TYPE
)
3064 want_va_type
= TREE_TYPE (want_va_type
);
3065 have_va_type
= TREE_TYPE (have_va_type
);
3068 if (TYPE_MAIN_VARIANT (want_va_type
) != TYPE_MAIN_VARIANT (have_va_type
))
3070 error ("first argument to `va_arg' not of type `va_list'");
3074 /* Generate a diagnostic for requesting data of a type that cannot
3075 be passed through `...' due to type promotion at the call site. */
3076 else if ((promoted_type
= (*lang_type_promotes_to
) (type
)) != NULL_TREE
)
3078 const char *name
= "<anonymous type>", *pname
= 0;
3079 static int gave_help
;
3081 if (TYPE_NAME (type
))
3083 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
3084 name
= IDENTIFIER_POINTER (TYPE_NAME (type
));
3085 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
3086 && DECL_NAME (TYPE_NAME (type
)))
3087 name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
3089 if (TYPE_NAME (promoted_type
))
3091 if (TREE_CODE (TYPE_NAME (promoted_type
)) == IDENTIFIER_NODE
)
3092 pname
= IDENTIFIER_POINTER (TYPE_NAME (promoted_type
));
3093 else if (TREE_CODE (TYPE_NAME (promoted_type
)) == TYPE_DECL
3094 && DECL_NAME (TYPE_NAME (promoted_type
)))
3095 pname
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (promoted_type
)));
3098 error ("`%s' is promoted to `%s' when passed through `...'", name
, pname
);
3102 error ("(so you should pass `%s' not `%s' to `va_arg')", pname
, name
);
3109 /* Make it easier for the backends by protecting the valist argument
3110 from multiple evaluations. */
3111 valist
= stabilize_va_list (valist
, 0);
3113 #ifdef EXPAND_BUILTIN_VA_ARG
3114 addr
= EXPAND_BUILTIN_VA_ARG (valist
, type
);
3116 addr
= std_expand_builtin_va_arg (valist
, type
);
3120 #ifdef POINTERS_EXTEND_UNSIGNED
3121 if (GET_MODE (addr
) != Pmode
)
3122 addr
= convert_memory_address (Pmode
, addr
);
3125 result
= gen_rtx_MEM (TYPE_MODE (type
), addr
);
3126 set_mem_alias_set (result
, get_varargs_alias_set ());
3131 /* Expand ARGLIST, from a call to __builtin_va_end. */
3134 expand_builtin_va_end (arglist
)
3137 tree valist
= TREE_VALUE (arglist
);
3139 #ifdef EXPAND_BUILTIN_VA_END
3140 valist
= stabilize_va_list (valist
, 0);
3141 EXPAND_BUILTIN_VA_END(arglist
);
3143 /* Evaluate for side effects, if needed. I hate macros that don't
3145 if (TREE_SIDE_EFFECTS (valist
))
3146 expand_expr (valist
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3152 /* Expand ARGLIST, from a call to __builtin_va_copy. We do this as a
3153 builtin rather than just as an assignment in stdarg.h because of the
3154 nastiness of array-type va_list types. */
3157 expand_builtin_va_copy (arglist
)
3162 dst
= TREE_VALUE (arglist
);
3163 src
= TREE_VALUE (TREE_CHAIN (arglist
));
3165 dst
= stabilize_va_list (dst
, 1);
3166 src
= stabilize_va_list (src
, 0);
3168 if (TREE_CODE (va_list_type_node
) != ARRAY_TYPE
)
3170 t
= build (MODIFY_EXPR
, va_list_type_node
, dst
, src
);
3171 TREE_SIDE_EFFECTS (t
) = 1;
3172 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3176 rtx dstb
, srcb
, size
;
3178 /* Evaluate to pointers. */
3179 dstb
= expand_expr (dst
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
3180 srcb
= expand_expr (src
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
3181 size
= expand_expr (TYPE_SIZE_UNIT (va_list_type_node
), NULL_RTX
,
3182 VOIDmode
, EXPAND_NORMAL
);
3184 #ifdef POINTERS_EXTEND_UNSIGNED
3185 if (GET_MODE (dstb
) != Pmode
)
3186 dstb
= convert_memory_address (Pmode
, dstb
);
3188 if (GET_MODE (srcb
) != Pmode
)
3189 srcb
= convert_memory_address (Pmode
, srcb
);
3192 /* "Dereference" to BLKmode memories. */
3193 dstb
= gen_rtx_MEM (BLKmode
, dstb
);
3194 set_mem_alias_set (dstb
, get_alias_set (TREE_TYPE (TREE_TYPE (dst
))));
3195 set_mem_align (dstb
, TYPE_ALIGN (va_list_type_node
));
3196 srcb
= gen_rtx_MEM (BLKmode
, srcb
);
3197 set_mem_alias_set (srcb
, get_alias_set (TREE_TYPE (TREE_TYPE (src
))));
3198 set_mem_align (srcb
, TYPE_ALIGN (va_list_type_node
));
3201 emit_block_move (dstb
, srcb
, size
);
3207 /* Expand a call to one of the builtin functions __builtin_frame_address or
3208 __builtin_return_address. */
3211 expand_builtin_frame_address (exp
)
3214 tree fndecl
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
3215 tree arglist
= TREE_OPERAND (exp
, 1);
3217 /* The argument must be a nonnegative integer constant.
3218 It counts the number of frames to scan up the stack.
3219 The value is the return address saved in that frame. */
3221 /* Warning about missing arg was already issued. */
3223 else if (! host_integerp (TREE_VALUE (arglist
), 1))
3225 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
3226 error ("invalid arg to `__builtin_frame_address'");
3228 error ("invalid arg to `__builtin_return_address'");
3234 = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl
),
3235 tree_low_cst (TREE_VALUE (arglist
), 1),
3236 hard_frame_pointer_rtx
);
3238 /* Some ports cannot access arbitrary stack frames. */
3241 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
3242 warning ("unsupported arg to `__builtin_frame_address'");
3244 warning ("unsupported arg to `__builtin_return_address'");
3248 /* For __builtin_frame_address, return what we've got. */
3249 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
3252 if (GET_CODE (tem
) != REG
3253 && ! CONSTANT_P (tem
))
3254 tem
= copy_to_mode_reg (Pmode
, tem
);
3259 /* Expand a call to the alloca builtin, with arguments ARGLIST. Return 0 if
3260 we failed and the caller should emit a normal call, otherwise try to get
3261 the result in TARGET, if convenient. */
3264 expand_builtin_alloca (arglist
, target
)
3271 if (!validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
3274 /* Compute the argument. */
3275 op0
= expand_expr (TREE_VALUE (arglist
), NULL_RTX
, VOIDmode
, 0);
3277 /* Allocate the desired space. */
3278 result
= allocate_dynamic_stack_space (op0
, target
, BITS_PER_UNIT
);
3280 #ifdef POINTERS_EXTEND_UNSIGNED
3281 if (GET_MODE (result
) != ptr_mode
)
3282 result
= convert_memory_address (ptr_mode
, result
);
3288 /* Expand a call to the ffs builtin. The arguments are in ARGLIST.
3289 Return 0 if a normal call should be emitted rather than expanding the
3290 function in-line. If convenient, the result should be placed in TARGET.
3291 SUBTARGET may be used as the target for computing one of EXP's operands. */
3294 expand_builtin_ffs (arglist
, target
, subtarget
)
3296 rtx target
, subtarget
;
3299 if (!validate_arglist (arglist
, INTEGER_TYPE
, VOID_TYPE
))
3302 /* Compute the argument. */
3303 op0
= expand_expr (TREE_VALUE (arglist
), subtarget
, VOIDmode
, 0);
3304 /* Compute ffs, into TARGET if possible.
3305 Set TARGET to wherever the result comes back. */
3306 target
= expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist
))),
3307 ffs_optab
, op0
, target
, 1);
3313 /* If the string passed to fputs is a constant and is one character
3314 long, we attempt to transform this call into __builtin_fputc(). */
3317 expand_builtin_fputs (arglist
, ignore
, unlocked
)
3323 tree fn_fputc
= unlocked
? built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
]
3324 : built_in_decls
[BUILT_IN_FPUTC
];
3325 tree fn_fwrite
= unlocked
? built_in_decls
[BUILT_IN_FWRITE_UNLOCKED
]
3326 : built_in_decls
[BUILT_IN_FWRITE
];
3328 /* If the return value is used, or the replacement _DECL isn't
3329 initialized, don't do the transformation. */
3330 if (!ignore
|| !fn_fputc
|| !fn_fwrite
)
3333 /* Verify the arguments in the original call. */
3334 if (!validate_arglist (arglist
, POINTER_TYPE
, POINTER_TYPE
, VOID_TYPE
))
3337 /* Get the length of the string passed to fputs. If the length
3338 can't be determined, punt. */
3339 if (!(len
= c_strlen (TREE_VALUE (arglist
)))
3340 || TREE_CODE (len
) != INTEGER_CST
)
3343 switch (compare_tree_int (len
, 1))
3345 case -1: /* length is 0, delete the call entirely . */
3347 /* Evaluate and ignore the argument in case it has
3349 expand_expr (TREE_VALUE (TREE_CHAIN (arglist
)), const0_rtx
,
3350 VOIDmode
, EXPAND_NORMAL
);
3353 case 0: /* length is 1, call fputc. */
3355 const char *p
= c_getstr (TREE_VALUE (arglist
));
3359 /* New argument list transforming fputs(string, stream) to
3360 fputc(string[0], stream). */
3362 build_tree_list (NULL_TREE
, TREE_VALUE (TREE_CHAIN (arglist
)));
3364 tree_cons (NULL_TREE
, build_int_2 (p
[0], 0), arglist
);
3370 case 1: /* length is greater than 1, call fwrite. */
3372 tree string_arg
= TREE_VALUE (arglist
);
3374 /* New argument list transforming fputs(string, stream) to
3375 fwrite(string, 1, len, stream). */
3376 arglist
= build_tree_list (NULL_TREE
, TREE_VALUE (TREE_CHAIN (arglist
)));
3377 arglist
= tree_cons (NULL_TREE
, len
, arglist
);
3378 arglist
= tree_cons (NULL_TREE
, size_one_node
, arglist
);
3379 arglist
= tree_cons (NULL_TREE
, string_arg
, arglist
);
3387 return expand_expr (build_function_call_expr (fn
, arglist
),
3388 (ignore
? const0_rtx
: NULL_RTX
),
3389 VOIDmode
, EXPAND_NORMAL
);
3392 /* Expand a call to __builtin_expect. We return our argument and emit a
3393 NOTE_INSN_EXPECTED_VALUE note. This is the expansion of __builtin_expect in
3394 a non-jump context. */
3397 expand_builtin_expect (arglist
, target
)
3404 if (arglist
== NULL_TREE
3405 || TREE_CHAIN (arglist
) == NULL_TREE
)
3407 exp
= TREE_VALUE (arglist
);
3408 c
= TREE_VALUE (TREE_CHAIN (arglist
));
3410 if (TREE_CODE (c
) != INTEGER_CST
)
3412 error ("second arg to `__builtin_expect' must be a constant");
3413 c
= integer_zero_node
;
3416 target
= expand_expr (exp
, target
, VOIDmode
, EXPAND_NORMAL
);
3418 /* Don't bother with expected value notes for integral constants. */
3419 if (GET_CODE (target
) != CONST_INT
)
3421 /* We do need to force this into a register so that we can be
3422 moderately sure to be able to correctly interpret the branch
3424 target
= force_reg (GET_MODE (target
), target
);
3426 rtx_c
= expand_expr (c
, NULL_RTX
, GET_MODE (target
), EXPAND_NORMAL
);
3428 note
= emit_note (NULL
, NOTE_INSN_EXPECTED_VALUE
);
3429 NOTE_EXPECTED_VALUE (note
) = gen_rtx_EQ (VOIDmode
, target
, rtx_c
);
3435 /* Like expand_builtin_expect, except do this in a jump context. This is
3436 called from do_jump if the conditional is a __builtin_expect. Return either
3437 a SEQUENCE of insns to emit the jump or NULL if we cannot optimize
3438 __builtin_expect. We need to optimize this at jump time so that machines
3439 like the PowerPC don't turn the test into a SCC operation, and then jump
3440 based on the test being 0/1. */
3443 expand_builtin_expect_jump (exp
, if_false_label
, if_true_label
)
3448 tree arglist
= TREE_OPERAND (exp
, 1);
3449 tree arg0
= TREE_VALUE (arglist
);
3450 tree arg1
= TREE_VALUE (TREE_CHAIN (arglist
));
3453 /* Only handle __builtin_expect (test, 0) and
3454 __builtin_expect (test, 1). */
3455 if (TREE_CODE (TREE_TYPE (arg1
)) == INTEGER_TYPE
3456 && (integer_zerop (arg1
) || integer_onep (arg1
)))
3461 /* If we fail to locate an appropriate conditional jump, we'll
3462 fall back to normal evaluation. Ensure that the expression
3463 can be re-evaluated. */
3464 switch (unsafe_for_reeval (arg0
))
3469 case 1: /* Mildly unsafe. */
3470 arg0
= unsave_expr (arg0
);
3473 case 2: /* Wildly unsafe. */
3477 /* Expand the jump insns. */
3479 do_jump (arg0
, if_false_label
, if_true_label
);
3480 ret
= gen_sequence ();
3483 /* Now that the __builtin_expect has been validated, go through and add
3484 the expect's to each of the conditional jumps. If we run into an
3485 error, just give up and generate the 'safe' code of doing a SCC
3486 operation and then doing a branch on that. */
3487 for (j
= 0; j
< XVECLEN (ret
, 0); j
++)
3489 rtx insn
= XVECEXP (ret
, 0, j
);
3492 if (GET_CODE (insn
) == JUMP_INSN
&& any_condjump_p (insn
)
3493 && (pattern
= pc_set (insn
)) != NULL_RTX
)
3495 rtx ifelse
= SET_SRC (pattern
);
3499 if (GET_CODE (ifelse
) != IF_THEN_ELSE
)
3502 if (GET_CODE (XEXP (ifelse
, 1)) == LABEL_REF
)
3505 label
= XEXP (XEXP (ifelse
, 1), 0);
3507 /* An inverted jump reverses the probabilities. */
3508 else if (GET_CODE (XEXP (ifelse
, 2)) == LABEL_REF
)
3511 label
= XEXP (XEXP (ifelse
, 2), 0);
3513 /* We shouldn't have to worry about conditional returns during
3514 the expansion stage, but handle it gracefully anyway. */
3515 else if (GET_CODE (XEXP (ifelse
, 1)) == RETURN
)
3520 /* An inverted return reverses the probabilities. */
3521 else if (GET_CODE (XEXP (ifelse
, 2)) == RETURN
)
3529 /* If the test is expected to fail, reverse the
3531 if (integer_zerop (arg1
))
3534 /* If we are jumping to the false label, reverse the
3536 if (label
== NULL_RTX
)
3537 ; /* conditional return */
3538 else if (label
== if_false_label
)
3540 else if (label
!= if_true_label
)
3544 predict_insn_def (insn
, PRED_BUILTIN_EXPECT
, taken
);
3548 /* If no jumps were modified, fail and do __builtin_expect the normal
3557 /* Expand an expression EXP that calls a built-in function,
3558 with result going to TARGET if that's convenient
3559 (and in mode MODE if that's convenient).
3560 SUBTARGET may be used as the target for computing one of EXP's operands.
3561 IGNORE is nonzero if the value is to be ignored. */
3564 expand_builtin (exp
, target
, subtarget
, mode
, ignore
)
3568 enum machine_mode mode
;
3571 tree fndecl
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
3572 tree arglist
= TREE_OPERAND (exp
, 1);
3573 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
3575 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
3576 return (*targetm
.expand_builtin
) (exp
, target
, subtarget
, mode
, ignore
);
3578 /* When not optimizing, generate calls to library functions for a certain
3580 if (!optimize
&& !CALLED_AS_BUILT_IN (fndecl
))
3586 case BUILT_IN_SQRTF
:
3587 case BUILT_IN_SQRTL
:
3588 case BUILT_IN_MEMSET
:
3589 case BUILT_IN_MEMCPY
:
3590 case BUILT_IN_MEMCMP
:
3592 case BUILT_IN_BZERO
:
3593 case BUILT_IN_INDEX
:
3594 case BUILT_IN_RINDEX
:
3595 case BUILT_IN_STRCHR
:
3596 case BUILT_IN_STRRCHR
:
3597 case BUILT_IN_STRLEN
:
3598 case BUILT_IN_STRCPY
:
3599 case BUILT_IN_STRNCPY
:
3600 case BUILT_IN_STRNCMP
:
3601 case BUILT_IN_STRSTR
:
3602 case BUILT_IN_STRPBRK
:
3603 case BUILT_IN_STRCAT
:
3604 case BUILT_IN_STRNCAT
:
3605 case BUILT_IN_STRSPN
:
3606 case BUILT_IN_STRCSPN
:
3607 case BUILT_IN_STRCMP
:
3609 case BUILT_IN_PUTCHAR
:
3611 case BUILT_IN_PRINTF
:
3612 case BUILT_IN_FPUTC
:
3613 case BUILT_IN_FPUTS
:
3614 case BUILT_IN_FWRITE
:
3615 case BUILT_IN_PUTCHAR_UNLOCKED
:
3616 case BUILT_IN_PUTS_UNLOCKED
:
3617 case BUILT_IN_PRINTF_UNLOCKED
:
3618 case BUILT_IN_FPUTC_UNLOCKED
:
3619 case BUILT_IN_FPUTS_UNLOCKED
:
3620 case BUILT_IN_FWRITE_UNLOCKED
:
3621 return expand_call (exp
, target
, ignore
);
3631 case BUILT_IN_LLABS
:
3632 case BUILT_IN_IMAXABS
:
3634 case BUILT_IN_FABSF
:
3635 case BUILT_IN_FABSL
:
3636 /* build_function_call changes these into ABS_EXPR. */
3640 case BUILT_IN_CONJF
:
3641 case BUILT_IN_CONJL
:
3642 case BUILT_IN_CREAL
:
3643 case BUILT_IN_CREALF
:
3644 case BUILT_IN_CREALL
:
3645 case BUILT_IN_CIMAG
:
3646 case BUILT_IN_CIMAGF
:
3647 case BUILT_IN_CIMAGL
:
3648 /* expand_tree_builtin changes these into CONJ_EXPR, REALPART_EXPR
3649 and IMAGPART_EXPR. */
3658 /* Treat these like sqrt only if unsafe math optimizations are allowed,
3659 because of possible accuracy problems. */
3660 if (! flag_unsafe_math_optimizations
)
3663 case BUILT_IN_SQRTF
:
3664 case BUILT_IN_SQRTL
:
3665 target
= expand_builtin_mathfn (exp
, target
, subtarget
);
3673 case BUILT_IN_APPLY_ARGS
:
3674 return expand_builtin_apply_args ();
3676 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
3677 FUNCTION with a copy of the parameters described by
3678 ARGUMENTS, and ARGSIZE. It returns a block of memory
3679 allocated on the stack into which is stored all the registers
3680 that might possibly be used for returning the result of a
3681 function. ARGUMENTS is the value returned by
3682 __builtin_apply_args. ARGSIZE is the number of bytes of
3683 arguments that must be copied. ??? How should this value be
3684 computed? We'll also need a safe worst case value for varargs
3686 case BUILT_IN_APPLY
:
3687 if (!validate_arglist (arglist
, POINTER_TYPE
,
3688 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
)
3689 && !validate_arglist (arglist
, REFERENCE_TYPE
,
3690 POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3698 for (t
= arglist
, i
= 0; t
; t
= TREE_CHAIN (t
), i
++)
3699 ops
[i
] = expand_expr (TREE_VALUE (t
), NULL_RTX
, VOIDmode
, 0);
3701 return expand_builtin_apply (ops
[0], ops
[1], ops
[2]);
3704 /* __builtin_return (RESULT) causes the function to return the
3705 value described by RESULT. RESULT is address of the block of
3706 memory returned by __builtin_apply. */
3707 case BUILT_IN_RETURN
:
3708 if (validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
3709 expand_builtin_return (expand_expr (TREE_VALUE (arglist
),
3710 NULL_RTX
, VOIDmode
, 0));
3713 case BUILT_IN_SAVEREGS
:
3714 return expand_builtin_saveregs ();
3716 case BUILT_IN_ARGS_INFO
:
3717 return expand_builtin_args_info (exp
);
3719 /* Return the address of the first anonymous stack arg. */
3720 case BUILT_IN_NEXT_ARG
:
3721 return expand_builtin_next_arg (arglist
);
3723 case BUILT_IN_CLASSIFY_TYPE
:
3724 return expand_builtin_classify_type (arglist
);
3726 case BUILT_IN_CONSTANT_P
:
3727 return expand_builtin_constant_p (exp
);
3729 case BUILT_IN_FRAME_ADDRESS
:
3730 case BUILT_IN_RETURN_ADDRESS
:
3731 return expand_builtin_frame_address (exp
);
3733 /* Returns the address of the area where the structure is returned.
3735 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS
:
3737 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
)))
3738 || GET_CODE (DECL_RTL (DECL_RESULT (current_function_decl
))) != MEM
)
3741 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl
)), 0);
3743 case BUILT_IN_ALLOCA
:
3744 target
= expand_builtin_alloca (arglist
, target
);
3750 target
= expand_builtin_ffs (arglist
, target
, subtarget
);
3755 case BUILT_IN_STRLEN
:
3756 target
= expand_builtin_strlen (exp
, target
);
3761 case BUILT_IN_STRCPY
:
3762 target
= expand_builtin_strcpy (exp
, target
, mode
);
3767 case BUILT_IN_STRNCPY
:
3768 target
= expand_builtin_strncpy (arglist
, target
, mode
);
3773 case BUILT_IN_STRCAT
:
3774 target
= expand_builtin_strcat (arglist
, target
, mode
);
3779 case BUILT_IN_STRNCAT
:
3780 target
= expand_builtin_strncat (arglist
, target
, mode
);
3785 case BUILT_IN_STRSPN
:
3786 target
= expand_builtin_strspn (arglist
, target
, mode
);
3791 case BUILT_IN_STRCSPN
:
3792 target
= expand_builtin_strcspn (arglist
, target
, mode
);
3797 case BUILT_IN_STRSTR
:
3798 target
= expand_builtin_strstr (arglist
, target
, mode
);
3803 case BUILT_IN_STRPBRK
:
3804 target
= expand_builtin_strpbrk (arglist
, target
, mode
);
3809 case BUILT_IN_INDEX
:
3810 case BUILT_IN_STRCHR
:
3811 target
= expand_builtin_strchr (arglist
, target
, mode
);
3816 case BUILT_IN_RINDEX
:
3817 case BUILT_IN_STRRCHR
:
3818 target
= expand_builtin_strrchr (arglist
, target
, mode
);
3823 case BUILT_IN_MEMCPY
:
3824 target
= expand_builtin_memcpy (arglist
, target
, mode
);
3829 case BUILT_IN_MEMSET
:
3830 target
= expand_builtin_memset (exp
, target
, mode
);
3835 case BUILT_IN_BZERO
:
3836 target
= expand_builtin_bzero (exp
);
3841 case BUILT_IN_STRCMP
:
3842 target
= expand_builtin_strcmp (exp
, target
, mode
);
3847 case BUILT_IN_STRNCMP
:
3848 target
= expand_builtin_strncmp (exp
, target
, mode
);
3854 case BUILT_IN_MEMCMP
:
3855 target
= expand_builtin_memcmp (exp
, arglist
, target
, mode
);
3860 case BUILT_IN_SETJMP
:
3861 target
= expand_builtin_setjmp (arglist
, target
);
3866 /* __builtin_longjmp is passed a pointer to an array of five words.
3867 It's similar to the C library longjmp function but works with
3868 __builtin_setjmp above. */
3869 case BUILT_IN_LONGJMP
:
3870 if (!validate_arglist (arglist
, POINTER_TYPE
, INTEGER_TYPE
, VOID_TYPE
))
3874 rtx buf_addr
= expand_expr (TREE_VALUE (arglist
), subtarget
,
3876 rtx value
= expand_expr (TREE_VALUE (TREE_CHAIN (arglist
)),
3877 NULL_RTX
, VOIDmode
, 0);
3879 if (value
!= const1_rtx
)
3881 error ("__builtin_longjmp second argument must be 1");
3885 expand_builtin_longjmp (buf_addr
, value
);
3892 emit_insn (gen_trap ());
3895 error ("__builtin_trap not supported by this target");
3899 case BUILT_IN_PUTCHAR
:
3901 case BUILT_IN_FPUTC
:
3902 case BUILT_IN_FWRITE
:
3903 case BUILT_IN_PUTCHAR_UNLOCKED
:
3904 case BUILT_IN_PUTS_UNLOCKED
:
3905 case BUILT_IN_FPUTC_UNLOCKED
:
3906 case BUILT_IN_FWRITE_UNLOCKED
:
3908 case BUILT_IN_FPUTS
:
3909 target
= expand_builtin_fputs (arglist
, ignore
,/*unlocked=*/ 0);
3913 case BUILT_IN_FPUTS_UNLOCKED
:
3914 target
= expand_builtin_fputs (arglist
, ignore
,/*unlocked=*/ 1);
3919 /* Various hooks for the DWARF 2 __throw routine. */
3920 case BUILT_IN_UNWIND_INIT
:
3921 expand_builtin_unwind_init ();
3923 case BUILT_IN_DWARF_CFA
:
3924 return virtual_cfa_rtx
;
3925 #ifdef DWARF2_UNWIND_INFO
3926 case BUILT_IN_DWARF_FP_REGNUM
:
3927 return expand_builtin_dwarf_fp_regnum ();
3928 case BUILT_IN_INIT_DWARF_REG_SIZES
:
3929 expand_builtin_init_dwarf_reg_sizes (TREE_VALUE (arglist
));
3932 case BUILT_IN_FROB_RETURN_ADDR
:
3933 return expand_builtin_frob_return_addr (TREE_VALUE (arglist
));
3934 case BUILT_IN_EXTRACT_RETURN_ADDR
:
3935 return expand_builtin_extract_return_addr (TREE_VALUE (arglist
));
3936 case BUILT_IN_EH_RETURN
:
3937 expand_builtin_eh_return (TREE_VALUE (arglist
),
3938 TREE_VALUE (TREE_CHAIN (arglist
)));
3940 #ifdef EH_RETURN_DATA_REGNO
3941 case BUILT_IN_EH_RETURN_DATA_REGNO
:
3942 return expand_builtin_eh_return_data_regno (arglist
);
3944 case BUILT_IN_VARARGS_START
:
3945 return expand_builtin_va_start (0, arglist
);
3946 case BUILT_IN_STDARG_START
:
3947 return expand_builtin_va_start (1, arglist
);
3948 case BUILT_IN_VA_END
:
3949 return expand_builtin_va_end (arglist
);
3950 case BUILT_IN_VA_COPY
:
3951 return expand_builtin_va_copy (arglist
);
3952 case BUILT_IN_EXPECT
:
3953 return expand_builtin_expect (arglist
, target
);
3954 case BUILT_IN_PREFETCH
:
3955 expand_builtin_prefetch (arglist
);
3959 default: /* just do library call, if unknown builtin */
3960 error ("built-in function `%s' not currently supported",
3961 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
3964 /* The switch statement above can drop through to cause the function
3965 to be called normally. */
3966 return expand_call (exp
, target
, ignore
);
3969 /* Fold a call to __builtin_constant_p, if we know it will evaluate to a
3970 constant. ARGLIST is the argument list of the call. */
3973 fold_builtin_constant_p (arglist
)
3979 arglist
= TREE_VALUE (arglist
);
3981 /* We return 1 for a numeric type that's known to be a constant
3982 value at compile-time or for an aggregate type that's a
3983 literal constant. */
3984 STRIP_NOPS (arglist
);
3986 /* If we know this is a constant, emit the constant of one. */
3987 if (TREE_CODE_CLASS (TREE_CODE (arglist
)) == 'c'
3988 || (TREE_CODE (arglist
) == CONSTRUCTOR
3989 && TREE_CONSTANT (arglist
))
3990 || (TREE_CODE (arglist
) == ADDR_EXPR
3991 && TREE_CODE (TREE_OPERAND (arglist
, 0)) == STRING_CST
))
3992 return integer_one_node
;
3994 /* If we aren't going to be running CSE or this expression
3995 has side effects, show we don't know it to be a constant.
3996 Likewise if it's a pointer or aggregate type since in those
3997 case we only want literals, since those are only optimized
3998 when generating RTL, not later.
3999 And finally, if we are compiling an initializer, not code, we
4000 need to return a definite result now; there's not going to be any
4001 more optimization done. */
4002 if (TREE_SIDE_EFFECTS (arglist
) || cse_not_expected
4003 || AGGREGATE_TYPE_P (TREE_TYPE (arglist
))
4004 || POINTER_TYPE_P (TREE_TYPE (arglist
))
4006 return integer_zero_node
;
4011 /* Fold a call to __builtin_classify_type. */
4014 fold_builtin_classify_type (arglist
)
4018 return build_int_2 (no_type_class
, 0);
4020 return build_int_2 (type_to_class (TREE_TYPE (TREE_VALUE (arglist
))), 0);
4023 /* Used by constant folding to eliminate some builtin calls early. EXP is
4024 the CALL_EXPR of a call to a builtin function. */
4030 tree fndecl
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
4031 tree arglist
= TREE_OPERAND (exp
, 1);
4032 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
4034 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
4039 case BUILT_IN_CONSTANT_P
:
4040 return fold_builtin_constant_p (arglist
);
4042 case BUILT_IN_CLASSIFY_TYPE
:
4043 return fold_builtin_classify_type (arglist
);
4045 case BUILT_IN_STRLEN
:
4046 if (validate_arglist (arglist
, POINTER_TYPE
, VOID_TYPE
))
4048 tree len
= c_strlen (TREE_VALUE (arglist
));
4062 build_function_call_expr (fn
, arglist
)
4067 call_expr
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (fn
)), fn
);
4068 call_expr
= build (CALL_EXPR
, TREE_TYPE (TREE_TYPE (fn
)),
4069 call_expr
, arglist
);
4070 TREE_SIDE_EFFECTS (call_expr
) = 1;
4071 return fold (call_expr
);
4074 /* This function validates the types of a function call argument list
4075 represented as a tree chain of parameters against a specified list
4076 of tree_codes. If the last specifier is a 0, that represents an
4077 ellipses, otherwise the last specifier must be a VOID_TYPE. */
4080 validate_arglist
VPARAMS ((tree arglist
, ...))
4082 enum tree_code code
;
4085 VA_OPEN (ap
, arglist
);
4086 VA_FIXEDARG (ap
, tree
, arglist
);
4089 code
= va_arg (ap
, enum tree_code
);
4093 /* This signifies an ellipses, any further arguments are all ok. */
4097 /* This signifies an endlink, if no arguments remain, return
4098 true, otherwise return false. */
4102 /* If no parameters remain or the parameter's code does not
4103 match the specified code, return false. Otherwise continue
4104 checking any remaining arguments. */
4105 if (arglist
== 0 || code
!= TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))))
4109 arglist
= TREE_CHAIN (arglist
);
4112 /* We need gotos here since we can only have one VA_CLOSE in a
4120 /* Default version of target-specific builtin setup that does nothing. */
4123 default_init_builtins ()
4127 /* Default target-specific builtin expander that does nothing. */
4130 default_expand_builtin (exp
, target
, subtarget
, mode
, ignore
)
4131 tree exp ATTRIBUTE_UNUSED
;
4132 rtx target ATTRIBUTE_UNUSED
;
4133 rtx subtarget ATTRIBUTE_UNUSED
;
4134 enum machine_mode mode ATTRIBUTE_UNUSED
;
4135 int ignore ATTRIBUTE_UNUSED
;