1 /* Expand builtin functions.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
30 #include "hard-reg-set.h"
33 #include "insn-flags.h"
34 #include "insn-codes.h"
35 #include "insn-config.h"
39 #include "typeclass.h"
44 #define CALLED_AS_BUILT_IN(NODE) \
45 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
47 /* Register mappings for target machines without register windows. */
48 #ifndef INCOMING_REGNO
49 #define INCOMING_REGNO(OUT) (OUT)
51 #ifndef OUTGOING_REGNO
52 #define OUTGOING_REGNO(IN) (IN)
55 #ifndef PAD_VARARGS_DOWN
56 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
59 tree (*lang_type_promotes_to) PARAMS ((tree));
61 static int get_pointer_alignment PARAMS ((tree, unsigned));
62 static tree c_strlen PARAMS ((tree));
63 static rtx get_memory_rtx PARAMS ((tree));
64 static int apply_args_size PARAMS ((void));
65 static int apply_result_size PARAMS ((void));
66 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
67 static rtx result_vector PARAMS ((int, rtx));
69 static rtx expand_builtin_apply_args PARAMS ((void));
70 static rtx expand_builtin_apply_args_1 PARAMS ((void));
71 static rtx expand_builtin_apply PARAMS ((rtx, rtx, rtx));
72 static void expand_builtin_return PARAMS ((rtx));
73 static rtx expand_builtin_classify_type PARAMS ((tree));
74 static rtx expand_builtin_mathfn PARAMS ((tree, rtx, rtx));
75 static rtx expand_builtin_constant_p PARAMS ((tree));
76 static rtx expand_builtin_args_info PARAMS ((tree));
77 static rtx expand_builtin_next_arg PARAMS ((tree));
78 static rtx expand_builtin_va_start PARAMS ((int, tree));
79 static rtx expand_builtin_va_end PARAMS ((tree));
80 static rtx expand_builtin_va_copy PARAMS ((tree));
82 static rtx expand_builtin_memcmp PARAMS ((tree, tree, rtx));
83 static rtx expand_builtin_strcmp PARAMS ((tree, rtx));
85 static rtx expand_builtin_memcpy PARAMS ((tree));
86 static rtx expand_builtin_strcpy PARAMS ((tree));
87 static rtx expand_builtin_memset PARAMS ((tree));
88 static rtx expand_builtin_strlen PARAMS ((tree, rtx, enum machine_mode));
89 static rtx expand_builtin_alloca PARAMS ((tree, rtx));
90 static rtx expand_builtin_ffs PARAMS ((tree, rtx, rtx));
91 static rtx expand_builtin_frame_address PARAMS ((tree));
92 static tree stabilize_va_list PARAMS ((tree, int));
94 /* Return the alignment in bits of EXP, a pointer valued expression.
95 But don't return more than MAX_ALIGN no matter what.
96 The alignment returned is, by default, the alignment of the thing that
97 EXP points to (if it is not a POINTER_TYPE, 0 is returned).
99 Otherwise, look at the expression to see if we can do better, i.e., if the
100 expression is actually pointing at an object whose alignment is tighter. */
103 get_pointer_alignment (exp, max_align)
107 unsigned align, inner;
109 if (TREE_CODE (TREE_TYPE (exp)) != POINTER_TYPE)
112 align = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
113 align = MIN (align, max_align);
117 switch (TREE_CODE (exp))
121 case NON_LVALUE_EXPR:
122 exp = TREE_OPERAND (exp, 0);
123 if (TREE_CODE (TREE_TYPE (exp)) != POINTER_TYPE)
125 inner = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
126 align = MIN (inner, max_align);
130 /* If sum of pointer + int, restrict our maximum alignment to that
131 imposed by the integer. If not, we can't do any better than
133 if (TREE_CODE (TREE_OPERAND (exp, 1)) != INTEGER_CST)
136 while (((TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)) * BITS_PER_UNIT)
141 exp = TREE_OPERAND (exp, 0);
145 /* See what we are pointing at and look at its alignment. */
146 exp = TREE_OPERAND (exp, 0);
147 if (TREE_CODE (exp) == FUNCTION_DECL)
148 align = FUNCTION_BOUNDARY;
149 else if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd')
150 align = DECL_ALIGN (exp);
151 #ifdef CONSTANT_ALIGNMENT
152 else if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c')
153 align = CONSTANT_ALIGNMENT (exp, align);
155 return MIN (align, max_align);
163 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
164 way, because it could contain a zero byte in the middle.
165 TREE_STRING_LENGTH is the size of the character array, not the string.
167 Unfortunately, string_constant can't access the values of const char
168 arrays with initializers, so neither can we do so here. */
178 src = string_constant (src, &offset_node);
181 max = TREE_STRING_LENGTH (src);
182 ptr = TREE_STRING_POINTER (src);
183 if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
185 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
186 compute the offset to the following null if we don't know where to
187 start searching for it. */
189 for (i = 0; i < max; i++)
192 /* We don't know the starting offset, but we do know that the string
193 has no internal zero bytes. We can assume that the offset falls
194 within the bounds of the string; otherwise, the programmer deserves
195 what he gets. Subtract the offset from the length of the string,
197 /* This would perhaps not be valid if we were dealing with named
198 arrays in addition to literal string constants. */
199 return size_binop (MINUS_EXPR, size_int (max), offset_node);
202 /* We have a known offset into the string. Start searching there for
204 if (offset_node == 0)
208 /* Did we get a long long offset? If so, punt. */
209 if (TREE_INT_CST_HIGH (offset_node) != 0)
211 offset = TREE_INT_CST_LOW (offset_node);
213 /* If the offset is known to be out of bounds, warn, and call strlen at
215 if (offset < 0 || offset > max)
217 warning ("offset outside bounds of constant string");
220 /* Use strlen to search for the first zero byte. Since any strings
221 constructed with build_string will have nulls appended, we win even
222 if we get handed something like (char[4])"abcd".
224 Since OFFSET is our starting index into the string, no further
225 calculation is needed. */
226 return size_int (strlen (ptr + offset));
229 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
230 times to get the address of either a higher stack frame, or a return
231 address located within it (depending on FNDECL_CODE). */
233 expand_builtin_return_addr (fndecl_code, count, tem)
234 enum built_in_function fndecl_code;
240 /* Some machines need special handling before we can access
241 arbitrary frames. For example, on the sparc, we must first flush
242 all register windows to the stack. */
243 #ifdef SETUP_FRAME_ADDRESSES
245 SETUP_FRAME_ADDRESSES ();
248 /* On the sparc, the return address is not in the frame, it is in a
249 register. There is no way to access it off of the current frame
250 pointer, but it can be accessed off the previous frame pointer by
251 reading the value from the register window save area. */
252 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
253 if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
257 /* Scan back COUNT frames to the specified frame. */
258 for (i = 0; i < count; i++)
260 /* Assume the dynamic chain pointer is in the word that the
261 frame address points to, unless otherwise specified. */
262 #ifdef DYNAMIC_CHAIN_ADDRESS
263 tem = DYNAMIC_CHAIN_ADDRESS (tem);
265 tem = memory_address (Pmode, tem);
266 tem = copy_to_reg (gen_rtx_MEM (Pmode, tem));
269 /* For __builtin_frame_address, return what we've got. */
270 if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
273 /* For __builtin_return_address, Get the return address from that
275 #ifdef RETURN_ADDR_RTX
276 tem = RETURN_ADDR_RTX (count, tem);
278 tem = memory_address (Pmode,
279 plus_constant (tem, GET_MODE_SIZE (Pmode)));
280 tem = gen_rtx_MEM (Pmode, tem);
285 /* __builtin_setjmp is passed a pointer to an array of five words (not
286 all will be used on all machines). It operates similarly to the C
287 library function of the same name, but is more efficient. Much of
288 the code below (and for longjmp) is copied from the handling of
291 NOTE: This is intended for use by GNAT and the exception handling
292 scheme in the compiler and will only work in the method used by
296 expand_builtin_setjmp (buf_addr, target, first_label, next_label)
299 rtx first_label, next_label;
301 rtx lab1 = gen_label_rtx ();
302 enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
303 enum machine_mode value_mode;
306 value_mode = TYPE_MODE (integer_type_node);
308 #ifdef POINTERS_EXTEND_UNSIGNED
309 buf_addr = convert_memory_address (Pmode, buf_addr);
312 buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
314 if (target == 0 || GET_CODE (target) != REG
315 || REGNO (target) < FIRST_PSEUDO_REGISTER)
316 target = gen_reg_rtx (value_mode);
320 /* We store the frame pointer and the address of lab1 in the buffer
321 and use the rest of it for the stack save area, which is
322 machine-dependent. */
324 #ifndef BUILTIN_SETJMP_FRAME_VALUE
325 #define BUILTIN_SETJMP_FRAME_VALUE virtual_stack_vars_rtx
328 emit_move_insn (gen_rtx_MEM (Pmode, buf_addr),
329 BUILTIN_SETJMP_FRAME_VALUE);
330 emit_move_insn (validize_mem
332 plus_constant (buf_addr,
333 GET_MODE_SIZE (Pmode)))),
334 force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, lab1)));
336 stack_save = gen_rtx_MEM (sa_mode,
337 plus_constant (buf_addr,
338 2 * GET_MODE_SIZE (Pmode)));
339 emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
341 /* If there is further processing to do, do it. */
342 #ifdef HAVE_builtin_setjmp_setup
343 if (HAVE_builtin_setjmp_setup)
344 emit_insn (gen_builtin_setjmp_setup (buf_addr));
347 /* Set TARGET to zero and branch to the first-time-through label. */
348 emit_move_insn (target, const0_rtx);
349 emit_jump_insn (gen_jump (first_label));
353 /* Tell flow about the strange goings on. Putting `lab1' on
354 `nonlocal_goto_handler_labels' to indicates that function
355 calls may traverse the arc back to this label. */
357 current_function_has_nonlocal_label = 1;
358 nonlocal_goto_handler_labels =
359 gen_rtx_EXPR_LIST (VOIDmode, lab1, nonlocal_goto_handler_labels);
361 /* Clobber the FP when we get here, so we have to make sure it's
362 marked as used by this function. */
363 emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
365 /* Mark the static chain as clobbered here so life information
366 doesn't get messed up for it. */
367 emit_insn (gen_rtx_CLOBBER (VOIDmode, static_chain_rtx));
369 /* Now put in the code to restore the frame pointer, and argument
370 pointer, if needed. The code below is from expand_end_bindings
371 in stmt.c; see detailed documentation there. */
372 #ifdef HAVE_nonlocal_goto
373 if (! HAVE_nonlocal_goto)
375 emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
377 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
378 if (fixed_regs[ARG_POINTER_REGNUM])
380 #ifdef ELIMINABLE_REGS
382 static struct elims {int from, to;} elim_regs[] = ELIMINABLE_REGS;
384 for (i = 0; i < sizeof elim_regs / sizeof elim_regs[0]; i++)
385 if (elim_regs[i].from == ARG_POINTER_REGNUM
386 && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
389 if (i == sizeof elim_regs / sizeof elim_regs [0])
392 /* Now restore our arg pointer from the address at which it
393 was saved in our stack frame.
394 If there hasn't be space allocated for it yet, make
396 if (arg_pointer_save_area == 0)
397 arg_pointer_save_area
398 = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0);
399 emit_move_insn (virtual_incoming_args_rtx,
400 copy_to_reg (arg_pointer_save_area));
405 #ifdef HAVE_builtin_setjmp_receiver
406 if (HAVE_builtin_setjmp_receiver)
407 emit_insn (gen_builtin_setjmp_receiver (lab1));
410 #ifdef HAVE_nonlocal_goto_receiver
411 if (HAVE_nonlocal_goto_receiver)
412 emit_insn (gen_nonlocal_goto_receiver ());
419 /* Set TARGET, and branch to the next-time-through label. */
420 emit_move_insn (target, const1_rtx);
421 emit_jump_insn (gen_jump (next_label));
427 /* __builtin_longjmp is passed a pointer to an array of five words (not
428 all will be used on all machines). It operates similarly to the C
429 library function of the same name, but is more efficient. Much of
430 the code below is copied from the handling of non-local gotos.
432 NOTE: This is intended for use by GNAT and the exception handling
433 scheme in the compiler and will only work in the method used by
437 expand_builtin_longjmp (buf_addr, value)
441 enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
443 #ifdef POINTERS_EXTEND_UNSIGNED
444 buf_addr = convert_memory_address (Pmode, buf_addr);
446 buf_addr = force_reg (Pmode, buf_addr);
448 /* We used to store value in static_chain_rtx, but that fails if pointers
449 are smaller than integers. We instead require that the user must pass
450 a second argument of 1, because that is what builtin_setjmp will
451 return. This also makes EH slightly more efficient, since we are no
452 longer copying around a value that we don't care about. */
453 if (value != const1_rtx)
456 #ifdef HAVE_builtin_longjmp
457 if (HAVE_builtin_longjmp)
458 emit_insn (gen_builtin_longjmp (buf_addr));
462 fp = gen_rtx_MEM (Pmode, buf_addr);
463 lab = gen_rtx_MEM (Pmode, plus_constant (buf_addr,
464 GET_MODE_SIZE (Pmode)));
466 stack = gen_rtx_MEM (sa_mode, plus_constant (buf_addr,
467 2 * GET_MODE_SIZE (Pmode)));
469 /* Pick up FP, label, and SP from the block and jump. This code is
470 from expand_goto in stmt.c; see there for detailed comments. */
471 #if HAVE_nonlocal_goto
472 if (HAVE_nonlocal_goto)
473 /* We have to pass a value to the nonlocal_goto pattern that will
474 get copied into the static_chain pointer, but it does not matter
475 what that value is, because builtin_setjmp does not use it. */
476 emit_insn (gen_nonlocal_goto (value, fp, stack, lab));
480 lab = copy_to_reg (lab);
482 emit_move_insn (hard_frame_pointer_rtx, fp);
483 emit_stack_restore (SAVE_NONLOCAL, stack, NULL_RTX);
485 emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
486 emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
487 emit_indirect_jump (lab);
492 /* Get a MEM rtx for expression EXP which can be used in a string instruction
493 (cmpstrsi, movstrsi, ..). */
501 mem = gen_rtx_MEM (BLKmode,
502 memory_address (BLKmode,
503 expand_expr (exp, NULL_RTX,
504 ptr_mode, EXPAND_SUM)));
506 RTX_UNCHANGING_P (mem) = TREE_READONLY (exp);
508 /* Figure out the type of the object pointed to. Set MEM_IN_STRUCT_P
509 if the value is the address of a structure or if the expression is
510 cast to a pointer to structure type. */
513 while (TREE_CODE (exp) == NOP_EXPR)
515 tree cast_type = TREE_TYPE (exp);
516 if (TREE_CODE (cast_type) == POINTER_TYPE
517 && AGGREGATE_TYPE_P (TREE_TYPE (cast_type)))
522 exp = TREE_OPERAND (exp, 0);
525 if (is_aggregate == 0)
529 if (TREE_CODE (exp) == ADDR_EXPR)
530 /* If this is the address of an object, check whether the
531 object is an array. */
532 type = TREE_TYPE (TREE_OPERAND (exp, 0));
534 type = TREE_TYPE (TREE_TYPE (exp));
535 is_aggregate = AGGREGATE_TYPE_P (type);
538 MEM_SET_IN_STRUCT_P (mem, is_aggregate);
542 /* Built-in functions to perform an untyped call and return. */
544 /* For each register that may be used for calling a function, this
545 gives a mode used to copy the register's value. VOIDmode indicates
546 the register is not used for calling a function. If the machine
547 has register windows, this gives only the outbound registers.
548 INCOMING_REGNO gives the corresponding inbound register. */
549 static enum machine_mode apply_args_mode[FIRST_PSEUDO_REGISTER];
551 /* For each register that may be used for returning values, this gives
552 a mode used to copy the register's value. VOIDmode indicates the
553 register is not used for returning values. If the machine has
554 register windows, this gives only the outbound registers.
555 INCOMING_REGNO gives the corresponding inbound register. */
556 static enum machine_mode apply_result_mode[FIRST_PSEUDO_REGISTER];
558 /* For each register that may be used for calling a function, this
559 gives the offset of that register into the block returned by
560 __builtin_apply_args. 0 indicates that the register is not
561 used for calling a function. */
562 static int apply_args_reg_offset[FIRST_PSEUDO_REGISTER];
564 /* Return the offset of register REGNO into the block returned by
565 __builtin_apply_args. This is not declared static, since it is
566 needed in objc-act.c. */
569 apply_args_register_offset (regno)
574 /* Arguments are always put in outgoing registers (in the argument
575 block) if such make sense. */
576 #ifdef OUTGOING_REGNO
577 regno = OUTGOING_REGNO(regno);
579 return apply_args_reg_offset[regno];
582 /* Return the size required for the block returned by __builtin_apply_args,
583 and initialize apply_args_mode. */
588 static int size = -1;
590 enum machine_mode mode;
592 /* The values computed by this function never change. */
595 /* The first value is the incoming arg-pointer. */
596 size = GET_MODE_SIZE (Pmode);
598 /* The second value is the structure value address unless this is
599 passed as an "invisible" first argument. */
600 if (struct_value_rtx)
601 size += GET_MODE_SIZE (Pmode);
603 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
604 if (FUNCTION_ARG_REGNO_P (regno))
606 /* Search for the proper mode for copying this register's
607 value. I'm not sure this is right, but it works so far. */
608 enum machine_mode best_mode = VOIDmode;
610 for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
612 mode = GET_MODE_WIDER_MODE (mode))
613 if (HARD_REGNO_MODE_OK (regno, mode)
614 && HARD_REGNO_NREGS (regno, mode) == 1)
617 if (best_mode == VOIDmode)
618 for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
620 mode = GET_MODE_WIDER_MODE (mode))
621 if (HARD_REGNO_MODE_OK (regno, mode)
622 && (mov_optab->handlers[(int) mode].insn_code
623 != CODE_FOR_nothing))
627 if (mode == VOIDmode)
630 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
631 if (size % align != 0)
632 size = CEIL (size, align) * align;
633 apply_args_reg_offset[regno] = size;
634 size += GET_MODE_SIZE (mode);
635 apply_args_mode[regno] = mode;
639 apply_args_mode[regno] = VOIDmode;
640 apply_args_reg_offset[regno] = 0;
646 /* Return the size required for the block returned by __builtin_apply,
647 and initialize apply_result_mode. */
652 static int size = -1;
654 enum machine_mode mode;
656 /* The values computed by this function never change. */
661 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
662 if (FUNCTION_VALUE_REGNO_P (regno))
664 /* Search for the proper mode for copying this register's
665 value. I'm not sure this is right, but it works so far. */
666 enum machine_mode best_mode = VOIDmode;
668 for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
670 mode = GET_MODE_WIDER_MODE (mode))
671 if (HARD_REGNO_MODE_OK (regno, mode))
674 if (best_mode == VOIDmode)
675 for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
677 mode = GET_MODE_WIDER_MODE (mode))
678 if (HARD_REGNO_MODE_OK (regno, mode)
679 && (mov_optab->handlers[(int) mode].insn_code
680 != CODE_FOR_nothing))
684 if (mode == VOIDmode)
687 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
688 if (size % align != 0)
689 size = CEIL (size, align) * align;
690 size += GET_MODE_SIZE (mode);
691 apply_result_mode[regno] = mode;
694 apply_result_mode[regno] = VOIDmode;
696 /* Allow targets that use untyped_call and untyped_return to override
697 the size so that machine-specific information can be stored here. */
698 #ifdef APPLY_RESULT_SIZE
699 size = APPLY_RESULT_SIZE;
705 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
706 /* Create a vector describing the result block RESULT. If SAVEP is true,
707 the result block is used to save the values; otherwise it is used to
708 restore the values. */
711 result_vector (savep, result)
715 int regno, size, align, nelts;
716 enum machine_mode mode;
718 rtx *savevec = (rtx *) alloca (FIRST_PSEUDO_REGISTER * sizeof (rtx));
721 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
722 if ((mode = apply_result_mode[regno]) != VOIDmode)
724 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
725 if (size % align != 0)
726 size = CEIL (size, align) * align;
727 reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
728 mem = change_address (result, mode,
729 plus_constant (XEXP (result, 0), size));
730 savevec[nelts++] = (savep
731 ? gen_rtx_SET (VOIDmode, mem, reg)
732 : gen_rtx_SET (VOIDmode, reg, mem));
733 size += GET_MODE_SIZE (mode);
735 return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
737 #endif /* HAVE_untyped_call or HAVE_untyped_return */
739 /* Save the state required to perform an untyped call with the same
740 arguments as were passed to the current function. */
743 expand_builtin_apply_args_1 ()
746 int size, align, regno;
747 enum machine_mode mode;
749 /* Create a block where the arg-pointer, structure value address,
750 and argument registers can be saved. */
751 registers = assign_stack_local (BLKmode, apply_args_size (), -1);
753 /* Walk past the arg-pointer and structure value address. */
754 size = GET_MODE_SIZE (Pmode);
755 if (struct_value_rtx)
756 size += GET_MODE_SIZE (Pmode);
758 /* Save each register used in calling a function to the block. */
759 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
760 if ((mode = apply_args_mode[regno]) != VOIDmode)
764 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
765 if (size % align != 0)
766 size = CEIL (size, align) * align;
768 tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
770 emit_move_insn (change_address (registers, mode,
771 plus_constant (XEXP (registers, 0),
774 size += GET_MODE_SIZE (mode);
777 /* Save the arg pointer to the block. */
778 emit_move_insn (change_address (registers, Pmode, XEXP (registers, 0)),
779 copy_to_reg (virtual_incoming_args_rtx));
780 size = GET_MODE_SIZE (Pmode);
782 /* Save the structure value address unless this is passed as an
783 "invisible" first argument. */
784 if (struct_value_incoming_rtx)
786 emit_move_insn (change_address (registers, Pmode,
787 plus_constant (XEXP (registers, 0),
789 copy_to_reg (struct_value_incoming_rtx));
790 size += GET_MODE_SIZE (Pmode);
793 /* Return the address of the block. */
794 return copy_addr_to_reg (XEXP (registers, 0));
797 /* __builtin_apply_args returns block of memory allocated on
798 the stack into which is stored the arg pointer, structure
799 value address, static chain, and all the registers that might
800 possibly be used in performing a function call. The code is
801 moved to the start of the function so the incoming values are
804 expand_builtin_apply_args ()
806 /* Don't do __builtin_apply_args more than once in a function.
807 Save the result of the first call and reuse it. */
808 if (apply_args_value != 0)
809 return apply_args_value;
811 /* When this function is called, it means that registers must be
812 saved on entry to this function. So we migrate the
813 call to the first insn of this function. */
818 temp = expand_builtin_apply_args_1 ();
822 apply_args_value = temp;
824 /* Put the sequence after the NOTE that starts the function.
825 If this is inside a SEQUENCE, make the outer-level insn
826 chain current, so the code is placed at the start of the
828 push_topmost_sequence ();
829 emit_insns_before (seq, NEXT_INSN (get_insns ()));
830 pop_topmost_sequence ();
835 /* Perform an untyped call and save the state required to perform an
836 untyped return of whatever value was returned by the given function. */
839 expand_builtin_apply (function, arguments, argsize)
840 rtx function, arguments, argsize;
842 int size, align, regno;
843 enum machine_mode mode;
844 rtx incoming_args, result, reg, dest, call_insn;
845 rtx old_stack_level = 0;
848 /* Create a block where the return registers can be saved. */
849 result = assign_stack_local (BLKmode, apply_result_size (), -1);
851 /* ??? The argsize value should be adjusted here. */
853 /* Fetch the arg pointer from the ARGUMENTS block. */
854 incoming_args = gen_reg_rtx (Pmode);
855 emit_move_insn (incoming_args,
856 gen_rtx_MEM (Pmode, arguments));
857 #ifndef STACK_GROWS_DOWNWARD
858 incoming_args = expand_binop (Pmode, sub_optab, incoming_args, argsize,
859 incoming_args, 0, OPTAB_LIB_WIDEN);
862 /* Perform postincrements before actually calling the function. */
865 /* Push a new argument block and copy the arguments. */
866 do_pending_stack_adjust ();
868 /* Save the stack with nonlocal if available */
869 #ifdef HAVE_save_stack_nonlocal
870 if (HAVE_save_stack_nonlocal)
871 emit_stack_save (SAVE_NONLOCAL, &old_stack_level, NULL_RTX);
874 emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
876 /* Push a block of memory onto the stack to store the memory arguments.
877 Save the address in a register, and copy the memory arguments. ??? I
878 haven't figured out how the calling convention macros effect this,
879 but it's likely that the source and/or destination addresses in
880 the block copy will need updating in machine specific ways. */
881 dest = allocate_dynamic_stack_space (argsize, 0, 0);
882 emit_block_move (gen_rtx_MEM (BLKmode, dest),
883 gen_rtx_MEM (BLKmode, incoming_args),
885 PARM_BOUNDARY / BITS_PER_UNIT);
887 /* Refer to the argument block. */
889 arguments = gen_rtx_MEM (BLKmode, arguments);
891 /* Walk past the arg-pointer and structure value address. */
892 size = GET_MODE_SIZE (Pmode);
893 if (struct_value_rtx)
894 size += GET_MODE_SIZE (Pmode);
896 /* Restore each of the registers previously saved. Make USE insns
897 for each of these registers for use in making the call. */
898 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
899 if ((mode = apply_args_mode[regno]) != VOIDmode)
901 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
902 if (size % align != 0)
903 size = CEIL (size, align) * align;
904 reg = gen_rtx_REG (mode, regno);
906 change_address (arguments, mode,
907 plus_constant (XEXP (arguments, 0),
910 use_reg (&call_fusage, reg);
911 size += GET_MODE_SIZE (mode);
914 /* Restore the structure value address unless this is passed as an
915 "invisible" first argument. */
916 size = GET_MODE_SIZE (Pmode);
917 if (struct_value_rtx)
919 rtx value = gen_reg_rtx (Pmode);
920 emit_move_insn (value,
921 change_address (arguments, Pmode,
922 plus_constant (XEXP (arguments, 0),
924 emit_move_insn (struct_value_rtx, value);
925 if (GET_CODE (struct_value_rtx) == REG)
926 use_reg (&call_fusage, struct_value_rtx);
927 size += GET_MODE_SIZE (Pmode);
930 /* All arguments and registers used for the call are set up by now! */
931 function = prepare_call_address (function, NULL_TREE, &call_fusage, 0);
933 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
934 and we don't want to load it into a register as an optimization,
935 because prepare_call_address already did it if it should be done. */
936 if (GET_CODE (function) != SYMBOL_REF)
937 function = memory_address (FUNCTION_MODE, function);
939 /* Generate the actual call instruction and save the return value. */
940 #ifdef HAVE_untyped_call
941 if (HAVE_untyped_call)
942 emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
943 result, result_vector (1, result)));
946 #ifdef HAVE_call_value
951 /* Locate the unique return register. It is not possible to
952 express a call that sets more than one return register using
953 call_value; use untyped_call for that. In fact, untyped_call
954 only needs to save the return registers in the given block. */
955 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
956 if ((mode = apply_result_mode[regno]) != VOIDmode)
959 abort (); /* HAVE_untyped_call required. */
960 valreg = gen_rtx_REG (mode, regno);
963 emit_call_insn (gen_call_value (valreg,
964 gen_rtx_MEM (FUNCTION_MODE, function),
965 const0_rtx, NULL_RTX, const0_rtx));
967 emit_move_insn (change_address (result, GET_MODE (valreg),
975 /* Find the CALL insn we just emitted. */
976 for (call_insn = get_last_insn ();
977 call_insn && GET_CODE (call_insn) != CALL_INSN;
978 call_insn = PREV_INSN (call_insn))
984 /* Put the register usage information on the CALL. If there is already
985 some usage information, put ours at the end. */
986 if (CALL_INSN_FUNCTION_USAGE (call_insn))
990 for (link = CALL_INSN_FUNCTION_USAGE (call_insn); XEXP (link, 1) != 0;
991 link = XEXP (link, 1))
994 XEXP (link, 1) = call_fusage;
997 CALL_INSN_FUNCTION_USAGE (call_insn) = call_fusage;
999 /* Restore the stack. */
1000 #ifdef HAVE_save_stack_nonlocal
1001 if (HAVE_save_stack_nonlocal)
1002 emit_stack_restore (SAVE_NONLOCAL, old_stack_level, NULL_RTX);
1005 emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1007 /* Return the address of the result block. */
1008 return copy_addr_to_reg (XEXP (result, 0));
1011 /* Perform an untyped return. */
1014 expand_builtin_return (result)
1017 int size, align, regno;
1018 enum machine_mode mode;
1020 rtx call_fusage = 0;
1022 apply_result_size ();
1023 result = gen_rtx_MEM (BLKmode, result);
1025 #ifdef HAVE_untyped_return
1026 if (HAVE_untyped_return)
1028 emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1034 /* Restore the return value and note that each value is used. */
1036 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1037 if ((mode = apply_result_mode[regno]) != VOIDmode)
1039 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1040 if (size % align != 0)
1041 size = CEIL (size, align) * align;
1042 reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1043 emit_move_insn (reg,
1044 change_address (result, mode,
1045 plus_constant (XEXP (result, 0),
1048 push_to_sequence (call_fusage);
1049 emit_insn (gen_rtx_USE (VOIDmode, reg));
1050 call_fusage = get_insns ();
1052 size += GET_MODE_SIZE (mode);
1055 /* Put the USE insns before the return. */
1056 emit_insns (call_fusage);
1058 /* Return whatever values was restored by jumping directly to the end
1060 expand_null_return ();
1063 /* Expand a call to __builtin_classify_type with arguments found in
1066 expand_builtin_classify_type (arglist)
1071 tree type = TREE_TYPE (TREE_VALUE (arglist));
1072 enum tree_code code = TREE_CODE (type);
1073 if (code == VOID_TYPE)
1074 return GEN_INT (void_type_class);
1075 if (code == INTEGER_TYPE)
1076 return GEN_INT (integer_type_class);
1077 if (code == CHAR_TYPE)
1078 return GEN_INT (char_type_class);
1079 if (code == ENUMERAL_TYPE)
1080 return GEN_INT (enumeral_type_class);
1081 if (code == BOOLEAN_TYPE)
1082 return GEN_INT (boolean_type_class);
1083 if (code == POINTER_TYPE)
1084 return GEN_INT (pointer_type_class);
1085 if (code == REFERENCE_TYPE)
1086 return GEN_INT (reference_type_class);
1087 if (code == OFFSET_TYPE)
1088 return GEN_INT (offset_type_class);
1089 if (code == REAL_TYPE)
1090 return GEN_INT (real_type_class);
1091 if (code == COMPLEX_TYPE)
1092 return GEN_INT (complex_type_class);
1093 if (code == FUNCTION_TYPE)
1094 return GEN_INT (function_type_class);
1095 if (code == METHOD_TYPE)
1096 return GEN_INT (method_type_class);
1097 if (code == RECORD_TYPE)
1098 return GEN_INT (record_type_class);
1099 if (code == UNION_TYPE || code == QUAL_UNION_TYPE)
1100 return GEN_INT (union_type_class);
1101 if (code == ARRAY_TYPE)
1103 if (TYPE_STRING_FLAG (type))
1104 return GEN_INT (string_type_class);
1106 return GEN_INT (array_type_class);
1108 if (code == SET_TYPE)
1109 return GEN_INT (set_type_class);
1110 if (code == FILE_TYPE)
1111 return GEN_INT (file_type_class);
1112 if (code == LANG_TYPE)
1113 return GEN_INT (lang_type_class);
1115 return GEN_INT (no_type_class);
1118 /* Expand expression EXP, which is a call to __builtin_constant_p. */
1120 expand_builtin_constant_p (exp)
1123 tree arglist = TREE_OPERAND (exp, 1);
1124 enum machine_mode value_mode = TYPE_MODE (TREE_TYPE (exp));
1130 tree arg = TREE_VALUE (arglist);
1133 /* We return 1 for a numeric type that's known to be a constant
1134 value at compile-time or for an aggregate type that's a
1135 literal constant. */
1138 /* If we know this is a constant, emit the constant of one. */
1139 if (TREE_CODE_CLASS (TREE_CODE (arg)) == 'c'
1140 || (TREE_CODE (arg) == CONSTRUCTOR
1141 && TREE_CONSTANT (arg))
1142 || (TREE_CODE (arg) == ADDR_EXPR
1143 && TREE_CODE (TREE_OPERAND (arg, 0)) == STRING_CST))
1146 /* If we aren't going to be running CSE or this expression
1147 has side effects, show we don't know it to be a constant.
1148 Likewise if it's a pointer or aggregate type since in those
1149 case we only want literals, since those are only optimized
1150 when generating RTL, not later. */
1151 if (TREE_SIDE_EFFECTS (arg) || cse_not_expected
1152 || AGGREGATE_TYPE_P (TREE_TYPE (arg))
1153 || POINTER_TYPE_P (TREE_TYPE (arg)))
1156 /* Otherwise, emit (constant_p_rtx (ARG)) and let CSE get a
1157 chance to see if it can deduce whether ARG is constant. */
1159 tmp = expand_expr (arg, NULL_RTX, VOIDmode, 0);
1160 tmp = gen_rtx_CONSTANT_P_RTX (value_mode, tmp);
1165 /* Expand a call to one of the builtin math functions (sin, cos, or sqrt).
1166 Return 0 if a normal call should be emitted rather than expanding the
1167 function in-line. EXP is the expression that is a call to the builtin
1168 function; if convenient, the result should be placed in TARGET.
1169 SUBTARGET may be used as the target for computing one of EXP's operands. */
1171 expand_builtin_mathfn (exp, target, subtarget)
1173 rtx target, subtarget;
1175 optab builtin_optab;
1177 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
1178 tree arglist = TREE_OPERAND (exp, 1);
1181 /* Arg could be wrong type if user redeclared this fcn wrong. */
1182 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != REAL_TYPE)
1185 /* Stabilize and compute the argument. */
1186 if (TREE_CODE (TREE_VALUE (arglist)) != VAR_DECL
1187 && TREE_CODE (TREE_VALUE (arglist)) != PARM_DECL)
1189 exp = copy_node (exp);
1190 TREE_OPERAND (exp, 1) = arglist;
1191 /* Wrap the computation of the argument in a SAVE_EXPR. That
1192 way, if we need to expand the argument again (as in the
1193 flag_errno_math case below where we cannot directly set
1194 errno), we will not perform side-effects more than once.
1195 Note that here we're mutating the original EXP as well as the
1196 copy; that's the right thing to do in case the original EXP
1197 is expanded later. */
1198 TREE_VALUE (arglist) = save_expr (TREE_VALUE (arglist));
1199 arglist = copy_node (arglist);
1201 op0 = expand_expr (TREE_VALUE (arglist), subtarget, VOIDmode, 0);
1203 /* Make a suitable register to place result in. */
1204 target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
1209 switch (DECL_FUNCTION_CODE (fndecl))
1212 builtin_optab = sin_optab; break;
1214 builtin_optab = cos_optab; break;
1215 case BUILT_IN_FSQRT:
1216 builtin_optab = sqrt_optab; break;
1221 /* Compute into TARGET.
1222 Set TARGET to wherever the result comes back. */
1223 target = expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist))),
1224 builtin_optab, op0, target, 0);
1226 /* If we were unable to expand via the builtin, stop the
1227 sequence (without outputting the insns) and return 0, causing
1228 a call to the library function. */
1235 /* Check the results by default. But if flag_fast_math is turned on,
1236 then assume sqrt will always be called with valid arguments. */
1238 if (flag_errno_math && ! flag_fast_math)
1242 /* Don't define the builtin FP instructions
1243 if your machine is not IEEE. */
1244 if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT)
1247 lab1 = gen_label_rtx ();
1249 /* Test the result; if it is NaN, set errno=EDOM because
1250 the argument was not in the domain. */
1251 emit_cmp_and_jump_insns (target, target, EQ, 0, GET_MODE (target),
1256 #ifdef GEN_ERRNO_RTX
1257 rtx errno_rtx = GEN_ERRNO_RTX;
1260 = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1263 emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1266 /* We can't set errno=EDOM directly; let the library call do it.
1267 Pop the arguments right away in case the call gets deleted. */
1269 expand_call (exp, target, 0);
1276 /* Output the entire sequence. */
1277 insns = get_insns ();
1284 /* Expand expression EXP which is a call to the strlen builtin. Return 0
1285 if we failed the caller should emit a normal call, otherwise
1286 try to get the result in TARGET, if convenient (and in mode MODE if that's
1289 expand_builtin_strlen (exp, target, mode)
1292 enum machine_mode mode;
1294 tree arglist = TREE_OPERAND (exp, 1);
1295 enum machine_mode value_mode = TYPE_MODE (TREE_TYPE (exp));
1298 /* Arg could be non-pointer if user redeclared this fcn wrong. */
1299 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
1303 tree src = TREE_VALUE (arglist);
1304 tree len = c_strlen (src);
1307 = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
1309 rtx result, src_rtx, char_rtx;
1310 enum machine_mode insn_mode = value_mode, char_mode;
1311 enum insn_code icode = CODE_FOR_nothing;
1313 /* If the length is known, just return it. */
1315 return expand_expr (len, target, mode, EXPAND_MEMORY_USE_BAD);
1317 /* If SRC is not a pointer type, don't do this operation inline. */
1321 /* Call a function if we can't compute strlen in the right mode. */
1323 while (insn_mode != VOIDmode)
1325 icode = strlen_optab->handlers[(int) insn_mode].insn_code;
1326 if (icode != CODE_FOR_nothing)
1329 insn_mode = GET_MODE_WIDER_MODE (insn_mode);
1331 if (insn_mode == VOIDmode)
1334 /* Make a place to write the result of the instruction. */
1337 && GET_CODE (result) == REG
1338 && GET_MODE (result) == insn_mode
1339 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
1340 result = gen_reg_rtx (insn_mode);
1342 /* Make sure the operands are acceptable to the predicates. */
1344 if (! (*insn_data[(int)icode].operand[0].predicate) (result, insn_mode))
1345 result = gen_reg_rtx (insn_mode);
1346 src_rtx = memory_address (BLKmode,
1347 expand_expr (src, NULL_RTX, ptr_mode,
1350 if (! (*insn_data[(int)icode].operand[1].predicate) (src_rtx, Pmode))
1351 src_rtx = copy_to_mode_reg (Pmode, src_rtx);
1353 /* Check the string is readable and has an end. */
1354 if (current_function_check_memory_usage)
1355 emit_library_call (chkr_check_str_libfunc, 1, VOIDmode, 2,
1357 GEN_INT (MEMORY_USE_RO),
1358 TYPE_MODE (integer_type_node));
1360 char_rtx = const0_rtx;
1361 char_mode = insn_data[(int)icode].operand[2].mode;
1362 if (! (*insn_data[(int)icode].operand[2].predicate) (char_rtx, char_mode))
1363 char_rtx = copy_to_mode_reg (char_mode, char_rtx);
1365 emit_insn (GEN_FCN (icode) (result,
1366 gen_rtx_MEM (BLKmode, src_rtx),
1367 char_rtx, GEN_INT (align)));
1369 /* Return the value in the proper mode for this function. */
1370 if (GET_MODE (result) == value_mode)
1372 else if (target != 0)
1374 convert_move (target, result, 0);
1378 return convert_to_mode (value_mode, result, 0);
1382 /* Expand a call to the memcpy builtin, with arguments in ARGLIST. */
1384 expand_builtin_memcpy (arglist)
1388 /* Arg could be non-pointer if user redeclared this fcn wrong. */
1389 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
1390 || TREE_CHAIN (arglist) == 0
1391 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist))))
1393 || TREE_CHAIN (TREE_CHAIN (arglist)) == 0
1394 || (TREE_CODE (TREE_TYPE (TREE_VALUE
1395 (TREE_CHAIN (TREE_CHAIN (arglist)))))
1400 tree dest = TREE_VALUE (arglist);
1401 tree src = TREE_VALUE (TREE_CHAIN (arglist));
1402 tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
1405 = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
1407 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
1408 rtx dest_mem, src_mem, dest_addr, len_rtx;
1410 /* If either SRC or DEST is not a pointer type, don't do
1411 this operation in-line. */
1412 if (src_align == 0 || dest_align == 0)
1415 dest_mem = get_memory_rtx (dest);
1416 src_mem = get_memory_rtx (src);
1417 len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
1419 /* Just copy the rights of SRC to the rights of DEST. */
1420 if (current_function_check_memory_usage)
1421 emit_library_call (chkr_copy_bitmap_libfunc, 1, VOIDmode, 3,
1422 XEXP (dest_mem, 0), Pmode,
1423 XEXP (src_mem, 0), Pmode,
1424 len_rtx, TYPE_MODE (sizetype));
1426 /* Copy word part most expediently. */
1428 = emit_block_move (dest_mem, src_mem, len_rtx,
1429 MIN (src_align, dest_align));
1432 dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
1438 /* Expand expression EXP, which is a call to the strcpy builtin. Return 0
1439 if we failed the caller should emit a normal call. */
1441 expand_builtin_strcpy (exp)
1444 tree arglist = TREE_OPERAND (exp, 1);
1448 /* Arg could be non-pointer if user redeclared this fcn wrong. */
1449 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
1450 || TREE_CHAIN (arglist) == 0
1451 || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) != POINTER_TYPE)
1455 tree len = c_strlen (TREE_VALUE (TREE_CHAIN (arglist)));
1460 len = size_binop (PLUS_EXPR, len, integer_one_node);
1462 chainon (arglist, build_tree_list (NULL_TREE, len));
1464 result = expand_builtin_memcpy (arglist);
1466 TREE_CHAIN (TREE_CHAIN (arglist)) = 0;
1470 /* Expand expression EXP, which is a call to the memset builtin. Return 0
1471 if we failed the caller should emit a normal call. */
1473 expand_builtin_memset (exp)
1476 tree arglist = TREE_OPERAND (exp, 1);
1479 /* Arg could be non-pointer if user redeclared this fcn wrong. */
1480 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
1481 || TREE_CHAIN (arglist) == 0
1482 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist))))
1484 || TREE_CHAIN (TREE_CHAIN (arglist)) == 0
1486 != (TREE_CODE (TREE_TYPE
1488 (TREE_CHAIN (TREE_CHAIN (arglist))))))))
1492 tree dest = TREE_VALUE (arglist);
1493 tree val = TREE_VALUE (TREE_CHAIN (arglist));
1494 tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
1497 = get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
1498 rtx dest_mem, dest_addr, len_rtx;
1500 /* If DEST is not a pointer type, don't do this
1501 operation in-line. */
1502 if (dest_align == 0)
1505 /* If the arguments have side-effects, then we can only evaluate
1506 them at most once. The following code evaluates them twice if
1507 they are not constants because we break out to expand_call
1508 in that case. They can't be constants if they have side-effects
1509 so we can check for that first. Alternatively, we could call
1510 save_expr to make multiple evaluation safe. */
1511 if (TREE_SIDE_EFFECTS (val) || TREE_SIDE_EFFECTS (len))
1514 /* If VAL is not 0, don't do this operation in-line. */
1515 if (expand_expr (val, NULL_RTX, VOIDmode, 0) != const0_rtx)
1518 len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
1520 dest_mem = get_memory_rtx (dest);
1522 /* Just check DST is writable and mark it as readable. */
1523 if (current_function_check_memory_usage)
1524 emit_library_call (chkr_check_addr_libfunc, 1, VOIDmode, 3,
1525 XEXP (dest_mem, 0), Pmode,
1526 len_rtx, TYPE_MODE (sizetype),
1527 GEN_INT (MEMORY_USE_WO),
1528 TYPE_MODE (integer_type_node));
1531 dest_addr = clear_storage (dest_mem, len_rtx, dest_align);
1534 dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
1540 #ifdef HAVE_cmpstrsi
1541 /* Expand expression EXP, which is a call to the memcmp or the strcmp builtin.
1542 ARGLIST is the argument list for this call. Return 0 if we failed and the
1543 caller should emit a normal call, otherwise try to get the result in
1544 TARGET, if convenient. */
1546 expand_builtin_memcmp (exp, arglist, target)
1551 /* If we need to check memory accesses, call the library function. */
1552 if (current_function_check_memory_usage)
1556 /* Arg could be non-pointer if user redeclared this fcn wrong. */
1557 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
1558 || TREE_CHAIN (arglist) == 0
1559 || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) != POINTER_TYPE
1560 || TREE_CHAIN (TREE_CHAIN (arglist)) == 0
1561 || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))))) != INTEGER_TYPE)
1563 else if (!HAVE_cmpstrsi)
1567 enum machine_mode mode;
1568 tree arg1 = TREE_VALUE (arglist);
1569 tree arg2 = TREE_VALUE (TREE_CHAIN (arglist));
1570 tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
1574 = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
1576 = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
1577 enum machine_mode insn_mode
1578 = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
1580 /* If we don't have POINTER_TYPE, call the function. */
1581 if (arg1_align == 0 || arg2_align == 0)
1584 /* Make a place to write the result of the instruction. */
1587 && GET_CODE (result) == REG && GET_MODE (result) == insn_mode
1588 && REGNO (result) >= FIRST_PSEUDO_REGISTER))
1589 result = gen_reg_rtx (insn_mode);
1591 emit_insn (gen_cmpstrsi (result, get_memory_rtx (arg1),
1592 get_memory_rtx (arg2),
1593 expand_expr (len, NULL_RTX, VOIDmode, 0),
1594 GEN_INT (MIN (arg1_align, arg2_align))));
1596 /* Return the value in the proper mode for this function. */
1597 mode = TYPE_MODE (TREE_TYPE (exp));
1598 if (GET_MODE (result) == mode)
1600 else if (target != 0)
1602 convert_move (target, result, 0);
1606 return convert_to_mode (mode, result, 0);
1610 /* Expand expression EXP, which is a call to the strcmp builtin. Return 0
1611 if we failed the caller should emit a normal call, otherwise try to get
1612 the result in TARGET, if convenient. */
1614 expand_builtin_strcmp (exp, target)
1618 tree arglist = TREE_OPERAND (exp, 1);
1620 /* If we need to check memory accesses, call the library function. */
1621 if (current_function_check_memory_usage)
1625 /* Arg could be non-pointer if user redeclared this fcn wrong. */
1626 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
1627 || TREE_CHAIN (arglist) == 0
1628 || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) != POINTER_TYPE)
1630 else if (!HAVE_cmpstrsi)
1633 tree arg1 = TREE_VALUE (arglist);
1634 tree arg2 = TREE_VALUE (TREE_CHAIN (arglist));
1637 len = c_strlen (arg1);
1639 len = size_binop (PLUS_EXPR, integer_one_node, len);
1640 len2 = c_strlen (arg2);
1642 len2 = size_binop (PLUS_EXPR, integer_one_node, len2);
1644 /* If we don't have a constant length for the first, use the length
1645 of the second, if we know it. We don't require a constant for
1646 this case; some cost analysis could be done if both are available
1647 but neither is constant. For now, assume they're equally cheap.
1649 If both strings have constant lengths, use the smaller. This
1650 could arise if optimization results in strcpy being called with
1651 two fixed strings, or if the code was machine-generated. We should
1652 add some code to the `memcmp' handler below to deal with such
1653 situations, someday. */
1654 if (!len || TREE_CODE (len) != INTEGER_CST)
1661 else if (len2 && TREE_CODE (len2) == INTEGER_CST)
1663 if (tree_int_cst_lt (len2, len))
1667 chainon (arglist, build_tree_list (NULL_TREE, len));
1668 result = expand_builtin_memcmp (exp, arglist, target);
1670 TREE_CHAIN (TREE_CHAIN (arglist)) = 0;
1676 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
1677 if that's convenient. */
1679 expand_builtin_saveregs ()
1683 /* Don't do __builtin_saveregs more than once in a function.
1684 Save the result of the first call and reuse it. */
1685 if (saveregs_value != 0)
1686 return saveregs_value;
1688 /* When this function is called, it means that registers must be
1689 saved on entry to this function. So we migrate the call to the
1690 first insn of this function. */
1694 #ifdef EXPAND_BUILTIN_SAVEREGS
1695 /* Do whatever the machine needs done in this case. */
1696 val = EXPAND_BUILTIN_SAVEREGS ();
1698 /* ??? We used to try and build up a call to the out of line function,
1699 guessing about what registers needed saving etc. This became much
1700 harder with __builtin_va_start, since we don't have a tree for a
1701 call to __builtin_saveregs to fall back on. There was exactly one
1702 port (i860) that used this code, and I'm unconvinced it could actually
1703 handle the general case. So we no longer try to handle anything
1704 weird and make the backend absorb the evil. */
1706 error ("__builtin_saveregs not supported by this target");
1713 saveregs_value = val;
1715 /* Put the sequence after the NOTE that starts the function. If this
1716 is inside a SEQUENCE, make the outer-level insn chain current, so
1717 the code is placed at the start of the function. */
1718 push_topmost_sequence ();
1719 emit_insns_after (seq, get_insns ());
1720 pop_topmost_sequence ();
1725 /* __builtin_args_info (N) returns word N of the arg space info
1726 for the current function. The number and meanings of words
1727 is controlled by the definition of CUMULATIVE_ARGS. */
1729 expand_builtin_args_info (exp)
1732 tree arglist = TREE_OPERAND (exp, 1);
1733 int nwords = sizeof (CUMULATIVE_ARGS) / sizeof (int);
1734 int *word_ptr = (int *) ¤t_function_args_info;
1736 /* These are used by the code below that is if 0'ed away */
1738 tree type, elts, result;
1741 if (sizeof (CUMULATIVE_ARGS) % sizeof (int) != 0)
1746 tree arg = TREE_VALUE (arglist);
1747 if (TREE_CODE (arg) != INTEGER_CST)
1748 error ("argument of `__builtin_args_info' must be constant");
1751 int wordnum = TREE_INT_CST_LOW (arg);
1753 if (wordnum < 0 || wordnum >= nwords || TREE_INT_CST_HIGH (arg))
1754 error ("argument of `__builtin_args_info' out of range");
1756 return GEN_INT (word_ptr[wordnum]);
1760 error ("missing argument in `__builtin_args_info'");
1765 for (i = 0; i < nwords; i++)
1766 elts = tree_cons (NULL_TREE, build_int_2 (word_ptr[i], 0));
1768 type = build_array_type (integer_type_node,
1769 build_index_type (build_int_2 (nwords, 0)));
1770 result = build (CONSTRUCTOR, type, NULL_TREE, nreverse (elts));
1771 TREE_CONSTANT (result) = 1;
1772 TREE_STATIC (result) = 1;
1773 result = build1 (INDIRECT_REF, build_pointer_type (type), result);
1774 TREE_CONSTANT (result) = 1;
1775 return expand_expr (result, NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_BAD);
1779 /* Expand ARGLIST, from a call to __builtin_next_arg. */
1781 expand_builtin_next_arg (arglist)
1784 tree fntype = TREE_TYPE (current_function_decl);
1786 if ((TYPE_ARG_TYPES (fntype) == 0
1787 || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
1789 && ! current_function_varargs)
1791 error ("`va_start' used in function with fixed args");
1797 tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
1798 tree arg = TREE_VALUE (arglist);
1800 /* Strip off all nops for the sake of the comparison. This
1801 is not quite the same as STRIP_NOPS. It does more.
1802 We must also strip off INDIRECT_EXPR for C++ reference
1804 while (TREE_CODE (arg) == NOP_EXPR
1805 || TREE_CODE (arg) == CONVERT_EXPR
1806 || TREE_CODE (arg) == NON_LVALUE_EXPR
1807 || TREE_CODE (arg) == INDIRECT_REF)
1808 arg = TREE_OPERAND (arg, 0);
1809 if (arg != last_parm)
1810 warning ("second parameter of `va_start' not last named argument");
1812 else if (! current_function_varargs)
1813 /* Evidently an out of date version of <stdarg.h>; can't validate
1814 va_start's second argument, but can still work as intended. */
1815 warning ("`__builtin_next_arg' called without an argument");
1817 return expand_binop (Pmode, add_optab,
1818 current_function_internal_arg_pointer,
1819 current_function_arg_offset_rtx,
1820 NULL_RTX, 0, OPTAB_LIB_WIDEN);
1823 /* Make it easier for the backends by protecting the valist argument
1824 from multiple evaluations. */
1827 stabilize_va_list (valist, was_ptr)
1831 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
1833 /* If stdarg.h took the address of an array-type valist that was passed
1834 as a parameter, we'll have taken the address of the parameter itself
1835 rather than the array as we'd intended. Undo this mistake. */
1839 STRIP_NOPS (valist);
1841 /* Two cases: either &array, which decomposed to
1842 <ptr <array <record> valist>>
1843 or &ptr, which turned into
1844 <ptr <ptr <record>>>
1845 In the first case we'll need to put the ADDR_EXPR back
1846 after frobbing the types as if &array[0]. */
1848 if (TREE_CODE (valist) != ADDR_EXPR)
1850 valist = TREE_OPERAND (valist, 0);
1853 if (TYPE_MAIN_VARIANT (TREE_TYPE (valist))
1854 == TYPE_MAIN_VARIANT (va_list_type_node))
1856 tree pt = build_pointer_type (TREE_TYPE (va_list_type_node));
1857 valist = build1 (ADDR_EXPR, pt, valist);
1858 TREE_SIDE_EFFECTS (valist)
1859 = TREE_SIDE_EFFECTS (TREE_OPERAND (valist, 0));
1863 if (! POINTER_TYPE_P (TREE_TYPE (valist))
1864 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (valist)))
1865 != TYPE_MAIN_VARIANT (TREE_TYPE (va_list_type_node))))
1869 if (TREE_SIDE_EFFECTS (valist))
1870 valist = save_expr (valist);
1878 if (! TREE_SIDE_EFFECTS (valist))
1881 pt = build_pointer_type (va_list_type_node);
1882 valist = fold (build1 (ADDR_EXPR, pt, valist));
1883 TREE_SIDE_EFFECTS (valist) = 1;
1885 if (TREE_SIDE_EFFECTS (valist))
1886 valist = save_expr (valist);
1887 valist = fold (build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (valist)),
1894 /* The "standard" implementation of va_start: just assign `nextarg' to
1897 std_expand_builtin_va_start (stdarg_p, valist, nextarg)
1898 int stdarg_p ATTRIBUTE_UNUSED;
1905 nextarg = plus_constant (nextarg, -UNITS_PER_WORD);
1907 t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
1908 make_tree (ptr_type_node, nextarg));
1909 TREE_SIDE_EFFECTS (t) = 1;
1911 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
1914 /* Expand ARGLIST, which from a call to __builtin_stdarg_va_start or
1915 __builtin_varargs_va_start, depending on STDARG_P. */
1917 expand_builtin_va_start (stdarg_p, arglist)
1922 tree chain = arglist, valist;
1925 nextarg = expand_builtin_next_arg (chain = TREE_CHAIN (arglist));
1927 nextarg = expand_builtin_next_arg (NULL_TREE);
1929 if (TREE_CHAIN (chain))
1930 error ("too many arguments to function `va_start'");
1932 valist = stabilize_va_list (TREE_VALUE (arglist), 1);
1934 #ifdef EXPAND_BUILTIN_VA_START
1935 EXPAND_BUILTIN_VA_START (stdarg_p, valist, nextarg);
1937 std_expand_builtin_va_start (stdarg_p, valist, nextarg);
1943 /* Allocate an alias set for use in storing and reading from the varargs
1946 get_varargs_alias_set ()
1948 static int set = -1;
1950 set = new_alias_set ();
1954 /* The "standard" implementation of va_arg: read the value from the
1955 current (padded) address and increment by the (padded) size. */
1957 std_expand_builtin_va_arg (valist, type)
1961 HOST_WIDE_INT align;
1962 HOST_WIDE_INT rounded_size;
1965 /* Compute the rounded size of the type. */
1966 align = PARM_BOUNDARY / BITS_PER_UNIT;
1967 rounded_size = (((int_size_in_bytes (type) + align - 1) / align) * align);
1971 if (PAD_VARARGS_DOWN)
1973 /* Small args are padded downward. */
1976 adj = TREE_INT_CST_LOW (TYPE_SIZE (type)) / BITS_PER_UNIT;
1977 if (rounded_size > align)
1980 addr_tree = build (PLUS_EXPR, TREE_TYPE (addr_tree), addr_tree,
1981 build_int_2 (rounded_size - adj, 0));
1984 addr = expand_expr (addr_tree, NULL_RTX, Pmode, EXPAND_NORMAL);
1985 addr = copy_to_reg (addr);
1987 /* Compute new value for AP. */
1988 t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
1989 build (PLUS_EXPR, TREE_TYPE (valist), valist,
1990 build_int_2 (rounded_size, 0)));
1991 TREE_SIDE_EFFECTS (t) = 1;
1992 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
1997 /* Expand __builtin_va_arg, which is not really a builtin function, but
1998 a very special sort of operator. */
2000 expand_builtin_va_arg (valist, type)
2004 tree promoted_type, want_va_type, have_va_type;
2006 /* Verify that valist is of the proper type. */
2008 want_va_type = va_list_type_node;
2009 have_va_type = TREE_TYPE (valist);
2010 if (TREE_CODE (want_va_type) == ARRAY_TYPE)
2012 /* If va_list is an array type, the argument may have decayed
2013 to a pointer type, e.g. by being passed to another function.
2014 In that case, unwrap both types so that we can compare the
2015 underlying records. */
2016 if (TREE_CODE (have_va_type) == ARRAY_TYPE
2017 || TREE_CODE (have_va_type) == POINTER_TYPE)
2019 want_va_type = TREE_TYPE (want_va_type);
2020 have_va_type = TREE_TYPE (have_va_type);
2023 if (TYPE_MAIN_VARIANT (want_va_type) != TYPE_MAIN_VARIANT (have_va_type))
2025 error ("first argument to `va_arg' not of type `va_list'");
2029 /* Generate a diagnostic for requesting data of a type that cannot
2030 be passed through `...' due to type promotion at the call site. */
2031 else if ((promoted_type = (*lang_type_promotes_to) (type)) != NULL_TREE)
2033 const char *name = "<anonymous type>", *pname = 0;
2034 static int gave_help;
2036 if (TYPE_NAME (type))
2038 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
2039 name = IDENTIFIER_POINTER (TYPE_NAME (type));
2040 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
2041 && DECL_NAME (TYPE_NAME (type)))
2042 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
2044 if (TYPE_NAME (promoted_type))
2046 if (TREE_CODE (TYPE_NAME (promoted_type)) == IDENTIFIER_NODE)
2047 pname = IDENTIFIER_POINTER (TYPE_NAME (promoted_type));
2048 else if (TREE_CODE (TYPE_NAME (promoted_type)) == TYPE_DECL
2049 && DECL_NAME (TYPE_NAME (promoted_type)))
2050 pname = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (promoted_type)));
2053 error ("`%s' is promoted to `%s' when passed through `...'", name, pname);
2057 error ("(so you should pass `%s' not `%s' to `va_arg')", pname, name);
2064 /* Make it easier for the backends by protecting the valist argument
2065 from multiple evaluations. */
2066 valist = stabilize_va_list (valist, 0);
2068 #ifdef EXPAND_BUILTIN_VA_ARG
2069 addr = EXPAND_BUILTIN_VA_ARG (valist, type);
2071 addr = std_expand_builtin_va_arg (valist, type);
2075 result = gen_rtx_MEM (TYPE_MODE (type), addr);
2076 MEM_ALIAS_SET (result) = get_varargs_alias_set ();
2081 /* Expand ARGLIST, from a call to __builtin_va_end. */
2083 expand_builtin_va_end (arglist)
2086 tree valist = TREE_VALUE (arglist);
2088 #ifdef EXPAND_BUILTIN_VA_END
2089 valist = stabilize_va_list (valist, 0);
2090 EXPAND_BUILTIN_VA_END(arglist);
2092 /* Evaluate for side effects, if needed. I hate macros that don't
2094 if (TREE_SIDE_EFFECTS (valist))
2095 expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
2101 /* Expand ARGLIST, from a call to __builtin_va_copy. We do this as a
2102 builtin rather than just as an assignment in stdarg.h because of the
2103 nastiness of array-type va_list types. */
2105 expand_builtin_va_copy (arglist)
2110 dst = TREE_VALUE (arglist);
2111 src = TREE_VALUE (TREE_CHAIN (arglist));
2113 dst = stabilize_va_list (dst, 1);
2114 src = stabilize_va_list (src, 0);
2116 if (TREE_CODE (va_list_type_node) != ARRAY_TYPE)
2118 t = build (MODIFY_EXPR, va_list_type_node, dst, src);
2119 TREE_SIDE_EFFECTS (t) = 1;
2120 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
2124 rtx dstb, srcb, size;
2126 /* Evaluate to pointers. */
2127 dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
2128 srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
2129 size = expand_expr (TYPE_SIZE_UNIT (va_list_type_node), NULL_RTX,
2130 VOIDmode, EXPAND_NORMAL);
2132 /* "Dereference" to BLKmode memories. */
2133 dstb = gen_rtx_MEM (BLKmode, dstb);
2134 MEM_ALIAS_SET (dstb) = get_alias_set (TREE_TYPE (TREE_TYPE (dst)));
2135 srcb = gen_rtx_MEM (BLKmode, srcb);
2136 MEM_ALIAS_SET (srcb) = get_alias_set (TREE_TYPE (TREE_TYPE (src)));
2139 emit_block_move (dstb, srcb, size,
2140 TYPE_ALIGN (va_list_type_node) / BITS_PER_UNIT);
2146 /* Expand a call to one of the builtin functions __builtin_frame_address or
2147 __builtin_return_address. */
2149 expand_builtin_frame_address (exp)
2152 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
2153 tree arglist = TREE_OPERAND (exp, 1);
2155 /* The argument must be a nonnegative integer constant.
2156 It counts the number of frames to scan up the stack.
2157 The value is the return address saved in that frame. */
2159 /* Warning about missing arg was already issued. */
2161 else if (TREE_CODE (TREE_VALUE (arglist)) != INTEGER_CST
2162 || tree_int_cst_sgn (TREE_VALUE (arglist)) < 0)
2164 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
2165 error ("invalid arg to `__builtin_frame_address'");
2167 error ("invalid arg to `__builtin_return_address'");
2172 rtx tem = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
2173 TREE_INT_CST_LOW (TREE_VALUE (arglist)),
2174 hard_frame_pointer_rtx);
2176 /* Some ports cannot access arbitrary stack frames. */
2179 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
2180 warning ("unsupported arg to `__builtin_frame_address'");
2182 warning ("unsupported arg to `__builtin_return_address'");
2186 /* For __builtin_frame_address, return what we've got. */
2187 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
2190 if (GET_CODE (tem) != REG
2191 && ! CONSTANT_P (tem))
2192 tem = copy_to_mode_reg (Pmode, tem);
2197 /* Expand a call to the alloca builtin, with arguments ARGLIST. Return 0 if
2198 we failed and the caller should emit a normal call, otherwise try to get
2199 the result in TARGET, if convenient. */
2201 expand_builtin_alloca (arglist, target)
2208 /* Arg could be non-integer if user redeclared this fcn wrong. */
2209 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE)
2212 /* Compute the argument. */
2213 op0 = expand_expr (TREE_VALUE (arglist), NULL_RTX, VOIDmode, 0);
2215 /* Allocate the desired space. */
2216 return allocate_dynamic_stack_space (op0, target, BITS_PER_UNIT);
2219 /* Expand a call to the ffs builtin. The arguments are in ARGLIST.
2220 Return 0 if a normal call should be emitted rather than expanding the
2221 function in-line. If convenient, the result should be placed in TARGET.
2222 SUBTARGET may be used as the target for computing one of EXP's operands. */
2224 expand_builtin_ffs (arglist, target, subtarget)
2226 rtx target, subtarget;
2230 /* Arg could be non-integer if user redeclared this fcn wrong. */
2231 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE)
2234 /* Compute the argument. */
2235 op0 = expand_expr (TREE_VALUE (arglist), subtarget, VOIDmode, 0);
2236 /* Compute ffs, into TARGET if possible.
2237 Set TARGET to wherever the result comes back. */
2238 target = expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist))),
2239 ffs_optab, op0, target, 1);
2245 /* Expand an expression EXP that calls a built-in function,
2246 with result going to TARGET if that's convenient
2247 (and in mode MODE if that's convenient).
2248 SUBTARGET may be used as the target for computing one of EXP's operands.
2249 IGNORE is nonzero if the value is to be ignored. */
2252 expand_builtin (exp, target, subtarget, mode, ignore)
2256 enum machine_mode mode;
2259 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
2260 tree arglist = TREE_OPERAND (exp, 1);
2261 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
2263 #ifdef MD_EXPAND_BUILTIN
2264 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
2265 return MD_EXPAND_BUILTIN (exp, target, subtarget, mode, ignore);
2268 /* When not optimizing, generate calls to library functions for a certain
2270 if (! optimize && ! CALLED_AS_BUILT_IN (fndecl)
2271 && (fcode == BUILT_IN_SIN || fcode == BUILT_IN_COS
2272 || fcode == BUILT_IN_FSQRT || fcode == BUILT_IN_MEMSET
2273 || fcode == BUILT_IN_MEMCPY || fcode == BUILT_IN_MEMCMP
2274 || fcode == BUILT_IN_STRLEN || fcode == BUILT_IN_STRCPY
2275 || fcode == BUILT_IN_STRCMP || fcode == BUILT_IN_FFS))
2276 return expand_call (exp, target, ignore);
2283 /* build_function_call changes these into ABS_EXPR. */
2288 /* Treat these like sqrt, but only if the user asks for them. */
2289 if (! flag_fast_math)
2291 case BUILT_IN_FSQRT:
2292 target = expand_builtin_mathfn (exp, target, subtarget);
2300 case BUILT_IN_APPLY_ARGS:
2301 return expand_builtin_apply_args ();
2303 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
2304 FUNCTION with a copy of the parameters described by
2305 ARGUMENTS, and ARGSIZE. It returns a block of memory
2306 allocated on the stack into which is stored all the registers
2307 that might possibly be used for returning the result of a
2308 function. ARGUMENTS is the value returned by
2309 __builtin_apply_args. ARGSIZE is the number of bytes of
2310 arguments that must be copied. ??? How should this value be
2311 computed? We'll also need a safe worst case value for varargs
2313 case BUILT_IN_APPLY:
2315 /* Arg could be non-pointer if user redeclared this fcn wrong. */
2316 || ! POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (arglist)))
2317 || TREE_CHAIN (arglist) == 0
2318 || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) != POINTER_TYPE
2319 || TREE_CHAIN (TREE_CHAIN (arglist)) == 0
2320 || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))))) != INTEGER_TYPE)
2328 for (t = arglist, i = 0; t; t = TREE_CHAIN (t), i++)
2329 ops[i] = expand_expr (TREE_VALUE (t), NULL_RTX, VOIDmode, 0);
2331 return expand_builtin_apply (ops[0], ops[1], ops[2]);
2334 /* __builtin_return (RESULT) causes the function to return the
2335 value described by RESULT. RESULT is address of the block of
2336 memory returned by __builtin_apply. */
2337 case BUILT_IN_RETURN:
2339 /* Arg could be non-pointer if user redeclared this fcn wrong. */
2340 && TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) == POINTER_TYPE)
2341 expand_builtin_return (expand_expr (TREE_VALUE (arglist),
2342 NULL_RTX, VOIDmode, 0));
2345 case BUILT_IN_SAVEREGS:
2346 return expand_builtin_saveregs ();
2348 case BUILT_IN_ARGS_INFO:
2349 return expand_builtin_args_info (exp);
2351 /* Return the address of the first anonymous stack arg. */
2352 case BUILT_IN_NEXT_ARG:
2353 return expand_builtin_next_arg (arglist);
2355 case BUILT_IN_CLASSIFY_TYPE:
2356 return expand_builtin_classify_type (arglist);
2358 case BUILT_IN_CONSTANT_P:
2359 return expand_builtin_constant_p (exp);
2361 case BUILT_IN_FRAME_ADDRESS:
2362 case BUILT_IN_RETURN_ADDRESS:
2363 return expand_builtin_frame_address (exp);
2365 /* Returns the address of the area where the structure is returned.
2367 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
2369 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
2370 || GET_CODE (DECL_RTL (DECL_RESULT (current_function_decl))) != MEM)
2373 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
2375 case BUILT_IN_ALLOCA:
2376 target = expand_builtin_alloca (arglist, target);
2382 target = expand_builtin_ffs (arglist, target, subtarget);
2387 case BUILT_IN_STRLEN:
2388 target = expand_builtin_strlen (exp, target, mode);
2393 case BUILT_IN_STRCPY:
2394 target = expand_builtin_strcpy (exp);
2399 case BUILT_IN_MEMCPY:
2400 target = expand_builtin_memcpy (arglist);
2405 case BUILT_IN_MEMSET:
2406 target = expand_builtin_memset (exp);
2411 /* These comparison functions need an instruction that returns an actual
2412 index. An ordinary compare that just sets the condition codes
2414 #ifdef HAVE_cmpstrsi
2415 case BUILT_IN_STRCMP:
2416 target = expand_builtin_strcmp (exp, target);
2421 case BUILT_IN_MEMCMP:
2422 target = expand_builtin_memcmp (exp, arglist, target);
2427 case BUILT_IN_STRCMP:
2428 case BUILT_IN_MEMCMP:
2432 case BUILT_IN_SETJMP:
2434 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
2438 rtx buf_addr = expand_expr (TREE_VALUE (arglist), subtarget,
2440 rtx lab = gen_label_rtx ();
2441 rtx ret = expand_builtin_setjmp (buf_addr, target, lab, lab);
2446 /* __builtin_longjmp is passed a pointer to an array of five words.
2447 It's similar to the C library longjmp function but works with
2448 __builtin_setjmp above. */
2449 case BUILT_IN_LONGJMP:
2450 if (arglist == 0 || TREE_CHAIN (arglist) == 0
2451 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
2455 rtx buf_addr = expand_expr (TREE_VALUE (arglist), subtarget,
2457 rtx value = expand_expr (TREE_VALUE (TREE_CHAIN (arglist)),
2458 NULL_RTX, VOIDmode, 0);
2460 if (value != const1_rtx)
2462 error ("__builtin_longjmp second argument must be 1");
2466 expand_builtin_longjmp (buf_addr, value);
2473 emit_insn (gen_trap ());
2476 error ("__builtin_trap not supported by this target");
2480 /* Various hooks for the DWARF 2 __throw routine. */
2481 case BUILT_IN_UNWIND_INIT:
2482 expand_builtin_unwind_init ();
2484 case BUILT_IN_DWARF_CFA:
2485 return virtual_cfa_rtx;
2486 #ifdef DWARF2_UNWIND_INFO
2487 case BUILT_IN_DWARF_FP_REGNUM:
2488 return expand_builtin_dwarf_fp_regnum ();
2489 case BUILT_IN_INIT_DWARF_REG_SIZES:
2490 expand_builtin_init_dwarf_reg_sizes (TREE_VALUE (arglist));
2493 case BUILT_IN_FROB_RETURN_ADDR:
2494 return expand_builtin_frob_return_addr (TREE_VALUE (arglist));
2495 case BUILT_IN_EXTRACT_RETURN_ADDR:
2496 return expand_builtin_extract_return_addr (TREE_VALUE (arglist));
2497 case BUILT_IN_EH_RETURN:
2498 expand_builtin_eh_return (TREE_VALUE (arglist),
2499 TREE_VALUE (TREE_CHAIN (arglist)),
2500 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))));
2502 case BUILT_IN_VARARGS_START:
2503 return expand_builtin_va_start (0, arglist);
2504 case BUILT_IN_STDARG_START:
2505 return expand_builtin_va_start (1, arglist);
2506 case BUILT_IN_VA_END:
2507 return expand_builtin_va_end (arglist);
2508 case BUILT_IN_VA_COPY:
2509 return expand_builtin_va_copy (arglist);
2511 default: /* just do library call, if unknown builtin */
2512 error ("built-in function `%s' not currently supported",
2513 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
2516 /* The switch statement above can drop through to cause the function
2517 to be called normally. */
2518 return expand_call (exp, target, ignore);