| blob | 4f6c9c400845961d113a922e84871b44a58f5f71 |
1 /* Expand builtin functions.
2 Copyright (C) 1988-2017 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* Legacy warning! Please add no further builtin simplifications here
21 (apart from pure constant folding) - builtin simplifications should go
22 to match.pd or gimple-fold.c instead. */
73 #if SWITCHABLE_TARGET
75 #endif
77 /* Define the names of the builtin function types and codes. */
81 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
83 {
85 };
87 /* Setup an array of builtin_info_type, make sure each element decl is
88 initialized to NULL_TREE. */
91 /* Non-zero if __builtin_constant_p should be folded right away. */
193 /* Return true if NAME starts with __builtin_ or __sync_. */
195 static bool
197 {
209 }
212 /* Return true if DECL is a function symbol representing a built-in. */
214 bool
216 {
218 }
220 /* Return true if NODE should be considered for inline expansion regardless
221 of the optimization level. This means whenever a function is invoked with
222 its "internal" name, which normally contains the prefix "__builtin". */
224 bool
226 {
227 /* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since
228 we want the name used to call the function, not the name it
229 will have. */
232 }
234 /* Compute values M and N such that M divides (address of EXP - N) and such
235 that N < M. If these numbers can be determined, store M in alignp and N in
236 *BITPOSP and return true. Otherwise return false and store BITS_PER_UNIT to
237 *alignp and any bit-offset to *bitposp.
239 Note that the address (and thus the alignment) computed here is based
240 on the address to which a symbol resolves, whereas DECL_ALIGN is based
241 on the address at which an object is actually located. These two
242 addresses are not always the same. For example, on ARM targets,
243 the address &foo of a Thumb function foo() has the lowest bit set,
244 whereas foo() itself starts on an even address.
246 If ADDR_P is true we are taking the address of the memory reference EXP
247 and thus cannot rely on the access taking place. */
249 static bool
252 {
254 tree offset;
255 machine_mode mode;
260 /* Get the innermost object and the constant (bitpos) and possibly
261 variable (offset) offset of the access. */
265 /* Extract alignment information from the innermost object and
266 possibly adjust bitpos and offset. */
268 {
269 /* Function addresses can encode extra information besides their
270 alignment. However, if TARGET_PTRMEMFUNC_VBIT_LOCATION
271 allows the low bit to be used as a virtual bit, we know
272 that the address itself must be at least 2-byte aligned. */
275 }
277 ;
279 {
280 /* The alignment of a CONST_DECL is determined by its initializer. */
287 }
289 {
292 }
296 {
302 /* If the address is explicitely aligned, handle that. */
305 {
310 }
312 known_alignment
316 /* Re-apply explicit alignment to the bitpos. */
319 /* The alignment of the pointer operand in a TARGET_MEM_REF
320 has to take the variable offset parts into account. */
322 {
324 {
329 }
333 }
335 /* When EXP is an actual memory reference then we can use
336 TYPE_ALIGN of a pointer indirection to derive alignment.
337 Do so only if get_pointer_alignment_1 did not reveal absolute
338 alignment knowledge and if using that alignment would
339 improve the situation. */
345 else
346 {
347 /* Else adjust bitpos accordingly. */
352 }
353 }
355 {
356 /* STRING_CST are the only constant objects we allow to be not
357 wrapped inside a CONST_DECL. */
363 }
365 /* If there is a non-constant offset part extract the maximum
366 alignment that can prevail. */
368 {
371 {
375 }
376 }
381 }
383 /* For a memory reference expression EXP compute values M and N such that M
384 divides (&EXP - N) and such that N < M. If these numbers can be determined,
385 store M in alignp and N in *BITPOSP and return true. Otherwise return false
386 and store BITS_PER_UNIT to *alignp and any bit-offset to *bitposp. */
388 bool
391 {
393 }
395 /* Return the alignment in bits of EXP, an object. */
397 unsigned int
399 {
405 /* align and bitpos now specify known low bits of the pointer.
406 ptr & (align - 1) == bitpos. */
411 }
413 /* For a pointer valued expression EXP compute values M and N such that M
414 divides (EXP - N) and such that N < M. If these numbers can be determined,
415 store M in alignp and N in *BITPOSP and return true. Return false if
416 the results are just a conservative approximation.
418 If EXP is not a pointer, false is returned too. */
420 bool
423 {
430 {
437 else
438 {
441 {
445 }
446 }
450 }
453 {
458 {
461 /* Make sure to return a sensible alignment when the multiplication
462 by BITS_PER_UNIT overflowed. */
465 /* We cannot really tell whether this result is an approximation. */
467 }
468 else
469 {
473 }
474 }
476 {
481 }
486 }
488 /* Return the alignment in bits of EXP, a pointer valued expression.
489 The alignment returned is, by default, the alignment of the thing that
490 EXP points to. If it is not a POINTER_TYPE, 0 is returned.
492 Otherwise, look at the expression to see if we can do better, i.e., if the
493 expression is actually pointing at an object whose alignment is tighter. */
495 unsigned int
497 {
503 /* align and bitpos now specify known low bits of the pointer.
504 ptr & (align - 1) == bitpos. */
510 }
512 /* Return the number of non-zero elements in the sequence
513 [ PTR, PTR + MAXELTS ) where each element's size is ELTSIZE bytes.
514 ELTSIZE must be a power of 2 less than 8. Used by c_strlen. */
516 static unsigned
518 {
524 {
525 /* Optimize the common case of plain char. */
527 {
531 }
532 }
533 else
534 {
536 {
540 }
541 }
543 }
545 /* Compute the length of a null-terminated character string or wide
546 character string handling character sizes of 1, 2, and 4 bytes.
547 TREE_STRING_LENGTH is not the right way because it evaluates to
548 the size of the character array in bytes (as opposed to characters)
549 and because it can contain a zero byte in the middle.
551 ONLY_VALUE should be nonzero if the result is not going to be emitted
552 into the instruction stream and zero if it is going to be expanded.
553 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
554 is returned, otherwise NULL, since
555 len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
556 evaluate the side-effects.
558 If ONLY_VALUE is two then we do not emit warnings about out-of-bound
559 accesses. Note that this implies the result is not going to be emitted
560 into the instruction stream.
562 The value returned is of type `ssizetype'.
564 Unfortunately, string_constant can't access the values of const char
565 arrays with initializers, so neither can we do so here. */
567 tree
569 {
573 {
580 }
588 /* Offset from the beginning of the string in bytes. */
589 tree byteoff;
594 /* Determine the size of the string element. */
595 unsigned eltsize
598 /* Set MAXELTS to sizeof (SRC) / sizeof (*SRC) - 1, the maximum possible
599 length of SRC. */
602 /* PTR can point to the byte representation of any string type, including
603 char* and wchar_t*. */
607 {
608 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
609 compute the offset to the following null if we don't know where to
610 start searching for it. */
612 {
613 /* Return when an embedded null character is found. */
615 }
617 /* We don't know the starting offset, but we do know that the string
618 has no internal zero bytes. We can assume that the offset falls
619 within the bounds of the string; otherwise, the programmer deserves
620 what he gets. Subtract the offset from the length of the string,
621 and return that. This would perhaps not be valid if we were dealing
622 with named arrays in addition to literal string constants. */
625 }
627 /* Offset from the beginning of the string in elements. */
628 HOST_WIDE_INT eltoff;
630 /* We have a known offset into the string. Start searching there for
631 a null character if we can represent it as a single HOST_WIDE_INT. */
636 else
639 /* If the offset is known to be out of bounds, warn, and call strlen at
640 runtime. */
642 {
643 /* Suppress multiple warnings for propagated constant strings. */
646 {
648 eltoff);
650 }
652 }
654 /* Use strlen to search for the first zero byte. Since any strings
655 constructed with build_string will have nulls appended, we win even
656 if we get handed something like (char[4])"abcd".
658 Since ELTOFF is our starting index into the string, no further
659 calculation is needed. */
664 }
666 /* Return a constant integer corresponding to target reading
667 GET_MODE_BITSIZE (MODE) bits from string constant STR. */
669 static rtx
671 {
672 HOST_WIDE_INT ch;
686 {
698 }
702 }
704 /* Cast a target constant CST to target CHAR and if that value fits into
705 host char type, return zero and put that value into variable pointed to by
706 P. */
708 static int
710 {
717 /* Do not care if it fits or not right here. */
732 }
734 /* Similar to save_expr, but assumes that arbitrary code is not executed
735 in between the multiple evaluations. In particular, we assume that a
736 non-addressable local variable will not be modified. */
738 static tree
740 {
748 }
750 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
751 times to get the address of either a higher stack frame, or a return
752 address located within it (depending on FNDECL_CODE). */
754 static rtx
756 {
760 {
761 /* For a zero count with __builtin_return_address, we don't care what
762 frame address we return, because target-specific definitions will
763 override us. Therefore frame pointer elimination is OK, and using
764 the soft frame pointer is OK.
766 For a nonzero count, or a zero count with __builtin_frame_address,
767 we require a stable offset from the current frame pointer to the
768 previous one, so we must use the hard frame pointer, and
769 we must disable frame pointer elimination. */
772 else
773 {
776 /* Tell reload not to eliminate the frame pointer. */
778 }
779 }
784 /* On the SPARC, the return address is not in the frame, it is in a
785 register. There is no way to access it off of the current frame
786 pointer, but it can be accessed off the previous frame pointer by
787 reading the value from the register window save area. */
789 count--;
791 /* Scan back COUNT frames to the specified frame. */
793 {
794 /* Assume the dynamic chain pointer is in the word that the
795 frame address points to, unless otherwise specified. */
800 }
802 /* For __builtin_frame_address, return what we've got. But, on
803 the SPARC for example, we may have to add a bias. */
807 /* For __builtin_return_address, get the return address from that frame. */
808 #ifdef RETURN_ADDR_RTX
810 #else
814 #endif
816 }
818 /* Alias set used for setjmp buffer. */
821 /* Construct the leading half of a __builtin_setjmp call. Control will
822 return to RECEIVER_LABEL. This is also called directly by the SJLJ
823 exception handling code. */
825 void
827 {
829 rtx stack_save;
830 rtx mem;
839 /* We store the frame pointer and the address of receiver_label in
840 the buffer and use the rest of it for the stack save area, which
841 is machine-dependent. */
860 /* If there is further processing to do, do it. */
864 /* We have a nonlocal label. */
866 }
868 /* Construct the trailing part of a __builtin_setjmp call. This is
869 also called directly by the SJLJ exception handling code.
870 If RECEIVER_LABEL is NULL, instead contruct a nonlocal goto handler. */
872 void
874 {
875 rtx chain;
877 /* Mark the FP as used when we get here, so we have to make sure it's
878 marked as used by this function. */
881 /* Mark the static chain as clobbered here so life information
882 doesn't get messed up for it. */
887 /* Now put in the code to restore the frame pointer, and argument
888 pointer, if needed. */
890 {
891 /* First adjust our frame pointer to its actual value. It was
892 previously set to the start of the virtual area corresponding to
893 the stacked variables when we branched here and now needs to be
894 adjusted to the actual hardware fp value.
896 Assignments to virtual registers are converted by
897 instantiate_virtual_regs into the corresponding assignment
898 to the underlying register (fp in this case) that makes
899 the original assignment true.
900 So the following insn will actually be decrementing fp by
901 STARTING_FRAME_OFFSET. */
904 /* Restoring the frame pointer also modifies the hard frame pointer.
905 Mark it used (so that the previous assignment remains live once
906 the frame pointer is eliminated) and clobbered (to represent the
907 implicit update from the assignment). */
910 }
913 {
914 /* If the argument pointer can be eliminated in favor of the
915 frame pointer, we don't need to restore it. We assume here
916 that if such an elimination is present, it can always be used.
917 This is the case on all known machines; if we don't make this
918 assumption, we do unnecessary saving on many machines. */
928 {
929 /* Now restore our arg pointer from the address at which it
930 was saved in our stack frame. */
933 }
934 }
940 else
943 /* We must not allow the code we just generated to be reordered by
944 scheduling. Specifically, the update of the frame pointer must
945 happen immediately, not later. */
947 }
949 /* __builtin_longjmp is passed a pointer to an array of five words (not
950 all will be used on all machines). It operates similarly to the C
951 library function of the same name, but is more efficient. Much of
952 the code below is copied from the handling of non-local gotos. */
954 static void
956 {
961 /* DRAP is needed for stack realign if longjmp is expanded to current
962 function */
973 /* We require that the user must pass a second argument of 1, because
974 that is what builtin_setjmp will return. */
980 else
981 {
992 /* Pick up FP, label, and SP from the block and jump. This code is
993 from expand_goto in stmt.c; see there for detailed comments. */
995 /* We have to pass a value to the nonlocal_goto pattern that will
996 get copied into the static_chain pointer, but it does not matter
997 what that value is, because builtin_setjmp does not use it. */
999 else
1000 {
1012 }
1013 }
1015 /* Search backwards and mark the jump insn as a non-local goto.
1016 Note that this precludes the use of __builtin_longjmp to a
1017 __builtin_setjmp target in the same function. However, we've
1018 already cautioned the user that these functions are for
1019 internal exception handling use only. */
1021 {
1025 {
1028 }
1031 }
1032 }
1036 {
1038 }
1040 /* This function validates the types of a function call argument list
1041 against a specified list of tree_codes. If the last specifier is a 0,
1042 that represents an ellipsis, otherwise the last specifier must be a
1043 VOID_TYPE. */
1045 static bool
1047 {
1051 const_call_expr_arg_iterator iter;
1052 const_tree arg;
1057 /* Get a bitmap of pointer argument numbers declared attribute nonnull. */
1062 {
1066 {
1068 /* This signifies an ellipses, any further arguments are all ok. */
1072 /* This signifies an endlink, if no arguments remain, return
1073 true, otherwise return false. */
1077 /* The actual argument must be nonnull when either the whole
1078 called function has been declared nonnull, or when the formal
1079 argument corresponding to the actual argument has been. */
1082 {
1087 }
1088 /* FALLTHRU */
1090 /* If no parameters remain or the parameter's code does not
1091 match the specified code, return false. Otherwise continue
1092 checking any remaining arguments. */
1097 }
1098 }
1100 /* We need gotos here since we can only have one VA_CLOSE in a
1101 function. */
1102 end: ;
1108 }
1110 /* Expand a call to __builtin_nonlocal_goto. We're passed the target label
1111 and the address of the save area. */
1113 static rtx
1115 {
1130 /* Copy the address of the save location to a register just in case it was
1131 based on the frame pointer. */
1140 /* ??? We no longer need to pass the static chain value, afaik. */
1143 else
1144 {
1150 /* Restore frame pointer for containing function. */
1154 /* USE of hard_frame_pointer_rtx added for consistency;
1155 not clear if really needed. */
1159 /* If the architecture is using a GP register, we must
1160 conservatively assume that the target function makes use of it.
1161 The prologue of functions with nonlocal gotos must therefore
1162 initialize the GP register to the appropriate value, and we
1163 must then make sure that this value is live at the point
1164 of the jump. (Note that this doesn't necessarily apply
1165 to targets with a nonlocal_goto pattern; they are free
1166 to implement it in their own way. Note also that this is
1167 a no-op if the GP register is a global invariant.) */
1173 }
1175 /* Search backwards to the jump insn and mark it as a
1176 non-local goto. */
1178 {
1180 {
1183 }
1186 }
1189 }
1191 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
1192 (not all will be used on all machines) that was passed to __builtin_setjmp.
1193 It updates the stack pointer in that block to the current value. This is
1194 also called directly by the SJLJ exception handling code. */
1196 void
1198 {
1200 rtx stack_save
1202 memory_address
1208 }
1210 /* Expand a call to __builtin_prefetch. For a target that does not support
1211 data prefetch, evaluate the memory address argument in case it has side
1212 effects. */
1214 static void
1216 {
1226 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1227 zero (read) and argument 2 (locality) defaults to 3 (high degree of
1228 locality). */
1232 else
1236 else
1239 /* Argument 0 is an address. */
1242 /* Argument 1 (read/write flag) must be a compile-time constant int. */
1244 {
1247 }
1249 /* Argument 1 must be either zero or one. */
1251 {
1255 }
1257 /* Argument 2 (locality) must be a compile-time constant int. */
1259 {
1262 }
1264 /* Argument 2 must be 0, 1, 2, or 3. */
1266 {
1269 }
1272 {
1280 }
1282 /* Don't do anything with direct references to volatile memory, but
1283 generate code to handle other side effects. */
1286 }
1288 /* Get a MEM rtx for expression EXP which is the address of an operand
1289 to be used in a string instruction (cmpstrsi, movmemsi, ..). LEN is
1290 the maximum length of the block of memory that might be accessed or
1291 NULL if unknown. */
1293 static rtx
1295 {
1299 /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1300 from its expression, for expr->a.b only <variable>.a.b is recorded. */
1307 /* Get an expression we can use to find the attributes to assign to MEM.
1308 First remove any nops. */
1313 /* Build a MEM_REF representing the whole accessed area as a byte blob,
1314 (as builtin stringops may alias with anything). */
1321 /* If the MEM_REF has no acceptable address, try to get the base object
1322 from the original address we got, and build an all-aliasing
1323 unknown-sized access to that one. */
1329 {
1334 size_zero_node,
1335 NULL)),
1338 }
1341 }
1342 \f
1343 /* Built-in functions to perform an untyped call and return. */
1345 #define apply_args_mode \
1346 (this_target_builtins->x_apply_args_mode)
1347 #define apply_result_mode \
1348 (this_target_builtins->x_apply_result_mode)
1350 /* Return the size required for the block returned by __builtin_apply_args,
1351 and initialize apply_args_mode. */
1353 static int
1355 {
1359 machine_mode mode;
1361 /* The values computed by this function never change. */
1363 {
1364 /* The first value is the incoming arg-pointer. */
1367 /* The second value is the structure value address unless this is
1368 passed as an "invisible" first argument. */
1374 {
1384 }
1385 else
1386 {
1388 }
1389 }
1391 }
1393 /* Return the size required for the block returned by __builtin_apply,
1394 and initialize apply_result_mode. */
1396 static int
1398 {
1401 machine_mode mode;
1403 /* The values computed by this function never change. */
1405 {
1410 {
1420 }
1421 else
1424 /* Allow targets that use untyped_call and untyped_return to override
1425 the size so that machine-specific information can be stored here. */
1426 #ifdef APPLY_RESULT_SIZE
1428 #endif
1429 }
1431 }
1433 /* Create a vector describing the result block RESULT. If SAVEP is true,
1434 the result block is used to save the values; otherwise it is used to
1435 restore the values. */
1437 static rtx
1439 {
1441 machine_mode mode;
1448 {
1458 }
1460 }
1462 /* Save the state required to perform an untyped call with the same
1463 arguments as were passed to the current function. */
1465 static rtx
1467 {
1470 machine_mode mode;
1471 rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1473 /* Create a block where the arg-pointer, structure value address,
1474 and argument registers can be saved. */
1477 /* Walk past the arg-pointer and structure value address. */
1482 /* Save each register used in calling a function to the block. */
1485 {
1494 }
1496 /* Save the arg pointer to the block. */
1498 /* We need the pointer as the caller actually passed them to us, not
1499 as we might have pretended they were passed. Make sure it's a valid
1500 operand, as emit_move_insn isn't expected to handle a PLUS. */
1502 tem
1505 NULL_RTX);
1510 /* Save the structure value address unless this is passed as an
1511 "invisible" first argument. */
1513 {
1517 }
1519 /* Return the address of the block. */
1521 }
1523 /* __builtin_apply_args returns block of memory allocated on
1524 the stack into which is stored the arg pointer, structure
1525 value address, static chain, and all the registers that might
1526 possibly be used in performing a function call. The code is
1527 moved to the start of the function so the incoming values are
1528 saved. */
1530 static rtx
1532 {
1533 /* Don't do __builtin_apply_args more than once in a function.
1534 Save the result of the first call and reuse it. */
1537 {
1538 /* When this function is called, it means that registers must be
1539 saved on entry to this function. So we migrate the
1540 call to the first insn of this function. */
1541 rtx temp;
1550 /* Put the insns after the NOTE that starts the function.
1551 If this is inside a start_sequence, make the outer-level insn
1552 chain current, so the code is placed at the start of the
1553 function. If internal_arg_pointer is a non-virtual pseudo,
1554 it needs to be placed after the function that initializes
1555 that pseudo. */
1560 else
1564 }
1565 }
1567 /* Perform an untyped call and save the state required to perform an
1568 untyped return of whatever value was returned by the given function. */
1570 static rtx
1572 {
1574 machine_mode mode;
1583 /* Create a block where the return registers can be saved. */
1586 /* Fetch the arg pointer from the ARGUMENTS block. */
1593 /* Push a new argument block and copy the arguments. Do not allow
1594 the (potential) memcpy call below to interfere with our stack
1595 manipulations. */
1597 NO_DEFER_POP;
1599 /* Save the stack with nonlocal if available. */
1602 else
1605 /* Allocate a block of memory onto the stack and copy the memory
1606 arguments to the outgoing arguments address. We can pass TRUE
1607 as the 4th argument because we just saved the stack pointer
1608 and will restore it right after the call. */
1611 /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1612 may have already set current_function_calls_alloca to true.
1613 current_function_calls_alloca won't be set if argsize is zero,
1614 so we have to guarantee need_drap is true here. */
1620 {
1623 else
1625 }
1632 /* Refer to the argument block. */
1637 /* Walk past the arg-pointer and structure value address. */
1642 /* Restore each of the registers previously saved. Make USE insns
1643 for each of these registers for use in making the call. */
1646 {
1654 }
1656 /* Restore the structure value address unless this is passed as an
1657 "invisible" first argument. */
1660 {
1667 }
1669 /* All arguments and registers used for the call are set up by now! */
1672 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1673 and we don't want to load it into a register as an optimization,
1674 because prepare_call_address already did it if it should be done. */
1678 /* Generate the actual call instruction and save the return value. */
1680 {
1684 }
1686 {
1689 /* Locate the unique return register. It is not possible to
1690 express a call that sets more than one return register using
1691 call_value; use untyped_call for that. In fact, untyped_call
1692 only needs to save the return registers in the given block. */
1695 {
1699 }
1706 }
1707 else
1710 /* Find the CALL insn we just emitted, and attach the register usage
1711 information. */
1715 /* Restore the stack. */
1718 else
1722 OK_DEFER_POP;
1724 /* Return the address of the result block. */
1727 }
1729 /* Perform an untyped return. */
1731 static void
1733 {
1735 machine_mode mode;
1736 rtx reg;
1745 {
1750 }
1752 /* Restore the return value and note that each value is used. */
1756 {
1768 }
1770 /* Put the USE insns before the return. */
1773 /* Return whatever values was restored by jumping directly to the end
1774 of the function. */
1776 }
1778 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1780 static enum type_class
1782 {
1784 {
1803 }
1804 }
1806 /* Expand a call EXP to __builtin_classify_type. */
1808 static rtx
1810 {
1814 }
1816 /* This helper macro, meant to be used in mathfn_built_in below,
1817 determines which among a set of three builtin math functions is
1818 appropriate for a given type mode. The `F' and `L' cases are
1819 automatically generated from the `double' case. */
1820 #define CASE_MATHFN(MATHFN) \
1821 CASE_CFN_##MATHFN: \
1822 fcode = BUILT_IN_##MATHFN; fcodef = BUILT_IN_##MATHFN##F ; \
1823 fcodel = BUILT_IN_##MATHFN##L ; break;
1824 /* Similar to above, but appends _R after any F/L suffix. */
1825 #define CASE_MATHFN_REENT(MATHFN) \
1826 case CFN_BUILT_IN_##MATHFN##_R: \
1827 case CFN_BUILT_IN_##MATHFN##F_R: \
1828 case CFN_BUILT_IN_##MATHFN##L_R: \
1829 fcode = BUILT_IN_##MATHFN##_R; fcodef = BUILT_IN_##MATHFN##F_R ; \
1830 fcodel = BUILT_IN_##MATHFN##L_R ; break;
1832 /* Return a function equivalent to FN but operating on floating-point
1833 values of type TYPE, or END_BUILTINS if no such function exists.
1834 This is purely an operation on function codes; it does not guarantee
1835 that the target actually has an implementation of the function. */
1837 static built_in_function
1839 {
1843 {
1934 }
1942 else
1944 }
1946 /* Return mathematic function equivalent to FN but operating directly on TYPE,
1947 if available. If IMPLICIT_P is true use the implicit builtin declaration,
1948 otherwise use the explicit declaration. If we can't do the conversion,
1949 return null. */
1951 static tree
1953 {
1962 }
1964 /* Like mathfn_built_in_1, but always use the implicit array. */
1966 tree
1968 {
1970 }
1972 /* Like mathfn_built_in_1, but take a built_in_function and
1973 always use the implicit array. */
1975 tree
1977 {
1979 }
1981 /* If BUILT_IN_NORMAL function FNDECL has an associated internal function,
1982 return its code, otherwise return IFN_LAST. Note that this function
1983 only tests whether the function is defined in internals.def, not whether
1984 it is actually available on the target. */
1986 internal_fn
1988 {
1992 {
1993 #define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE) \
1994 CASE_FLT_FN (BUILT_IN_##NAME): return IFN_##NAME;
1995 #define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE) \
1996 CASE_INT_FN (BUILT_IN_##NAME): return IFN_##NAME;
2013 }
2014 }
2016 /* If CALL is a call to a BUILT_IN_NORMAL function that could be replaced
2017 on the current target by a call to an internal function, return the
2018 code of that internal function, otherwise return IFN_LAST. The caller
2019 is responsible for ensuring that any side-effects of the built-in
2020 call are dealt with correctly. E.g. if CALL sets errno, the caller
2021 must decide that the errno result isn't needed or make it available
2022 in some other way. */
2024 internal_fn
2026 {
2028 {
2031 {
2036 }
2037 }
2039 }
2041 /* Expand a call to the builtin trinary math functions (fma).
2042 Return NULL_RTX if a normal call should be emitted rather than expanding the
2043 function in-line. EXP is the expression that is a call to the builtin
2044 function; if convenient, the result should be placed in TARGET.
2045 SUBTARGET may be used as the target for computing one of EXP's
2046 operands. */
2048 static rtx
2050 {
2051 optab builtin_optab;
2056 machine_mode mode;
2066 {
2071 }
2073 /* Make a suitable register to place result in. */
2076 /* Before working hard, check whether the instruction is available. */
2082 /* Always stabilize the argument list. */
2093 /* Compute into RESULT.
2094 Set RESULT to wherever the result comes back. */
2098 /* If we were unable to expand via the builtin, stop the sequence
2099 (without outputting the insns) and call to the library function
2100 with the stabilized argument list. */
2102 {
2105 }
2107 /* Output the entire sequence. */
2113 }
2115 /* Expand a call to the builtin sin and cos math functions.
2116 Return NULL_RTX if a normal call should be emitted rather than expanding the
2117 function in-line. EXP is the expression that is a call to the builtin
2118 function; if convenient, the result should be placed in TARGET.
2119 SUBTARGET may be used as the target for computing one of EXP's
2120 operands. */
2122 static rtx
2124 {
2125 optab builtin_optab;
2126 rtx op0;
2129 machine_mode mode;
2130 tree arg;
2138 {
2144 }
2146 /* Make a suitable register to place result in. */
2149 /* Check if sincos insn is available, otherwise fallback
2150 to sin or cos insn. */
2153 {
2160 }
2162 /* Before working hard, check whether the instruction is available. */
2164 {
2167 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2168 need to expand the argument again. This way, we will not perform
2169 side-effects more the once. */
2176 /* Compute into RESULT.
2177 Set RESULT to wherever the result comes back. */
2179 {
2183 {
2192 }
2194 }
2195 else
2199 {
2200 /* Output the entire sequence. */
2205 }
2207 /* If we were unable to expand via the builtin, stop the sequence
2208 (without outputting the insns) and call to the library function
2209 with the stabilized argument list. */
2211 }
2214 }
2216 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2217 return an RTL instruction code that implements the functionality.
2218 If that isn't possible or available return CODE_FOR_nothing. */
2220 static enum insn_code
2222 {
2225 machine_mode mode;
2228 {
2242 /* These builtins have no optabs (yet). */
2246 }
2248 /* There's no easy way to detect the case we need to set EDOM. */
2252 /* Optab mode depends on the mode of the input argument. */
2258 }
2260 /* Expand a call to one of the builtin math functions that operate on
2261 floating point argument and output an integer result (ilogb, isinf,
2262 isnan, etc).
2263 Return 0 if a normal call should be emitted rather than expanding the
2264 function in-line. EXP is the expression that is a call to the builtin
2265 function; if convenient, the result should be placed in TARGET. */
2267 static rtx
2269 {
2271 rtx op0;
2273 machine_mode mode;
2274 tree arg;
2284 {
2289 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2290 need to expand the argument again. This way, we will not perform
2291 side-effects more the once. */
2306 }
2309 }
2311 /* Expand a call to the builtin sincos math function.
2312 Return NULL_RTX if a normal call should be emitted rather than expanding the
2313 function in-line. EXP is the expression that is a call to the builtin
2314 function. */
2316 static rtx
2318 {
2320 machine_mode mode;
2334 /* Make a suitable register to place result in. */
2337 /* Check if sincos insn is available, otherwise emit the call. */
2352 /* Compute into target1 and target2.
2353 Set TARGET to wherever the result comes back. */
2357 /* Move target1 and target2 to the memory locations indicated
2358 by op1 and op2. */
2363 }
2365 /* Expand a call to the internal cexpi builtin to the sincos math function.
2366 EXP is the expression that is a call to the builtin function; if convenient,
2367 the result should be placed in TARGET. */
2369 static rtx
2371 {
2374 machine_mode mode;
2385 /* Try expanding via a sincos optab, fall back to emitting a libcall
2386 to sincos or cexp. We are sure we have sincos or cexp because cexpi
2387 is only generated from sincos, cexp or if we have either of them. */
2389 {
2395 /* Compute into op1 and op2. */
2397 }
2399 {
2410 else
2420 /* Make sure not to fold the sincos call again. */
2424 }
2425 else
2426 {
2436 else
2439 /* If we don't have a decl for cexp create one. This is the
2440 friendliest fallback if the user calls __builtin_cexpi
2441 without full target C99 function support. */
2443 {
2444 tree fntype;
2456 }
2461 /* Make sure not to fold the cexp call again. */
2465 }
2467 /* Now build the proper return type. */
2472 }
2474 /* Conveniently construct a function call expression. FNDECL names the
2475 function to be called, N is the number of arguments, and the "..."
2476 parameters are the argument expressions. Unlike build_call_exr
2477 this doesn't fold the call, hence it will always return a CALL_EXPR. */
2479 static tree
2481 {
2491 }
2493 /* Expand a call to one of the builtin rounding functions gcc defines
2494 as an extension (lfloor and lceil). As these are gcc extensions we
2495 do not need to worry about setting errno to EDOM.
2496 If expanding via optab fails, lower expression to (int)(floor(x)).
2497 EXP is the expression that is a call to the builtin function;
2498 if convenient, the result should be placed in TARGET. */
2500 static rtx
2502 {
2503 convert_optab builtin_optab;
2508 tree fallback_fndecl;
2509 machine_mode mode;
2510 tree arg;
2518 {
2535 }
2537 /* Make a suitable register to place result in. */
2542 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2543 need to expand the argument again. This way, we will not perform
2544 side-effects more the once. */
2551 /* Compute into TARGET. */
2553 {
2554 /* Output the entire sequence. */
2559 }
2561 /* If we were unable to expand via the builtin, stop the sequence
2562 (without outputting the insns). */
2565 /* Fall back to floating point rounding optab. */
2568 /* For non-C99 targets we may end up without a fallback fndecl here
2569 if the user called __builtin_lfloor directly. In this case emit
2570 a call to the floor/ceil variants nevertheless. This should result
2571 in the best user experience for not full C99 targets. */
2573 {
2574 tree fntype;
2578 {
2611 }
2616 }
2623 /* Truncate the result of floating point optab to integer
2624 via expand_fix (). */
2629 }
2631 /* Expand a call to one of the builtin math functions doing integer
2632 conversion (lrint).
2633 Return 0 if a normal call should be emitted rather than expanding the
2634 function in-line. EXP is the expression that is a call to the builtin
2635 function; if convenient, the result should be placed in TARGET. */
2637 static rtx
2639 {
2640 convert_optab builtin_optab;
2641 rtx op0;
2644 tree arg;
2645 machine_mode mode;
2654 {
2673 }
2675 /* There's no easy way to detect the case we need to set EDOM. */
2679 /* Make a suitable register to place result in. */
2682 /* There's no easy way to detect the case we need to set EDOM. */
2684 {
2687 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2688 need to expand the argument again. This way, we will not perform
2689 side-effects more the once. */
2697 {
2698 /* Output the entire sequence. */
2703 }
2705 /* If we were unable to expand via the builtin, stop the sequence
2706 (without outputting the insns) and call to the library function
2707 with the stabilized argument list. */
2709 }
2712 {
2713 /* Fall back to rounding to long int. Use implicit_p 0 - for non-C99
2714 targets, (int) round (x) should never be transformed into
2715 BUILT_IN_IROUND and if __builtin_iround is called directly, emit
2716 a call to lround in the hope that the target provides at least some
2717 C99 functions. This should result in the best user experience for
2718 not full C99 targets. */
2719 tree fallback_fndecl = mathfn_built_in_1
2728 }
2731 }
2733 /* Expand a call to the powi built-in mathematical function. Return NULL_RTX if
2734 a normal call should be emitted rather than expanding the function
2735 in-line. EXP is the expression that is a call to the builtin
2736 function; if convenient, the result should be placed in TARGET. */
2738 static rtx
2740 {
2743 machine_mode mode;
2744 machine_mode mode2;
2753 /* Emit a libcall to libgcc. */
2755 /* Mode of the 2nd argument must match that of an int. */
2773 }
2775 /* Expand expression EXP which is a call to the strlen builtin. Return
2776 NULL_RTX if we failed the caller should emit a normal call, otherwise
2777 try to get the result in TARGET, if convenient. */
2779 static rtx
2781 machine_mode target_mode)
2782 {
2785 else
2786 {
2788 rtx pat;
2789 tree len;
2791 rtx src_reg;
2797 /* If the length can be computed at compile-time, return it. */
2802 /* If the length can be computed at compile-time and is constant
2803 integer, but there are side-effects in src, evaluate
2804 src for side-effects, then return len.
2805 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
2806 can be optimized into: i++; x = 3; */
2809 {
2812 }
2816 /* If SRC is not a pointer type, don't do this operation inline. */
2820 /* Bail out if we can't compute strlen in the right mode. */
2822 {
2828 }
2832 /* Make a place to hold the source address. We will not expand
2833 the actual source until we are sure that the expansion will
2834 not fail -- there are trees that cannot be expanded twice. */
2837 /* Mark the beginning of the strlen sequence so we can emit the
2838 source operand later. */
2848 /* Now that we are assured of success, expand the source. */
2852 {
2853 #ifdef POINTERS_EXTEND_UNSIGNED
2856 POINTERS_EXTEND_UNSIGNED);
2857 #endif
2859 }
2865 else
2868 /* Return the value in the proper mode for this function. */
2873 else
2877 }
2878 }
2880 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
2881 bytes from constant string DATA + OFFSET and return it as target
2882 constant. */
2884 static rtx
2886 machine_mode mode)
2887 {
2895 }
2897 /* LEN specify length of the block of memcpy/memset operation.
2898 Figure out its range and put it into MIN_SIZE/MAX_SIZE.
2899 In some cases we can make very likely guess on max size, then we
2900 set it into PROBABLE_MAX_SIZE. */
2902 static void
2907 {
2909 {
2912 }
2913 else
2914 {
2918 /* Determine bounds from the type. */
2921 else
2926 else
2932 {
2937 }
2939 {
2940 /* Anti range 0...N lets us to determine minimal size to N+1. */
2942 {
2945 }
2946 /* Code like
2948 int n;
2949 if (n < 100)
2950 memcpy (a, b, n)
2952 Produce anti range allowing negative values of N. We still
2953 can use the information and make a guess that N is not negative.
2954 */
2957 }
2958 }
2962 }
2964 /* Helper function to do the actual work for expand_builtin_memcpy. */
2966 static rtx
2968 {
2979 /* If DEST is not a pointer type, call the normal function. */
2983 /* If either SRC is not a pointer type, don't do this
2984 operation in-line. */
3001 /* If SRC is a string constant and block move would be done
3002 by pieces, we can avoid loading the string from memory
3003 and only stored the computed constants. */
3010 {
3012 builtin_memcpy_read_str,
3018 }
3023 /* Copy word part most expediently. */
3031 {
3034 }
3037 }
3039 /* Try to verify that the sizes and lengths of the arguments to a string
3040 manipulation function given by EXP are within valid bounds and that
3041 the operation does not lead to buffer overflow. Arguments other than
3042 EXP may be null. When non-null, the arguments have the following
3043 meaning:
3044 SIZE is the user-supplied size argument to the function (such as in
3045 memcpy(d, s, SIZE) or strncpy(d, s, SIZE). It specifies the exact
3046 number of bytes to write.
3047 MAXLEN is the user-supplied bound on the length of the source sequence
3048 (such as in strncat(d, s, N). It specifies the upper limit on the number
3049 of bytes to write.
3050 SRC is the source string (such as in strcpy(d, s)) when the expression
3051 EXP is a string function call (as opposed to a memory call like memcpy).
3052 As an exception, SRC can also be an integer denoting the precomputed
3053 size of the source string or object (for functions like memcpy).
3054 OBJSIZE is the size of the destination object specified by the last
3055 argument to the _chk builtins, typically resulting from the expansion
3056 of __builtin_object_size (such as in __builtin___strcpy_chk(d, s,
3057 OBJSIZE).
3059 When SIZE is null LEN is checked to verify that it doesn't exceed
3060 SIZE_MAX.
3062 If the call is successfully verified as safe from buffer overflow
3063 the function returns true, otherwise false.. */
3065 static bool
3067 {
3068 /* The size of the largest object is half the address space, or
3069 SSIZE_MAX. (This is way too permissive.) */
3076 /* Set to true when the exact number of bytes written by a string
3077 function like strcpy is not known and the only thing that is
3078 known is that it must be at least one (for the terminating nul). */
3081 {
3082 /* SRC is normally a pointer to string but as a special case
3083 it can be an integer denoting the length of a string. */
3085 {
3086 /* Try to determine the range of lengths the source string
3087 refers to. If it can be determined and is less than
3088 the upper bound given by MAXLEN add one to it for
3089 the terminating nul. Otherwise, set it to one for
3090 the same reason, or to MAXLEN as appropriate. */
3093 {
3096 else
3107 }
3108 else
3109 {
3112 }
3113 }
3114 else
3116 }
3119 {
3120 /* When the only available piece of data is the object size
3121 there is nothing to do. */
3125 /* Otherwise, when the length of the source sequence is known
3126 (as with with strlen), set SIZE to it. */
3129 }
3134 /* The SIZE is exact if it's non-null, constant, and in range of
3135 unsigned HOST_WIDE_INT. */
3141 /* First check the number of bytes to be written against the maximum
3142 object size. */
3144 {
3150 "%K%qD specified size %E "
3153 else
3155 "%K%qD specified size between %E and %E "
3160 }
3162 /* Next check the number of bytes to be written against the destination
3163 object size. */
3165 {
3171 {
3176 {
3177 /* This is a call to strcpy with a destination of 0 size
3178 and a source of unknown length. The call will write
3179 at least one byte past the end of the destination. */
3181 "%K%qD writing %E or more bytes into a region "
3184 }
3194 {
3195 /* Avoid printing the upper bound if it's invalid. */
3197 "%K%qD writing %E or more bytes into a region "
3200 }
3201 else
3203 "%K%qD writing between %E and %E bytes into "
3206 objsize);
3208 /* Return error when an overflow has been detected. */
3210 }
3211 }
3213 /* Check the maximum length of the source sequence against the size
3214 of the destination object if known, or against the maximum size
3215 of an object. */
3217 {
3221 {
3226 {
3227 /* Warn about crazy big sizes first since that's more
3228 likely to be meaningful than saying that the bound
3229 is greater than the object size if both are big. */
3232 "%K%qD specified bound %E "
3236 else
3238 "%K%qD specified bound between %E and %E "
3244 }
3247 {
3250 "%K%qD specified bound %E "
3254 else
3256 "%K%qD specified bound between %E and %E "
3261 }
3262 }
3263 }
3269 {
3279 {
3280 /* Avoid printing the upper bound if it's invalid. */
3282 "%K%qD reading %E or more bytes from a region "
3285 }
3286 else
3288 "%K%qD reading between %E and %E bytes from a region "
3292 }
3295 }
3297 /* Helper to compute the size of the object referenced by the DEST
3298 expression which must of of pointer type, using Object Size type
3299 OSTYPE (only the least significant 2 bits are used). Return
3300 the size of the object if successful or NULL when the size cannot
3301 be determined. */
3305 {
3311 }
3313 /* Helper to determine and check the sizes of the source and the destination
3314 of calls to __builtin_{bzero,memcpy,mempcpy,memset} calls. EXP is the
3315 call expression, DEST is the destination argument, SRC is the source
3316 argument or null, and LEN is the number of bytes. Use Object Size type-0
3317 regardless of the OPT_Wstringop_overflow_ setting. Return true on success
3318 (no overflow or invalid sizes), false otherwise. */
3320 static bool
3322 {
3326 /* For functions like memset and memcpy that operate on raw memory
3327 try to determine the size of the largest source and destination
3328 object using type-0 Object Size regardless of the object size
3329 type specified by the option. */
3335 }
3337 /* Validate memchr arguments without performing any expansion.
3338 Return NULL_RTX. */
3340 static rtx
3342 {
3350 /* Diagnose calls where the specified length exceeds the size
3351 of the object. */
3353 {
3358 }
3361 }
3363 /* Expand a call EXP to the memcpy builtin.
3364 Return NULL_RTX if we failed, the caller should emit a normal call,
3365 otherwise try to get the result in TARGET, if convenient (and in
3366 mode MODE if that's convenient). */
3368 static rtx
3370 {
3382 }
3384 /* Check a call EXP to the memmove built-in for validity.
3385 Return NULL_RTX on both success and failure. */
3387 static rtx
3389 {
3401 }
3403 /* Expand an instrumented call EXP to the memcpy builtin.
3404 Return NULL_RTX if we failed, the caller should emit a normal call,
3405 otherwise try to get the result in TARGET, if convenient (and in
3406 mode MODE if that's convenient). */
3408 static rtx
3410 {
3416 else
3417 {
3423 /* Return src bounds with the result. */
3425 {
3429 }
3431 }
3432 }
3434 /* Expand a call EXP to the mempcpy builtin.
3435 Return NULL_RTX if we failed; the caller should emit a normal call,
3436 otherwise try to get the result in TARGET, if convenient (and in
3437 mode MODE if that's convenient). If ENDP is 0 return the
3438 destination pointer, if ENDP is 1 return the end pointer ala
3439 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3440 stpcpy. */
3442 static rtx
3444 {
3453 /* Avoid expanding mempcpy into memcpy when the call is determined
3454 to overflow the buffer. This also prevents the same overflow
3455 from being diagnosed again when expanding memcpy. */
3461 exp);
3462 }
3464 /* Expand an instrumented call EXP to the mempcpy builtin.
3465 Return NULL_RTX if we failed, the caller should emit a normal call,
3466 otherwise try to get the result in TARGET, if convenient (and in
3467 mode MODE if that's convenient). */
3469 static rtx
3471 {
3477 else
3478 {
3485 /* Return src bounds with the result. */
3487 {
3491 }
3493 }
3494 }
3496 /* Helper function to do the actual work for expand_builtin_mempcpy. The
3497 arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3498 so that this can also be called without constructing an actual CALL_EXPR.
3499 The other arguments and return value are the same as for
3500 expand_builtin_mempcpy. */
3502 static rtx
3505 tree orig_exp)
3506 {
3509 /* If return value is ignored, transform mempcpy into memcpy. */
3513 {
3518 }
3521 {
3526 }
3527 else
3528 {
3534 /* If either SRC or DEST is not a pointer type, don't do this
3535 operation in-line. */
3539 /* If LEN is not constant, call the normal function. */
3546 /* If SRC is a string constant and block move would be done
3547 by pieces, we can avoid loading the string from memory
3548 and only stored the computed constants. */
3555 {
3559 builtin_memcpy_read_str,
3565 }
3570 {
3580 }
3583 }
3584 }
3586 /* Expand into a movstr instruction, if one is available. Return NULL_RTX if
3587 we failed, the caller should emit a normal call, otherwise try to
3588 get the result in TARGET, if convenient. If ENDP is 0 return the
3589 destination pointer, if ENDP is 1 return the end pointer ala
3590 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3591 stpcpy. */
3593 static rtx
3595 {
3597 rtx dest_mem;
3598 rtx src_mem;
3606 {
3609 }
3618 {
3620 /* movstr is supposed to set end to the address of the NUL
3621 terminator. If the caller requested a mempcpy-like return value,
3622 adjust it. */
3624 {
3628 }
3629 }
3631 }
3633 /* Do some very basic size validation of a call to the strcpy builtin
3634 given by EXP. Return NULL_RTX to have the built-in expand to a call
3635 to the library function. */
3637 static rtx
3639 {
3647 /* There is no way here to determine the length of the string in
3648 the destination to which the SRC string is being appended so
3649 just diagnose cases when the souce string is longer than
3650 the destination object. */
3658 }
3660 /* Expand expression EXP, which is a call to the strcpy builtin. Return
3661 NULL_RTX if we failed the caller should emit a normal call, otherwise
3662 try to get the result in TARGET, if convenient (and in mode MODE if that's
3663 convenient). */
3665 static rtx
3667 {
3675 {
3679 }
3682 }
3684 /* Helper function to do the actual work for expand_builtin_strcpy. The
3685 arguments to the builtin_strcpy call DEST and SRC are broken out
3686 so that this can also be called without constructing an actual CALL_EXPR.
3687 The other arguments and return value are the same as for
3688 expand_builtin_strcpy. */
3690 static rtx
3692 {
3694 }
3696 /* Expand a call EXP to the stpcpy builtin.
3697 Return NULL_RTX if we failed the caller should emit a normal call,
3698 otherwise try to get the result in TARGET, if convenient (and in
3699 mode MODE if that's convenient). */
3701 static rtx
3703 {
3714 {
3718 }
3720 /* If return value is ignored, transform stpcpy into strcpy. */
3722 {
3726 }
3727 else
3728 {
3730 rtx ret;
3732 /* Ensure we get an actual string whose length can be evaluated at
3733 compile-time, not an expression containing a string. This is
3734 because the latter will potentially produce pessimized code
3735 when used to produce the return value. */
3742 exp);
3748 {
3752 {
3756 {
3758 {
3761 else
3763 }
3772 }
3773 }
3774 }
3777 }
3778 }
3780 /* Check a call EXP to the stpncpy built-in for validity.
3781 Return NULL_RTX on both success and failure. */
3783 static rtx
3785 {
3791 /* The source and destination of the call. */
3795 /* The exact number of bytes to write (not the maximum). */
3798 /* The size of the destination object. */
3805 }
3807 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3808 bytes from constant string DATA + OFFSET and return it as target
3809 constant. */
3811 rtx
3813 machine_mode mode)
3814 {
3821 }
3823 /* Helper to check the sizes of sequences and the destination of calls
3824 to __builtin_strncat and __builtin___strncat_chk. Returns true on
3825 success (no overflow or invalid sizes), false otherwise. */
3827 static bool
3829 {
3834 /* Try to determine the range of lengths that the source expression
3835 refers to. */
3839 /* Try to verify that the destination is big enough for the shortest
3840 string. */
3843 {
3844 /* If it hasn't been provided by __strncat_chk, try to determine
3845 the size of the destination object into which the source is
3846 being copied. */
3848 }
3850 /* Add one for the terminating nul. */
3853 size_one_node)
3856 /* Strncat copies at most MAXLEN bytes and always appends the terminating
3857 nul so the specified upper bound should never be equal to (or greater
3858 than) the size of the destination. */
3861 {
3870 }
3878 /* The number of bytes to write is LEN but check_sizes will also
3879 check SRCLEN if LEN's value isn't known. */
3882 }
3884 /* Similar to expand_builtin_strcat, do some very basic size validation
3885 of a call to the strcpy builtin given by EXP. Return NULL_RTX to have
3886 the built-in expand to a call to the library function. */
3888 static rtx
3890 {
3898 /* The upper bound on the number of bytes to write. */
3900 /* The length of the source sequence. */
3903 /* Try to determine the range of lengths that the source expression
3904 refers to. */
3908 else
3911 /* Try to verify that the destination is big enough for the shortest
3912 string. First try to determine the size of the destination object
3913 into which the source is being copied. */
3916 /* Add one for the terminating nul. */
3919 size_one_node)
3922 /* Strncat copies at most MAXLEN bytes and always appends the terminating
3923 nul so the specified upper bound should never be equal to (or greater
3924 than) the size of the destination. */
3927 {
3936 }
3944 /* The number of bytes to write is LEN but check_sizes will also
3945 check SRCLEN if LEN's value isn't known. */
3950 }
3952 /* Expand expression EXP, which is a call to the strncpy builtin. Return
3953 NULL_RTX if we failed the caller should emit a normal call. */
3955 static rtx
3957 {
3962 {
3965 /* The number of bytes to write (not the maximum). */
3967 /* The length of the source sequence. */
3971 {
3975 /* The number of bytes to write is LEN but check_sizes will also
3976 check SLEN if LEN's value isn't known. */
3979 }
3981 /* We must be passed a constant len and src parameter. */
3987 /* We're required to pad with trailing zeros if the requested
3988 len is greater than strlen(s2)+1. In that case try to
3989 use store_by_pieces, if it fails, punt. */
3991 {
3994 rtx dest_mem;
3998 builtin_strncpy_read_str,
4005 builtin_strncpy_read_str,
4010 }
4011 }
4013 }
4015 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
4016 bytes from constant string DATA + OFFSET and return it as target
4017 constant. */
4019 rtx
4021 machine_mode mode)
4022 {
4029 }
4031 /* Callback routine for store_by_pieces. Return the RTL of a register
4032 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
4033 char value given in the RTL register data. For example, if mode is
4034 4 bytes wide, return the RTL for 0x01010101*data. */
4036 static rtx
4038 machine_mode mode)
4039 {
4055 }
4057 /* Expand expression EXP, which is a call to the memset builtin. Return
4058 NULL_RTX if we failed the caller should emit a normal call, otherwise
4059 try to get the result in TARGET, if convenient (and in mode MODE if that's
4060 convenient). */
4062 static rtx
4064 {
4076 }
4078 /* Expand expression EXP, which is an instrumented call to the memset builtin.
4079 Return NULL_RTX if we failed the caller should emit a normal call, otherwise
4080 try to get the result in TARGET, if convenient (and in mode MODE if that's
4081 convenient). */
4083 static rtx
4085 {
4090 else
4091 {
4097 /* Return src bounds with the result. */
4099 {
4103 }
4105 }
4106 }
4108 /* Helper function to do the actual work for expand_builtin_memset. The
4109 arguments to the builtin_memset call DEST, VAL, and LEN are broken out
4110 so that this can also be called without constructing an actual CALL_EXPR.
4111 The other arguments and return value are the same as for
4112 expand_builtin_memset. */
4114 static rtx
4117 {
4120 machine_mode val_mode;
4132 /* If DEST is not a pointer type, don't do this operation in-line. */
4143 /* If the LEN parameter is zero, return DEST. */
4145 {
4146 /* Evaluate and ignore VAL in case it has side-effects. */
4149 }
4151 /* Stabilize the arguments in case we fail. */
4163 {
4164 rtx val_rtx;
4169 /* Assume that we can memset by pieces if we can store
4170 * the coefficients by pieces (in the required modes).
4171 * We can't pass builtin_memset_gen_str as that emits RTL. */
4177 {
4182 }
4186 probable_max_size))
4192 }
4198 {
4209 probable_max_size))
4215 }
4223 probable_max_size);
4226 {
4229 }
4233 do_libcall:
4243 else
4248 }
4250 /* Expand expression EXP, which is a call to the bzero builtin. Return
4251 NULL_RTX if we failed the caller should emit a normal call. */
4253 static rtx
4255 {
4264 /* New argument list transforming bzero(ptr x, int y) to
4265 memset(ptr x, int 0, size_t y). This is done this way
4266 so that if it isn't expanded inline, we fallback to
4267 calling bzero instead of memset. */
4275 }
4277 /* Try to expand cmpstr operation ICODE with the given operands.
4278 Return the result rtx on success, otherwise return null. */
4280 static rtx
4282 HOST_WIDE_INT align)
4283 {
4297 }
4299 /* Expand expression EXP, which is a call to the memcmp built-in function.
4300 Return NULL_RTX if we failed and the caller should emit a normal call,
4301 otherwise try to get the result in TARGET, if convenient.
4302 RESULT_EQ is true if we can relax the returned value to be either zero
4303 or nonzero, without caring about the sign. */
4305 static rtx
4307 {
4316 /* Diagnose calls where the specified length exceeds the size of either
4317 object. */
4319 {
4324 {
4329 }
4330 }
4338 /* If we don't have POINTER_TYPE, call the function. */
4346 /* Set MEM_SIZE as appropriate. */
4348 {
4351 }
4357 {
4361 }
4363 /* If SRC is a string constant and block move would be done
4364 by pieces, we can avoid loading the string from memory
4365 and only stored the computed constants. */
4377 {
4378 /* Return the value in the proper mode for this function. */
4383 {
4386 }
4389 }
4392 }
4394 /* Expand expression EXP, which is a call to the strcmp builtin. Return NULL_RTX
4395 if we failed the caller should emit a normal call, otherwise try to get
4396 the result in TARGET, if convenient. */
4398 static rtx
4400 {
4407 {
4417 /* If we don't have POINTER_TYPE, call the function. */
4421 /* Stabilize the arguments in case gen_cmpstr(n)si fail. */
4428 /* Try to call cmpstrsi. */
4433 /* Try to determine at least one length and call cmpstrnsi. */
4435 {
4436 tree len;
4437 rtx arg3_rtx;
4447 /* If we don't have a constant length for the first, use the length
4448 of the second, if we know it. We don't require a constant for
4449 this case; some cost analysis could be done if both are available
4450 but neither is constant. For now, assume they're equally cheap,
4451 unless one has side effects. If both strings have constant lengths,
4452 use the smaller. */
4468 else
4471 /* If both arguments have side effects, we cannot optimize. */
4473 {
4475 result = expand_cmpstrn_or_cmpmem
4478 }
4479 }
4482 {
4483 /* Return the value in the proper mode for this function. */
4491 }
4493 /* Expand the library call ourselves using a stabilized argument
4494 list to avoid re-evaluating the function's arguments twice. */
4500 }
4502 }
4504 /* Expand expression EXP, which is a call to the strncmp builtin. Return
4505 NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
4506 the result in TARGET, if convenient. */
4508 static rtx
4510 ATTRIBUTE_UNUSED machine_mode mode)
4511 {
4518 /* If c_strlen can determine an expression for one of the string
4519 lengths, and it doesn't have side effects, then emit cmpstrnsi
4520 using length MIN(strlen(string)+1, arg3). */
4523 {
4526 rtx result;
4545 /* If we don't have a constant length for the first, use the length
4546 of the second, if we know it. If neither string is constant length,
4547 use the given length argument. We don't require a constant for
4548 this case; some cost analysis could be done if both are available
4549 but neither is constant. For now, assume they're equally cheap,
4550 unless one has side effects. If both strings have constant lengths,
4551 use the smaller. */
4569 else
4572 /* If we are not using the given length, we must incorporate it here.
4573 The actual new length parameter will be MIN(len,arg3) in this case. */
4583 {
4584 /* Return the value in the proper mode for this function. */
4592 }
4594 /* Expand the library call ourselves using a stabilized argument
4595 list to avoid re-evaluating the function's arguments twice. */
4602 }
4604 }
4606 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4607 if that's convenient. */
4609 rtx
4611 {
4612 rtx val;
4615 /* Don't do __builtin_saveregs more than once in a function.
4616 Save the result of the first call and reuse it. */
4620 /* When this function is called, it means that registers must be
4621 saved on entry to this function. So we migrate the call to the
4622 first insn of this function. */
4626 /* Do whatever the machine needs done in this case. */
4634 /* Put the insns after the NOTE that starts the function. If this
4635 is inside a start_sequence, make the outer-level insn chain current, so
4636 the code is placed at the start of the function. */
4642 }
4644 /* Expand a call to __builtin_next_arg. */
4646 static rtx
4648 {
4649 /* Checking arguments is already done in fold_builtin_next_arg
4650 that must be called before this function. */
4655 }
4657 /* Make it easier for the backends by protecting the valist argument
4658 from multiple evaluations. */
4660 static tree
4662 {
4665 /* The current way of determining the type of valist is completely
4666 bogus. We should have the information on the va builtin instead. */
4671 {
4675 /* For this case, the backends will be expecting a pointer to
4676 vatype, but it's possible we've actually been given an array
4677 (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4678 So fix it. */
4680 {
4683 }
4684 }
4685 else
4686 {
4690 {
4696 }
4702 }
4705 }
4707 /* The "standard" definition of va_list is void*. */
4709 tree
4711 {
4713 }
4715 /* The "standard" abi va_list is va_list_type_node. */
4717 tree
4719 {
4721 }
4723 /* The "standard" type of va_list is va_list_type_node. */
4725 tree
4727 {
4734 {
4735 /* If va_list is an array type, the argument may have decayed
4736 to a pointer type, e.g. by being passed to another function.
4737 In that case, unwrap both types so that we can compare the
4738 underlying records. */
4741 {
4744 }
4745 }
4750 }
4752 /* The "standard" implementation of va_start: just assign `nextarg' to
4753 the variable. */
4755 void
4757 {
4761 /* We do not have any valid bounds for the pointer, so
4762 just store zero bounds for it. */
4766 nextarg));
4767 }
4769 /* Expand EXP, a call to __builtin_va_start. */
4771 static rtx
4773 {
4774 rtx nextarg;
4775 tree valist;
4779 {
4782 }
4792 else
4796 }
4798 /* Expand EXP, a call to __builtin_va_end. */
4800 static rtx
4802 {
4805 /* Evaluate for side effects, if needed. I hate macros that don't
4806 do that. */
4811 }
4813 /* Expand EXP, a call to __builtin_va_copy. We do this as a
4814 builtin rather than just as an assignment in stdarg.h because of the
4815 nastiness of array-type va_list types. */
4817 static rtx
4819 {
4832 {
4836 }
4837 else
4838 {
4841 /* Evaluate to pointers. */
4850 /* "Dereference" to BLKmode memories. */
4858 /* Copy. */
4860 }
4863 }
4865 /* Expand a call to one of the builtin functions __builtin_frame_address or
4866 __builtin_return_address. */
4868 static rtx
4870 {
4871 /* The argument must be a nonnegative integer constant.
4872 It counts the number of frames to scan up the stack.
4873 The value is either the frame pointer value or the return
4874 address saved in that frame. */
4876 /* Warning about missing arg was already issued. */
4879 {
4882 }
4883 else
4884 {
4885 /* Number of frames to scan up the stack. */
4890 /* Some ports cannot access arbitrary stack frames. */
4892 {
4895 }
4898 {
4899 /* Warn since no effort is made to ensure that any frame
4900 beyond the current one exists or can be safely reached. */
4903 }
4905 /* For __builtin_frame_address, return what we've got. */
4913 }
4914 }
4916 /* Expand EXP, a call to the alloca builtin. Return NULL_RTX if we
4917 failed and the caller should emit a normal call. CANNOT_ACCUMULATE
4918 is the same as for allocate_dynamic_stack_space. */
4920 static rtx
4922 {
4923 rtx op0;
4924 rtx result;
4930 bool valid_arglist
4931 = (alloca_with_align
4940 {
4941 /* -Walloca-larger-than and -Wvla-larger-than settings override
4942 the more general -Walloc-size-larger-than so unless either of
4943 the former options is specified check the alloca arguments for
4944 overflow. */
4948 }
4950 /* Compute the argument. */
4953 /* Compute the alignment. */
4954 align = (alloca_with_align
4958 /* Allocate the desired space. */
4963 }
4965 /* Expand a call to bswap builtin in EXP.
4966 Return NULL_RTX if a normal call should be emitted rather than expanding the
4967 function in-line. If convenient, the result should be placed in TARGET.
4968 SUBTARGET may be used as the target for computing one of EXP's operands. */
4970 static rtx
4972 rtx subtarget)
4973 {
4974 tree arg;
4975 rtx op0;
4993 }
4995 /* Expand a call to a unary builtin in EXP.
4996 Return NULL_RTX if a normal call should be emitted rather than expanding the
4997 function in-line. If convenient, the result should be placed in TARGET.
4998 SUBTARGET may be used as the target for computing one of EXP's operands. */
5000 static rtx
5003 {
5004 rtx op0;
5009 /* Compute the argument. */
5011 (subtarget
5015 /* Compute op, into TARGET if possible.
5016 Set TARGET to wherever the result comes back. */
5022 }
5024 /* Expand a call to __builtin_expect. We just return our argument
5025 as the builtin_expect semantic should've been already executed by
5026 tree branch prediction pass. */
5028 static rtx
5030 {
5031 tree arg;
5038 /* When guessing was done, the hints should be already stripped away. */
5042 }
5044 /* Expand a call to __builtin_assume_aligned. We just return our first
5045 argument as the builtin_assume_aligned semantic should've been already
5046 executed by CCP. */
5048 static rtx
5050 {
5054 EXPAND_NORMAL);
5059 }
5061 void
5063 {
5065 {
5067 /* For trap insns when not accumulating outgoing args force
5068 REG_ARGS_SIZE note to prevent crossjumping of calls with
5069 different args sizes. */
5072 }
5073 else
5074 {
5078 }
5081 }
5083 /* Expand a call to __builtin_unreachable. We do nothing except emit
5084 a barrier saying that control flow will not pass here.
5086 It is the responsibility of the program being compiled to ensure
5087 that control flow does never reach __builtin_unreachable. */
5088 static void
5090 {
5092 }
5094 /* Expand EXP, a call to fabs, fabsf or fabsl.
5095 Return NULL_RTX if a normal call should be emitted rather than expanding
5096 the function inline. If convenient, the result should be placed
5097 in TARGET. SUBTARGET may be used as the target for computing
5098 the operand. */
5100 static rtx
5102 {
5103 machine_mode mode;
5104 tree arg;
5105 rtx op0;
5115 }
5117 /* Expand EXP, a call to copysign, copysignf, or copysignl.
5118 Return NULL is a normal call should be emitted rather than expanding the
5119 function inline. If convenient, the result should be placed in TARGET.
5120 SUBTARGET may be used as the target for computing the operand. */
5122 static rtx
5124 {
5126 tree arg;
5138 }
5140 /* Expand a call to __builtin___clear_cache. */
5142 static rtx
5144 {
5146 {
5147 #ifdef CLEAR_INSN_CACHE
5148 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5149 does something. Just do the default expansion to a call to
5150 __clear_cache(). */
5152 #else
5153 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5154 does nothing. There is no need to call it. Do nothing. */
5157 }
5159 /* We have a "clear_cache" insn, and it will handle everything. */
5163 /* We must not expand to a library call. If we did, any
5164 fallback library function in libgcc that might contain a call to
5165 __builtin___clear_cache() would recurse infinitely. */
5167 {
5170 }
5173 {
5186 }
5188 }
5190 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */
5192 static rtx
5194 {
5197 /* If we don't need too much alignment, we'll have been guaranteed
5198 proper alignment by get_trampoline_type. */
5202 /* Round address up to desired boundary. */
5213 }
5215 static rtx
5217 {
5233 /* If ONSTACK, the TRAMP argument should be the address of a field
5234 within the local function's FRAME decl. Either way, let's see if
5235 we can fill in the MEM_ATTRs for this memory. */
5239 /* Creator of a heap trampoline is responsible for making sure the
5240 address is aligned to at least STACK_BOUNDARY. Normally malloc
5241 will ensure this anyhow. */
5244 {
5248 }
5250 /* The FUNC argument should be the address of the nested function.
5251 Extract the actual function decl to pass to the hook. */
5258 /* Generate insns to initialize the trampoline. */
5262 {
5268 }
5271 }
5273 static rtx
5275 {
5276 rtx tramp;
5287 }
5289 /* Expand a call to the builtin descriptor initialization routine.
5290 A descriptor is made up of a couple of pointers to the static
5291 chain and the code entry in this order. */
5293 static rtx
5295 {
5300 VOID_TYPE))
5314 /* Generate insns to initialize the descriptor. */
5320 }
5322 /* Expand a call to the builtin descriptor adjustment routine. */
5324 static rtx
5326 {
5327 rtx tramp;
5334 /* Unalign the descriptor to allow runtime identification. */
5339 }
5341 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
5342 function. The function first checks whether the back end provides
5343 an insn to implement signbit for the respective mode. If not, it
5344 checks whether the floating point format of the value is such that
5345 the sign bit can be extracted. If that is not the case, error out.
5346 EXP is the expression that is a call to the builtin function; if
5347 convenient, the result should be placed in TARGET. */
5348 static rtx
5350 {
5353 tree arg;
5356 rtx temp;
5369 /* Expand the argument yielding a RTX expression. */
5372 /* Check if the back end provides an insn that handles signbit for the
5373 argument's mode. */
5376 {
5382 }
5384 /* For floating point formats without a sign bit, implement signbit
5385 as "ARG < 0.0". */
5388 {
5389 /* But we can't do this if the format supports signed zero. */
5395 }
5398 {
5402 }
5403 else
5404 {
5406 /* Handle targets with different FP word orders. */
5409 else
5413 }
5415 /* Force the intermediate word_mode (or narrower) result into a
5416 register. This avoids attempting to create paradoxical SUBREGs
5417 of floating point modes below. */
5420 /* If the bitpos is within the "result mode" lowpart, the operation
5421 can be implement with a single bitwise AND. Otherwise, we need
5422 a right shift and an AND. */
5425 {
5433 }
5434 else
5435 {
5436 /* Perform a logical right shift to place the signbit in the least
5437 significant bit, then truncate the result to the desired mode
5438 and mask just this bit. */
5443 }
5446 }
5448 /* Expand fork or exec calls. TARGET is the desired target of the
5449 call. EXP is the call. FN is the
5450 identificator of the actual function. IGNORE is nonzero if the
5451 value is to be ignored. */
5453 static rtx
5455 {
5457 tree call;
5459 /* If we are not profiling, just call the function. */
5463 /* Otherwise call the wrapper. This should be equivalent for the rest of
5464 compiler, so the code does not diverge, and the wrapper may run the
5465 code necessary for keeping the profiling sane. */
5468 {
5499 }
5511 }
5514 \f
5515 /* Reconstitute a mode for a __sync intrinsic operation. Since the type of
5516 the pointer in these functions is void*, the tree optimizers may remove
5517 casts. The mode computed in expand_builtin isn't reliable either, due
5518 to __sync_bool_compare_and_swap.
5520 FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5521 group of builtins. This gives us log2 of the mode size. */
5525 {
5526 /* The size is not negotiable, so ask not to get BLKmode in return
5527 if the target indicates that a smaller size would be better. */
5529 }
5531 /* Expand the memory expression LOC and return the appropriate memory operand
5532 for the builtin_sync operations. */
5534 static rtx
5536 {
5542 /* Note that we explicitly do not want any alias information for this
5543 memory, so that we kill all other live memories. Otherwise we don't
5544 satisfy the full barrier semantics of the intrinsic. */
5547 /* The alignment needs to be at least according to that of the mode. */
5554 }
5556 /* Make sure an argument is in the right mode.
5557 EXP is the tree argument.
5558 MODE is the mode it should be in. */
5560 static rtx
5562 {
5563 rtx val;
5564 machine_mode old_mode;
5567 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5568 of CONST_INTs, where we know the old_mode only from the call argument. */
5575 }
5578 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5579 EXP is the CALL_EXPR. CODE is the rtx code
5580 that corresponds to the arithmetic or logical operation from the name;
5581 an exception here is that NOT actually means NAND. TARGET is an optional
5582 place for us to store the results; AFTER is true if this is the
5583 fetch_and_xxx form. */
5585 static rtx
5588 rtx target)
5589 {
5594 {
5601 {
5630 }
5631 }
5633 /* Expand the operands. */
5638 after);
5639 }
5641 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5642 intrinsics. EXP is the CALL_EXPR. IS_BOOL is
5643 true if this is the boolean form. TARGET is a place for us to store the
5644 results; this is NOT optional if IS_BOOL is true. */
5646 static rtx
5649 {
5653 /* Expand the operands. */
5660 {
5663 else
5665 }
5668 MEMMODEL_SYNC_SEQ_CST))
5672 }
5674 /* Expand the __sync_lock_test_and_set intrinsic. Note that the most
5675 general form is actually an atomic exchange, and some targets only
5676 support a reduced form with the second argument being a constant 1.
5677 EXP is the CALL_EXPR; TARGET is an optional place for us to store
5678 the results. */
5680 static rtx
5682 rtx target)
5683 {
5686 /* Expand the operands. */
5691 }
5693 /* Expand the __sync_lock_release intrinsic. EXP is the CALL_EXPR. */
5695 static void
5697 {
5698 rtx mem;
5700 /* Expand the operands. */
5704 }
5706 /* Given an integer representing an ``enum memmodel'', verify its
5707 correctness and return the memory model enum. */
5709 static enum memmodel
5711 {
5712 rtx op;
5714 source_location loc
5717 /* If the parameter is not a constant, it's a run time value so we'll just
5718 convert it to MEMMODEL_SEQ_CST to avoid annoying runtime checking. */
5728 {
5732 }
5734 /* Should never see a user explicit SYNC memodel model, so >= LAST works. */
5736 {
5740 }
5742 /* Workaround for Bugzilla 59448. GCC doesn't track consume properly, so
5743 be conservative and promote consume to acquire. */
5748 }
5750 /* Expand the __atomic_exchange intrinsic:
5751 TYPE __atomic_exchange (TYPE *object, TYPE desired, enum memmodel)
5752 EXP is the CALL_EXPR.
5753 TARGET is an optional place for us to store the results. */
5755 static rtx
5757 {
5766 /* Expand the operands. */
5771 }
5773 /* Expand the __atomic_compare_exchange intrinsic:
5774 bool __atomic_compare_exchange (TYPE *object, TYPE *expect,
5775 TYPE desired, BOOL weak,
5776 enum memmodel success,
5777 enum memmodel failure)
5778 EXP is the CALL_EXPR.
5779 TARGET is an optional place for us to store the results. */
5781 static rtx
5783 rtx target)
5784 {
5788 tree weak;
5790 source_location loc
5797 {
5799 "failure memory model cannot be stronger than success "
5802 }
5805 {
5807 "invalid failure memory model for "
5811 }
5817 /* Expand the operands. */
5833 /* Lest the rtl backend create a race condition with an imporoper store
5834 to memory, always create a new pseudo for OLDVAL. */
5841 /* Conditionally store back to EXPECT, lest we create a race condition
5842 with an improper store to memory. */
5843 /* ??? With a rearrangement of atomics at the gimple level, we can handle
5844 the normal case where EXPECT is totally private, i.e. a register. At
5845 which point the store can be unconditional. */
5853 }
5855 /* Helper function for expand_ifn_atomic_compare_exchange - expand
5856 internal ATOMIC_COMPARE_EXCHANGE call into __atomic_compare_exchange_N
5857 call. The weak parameter must be dropped to match the expected parameter
5858 list and the expected argument changed from value to pointer to memory
5859 slot. */
5861 static void
5863 {
5879 /* Skip the boolean weak parameter. */
5882 built_in_function fncode
5887 fndecl);
5892 {
5899 }
5900 }
5902 /* Expand IFN_ATOMIC_COMPARE_EXCHANGE internal function. */
5904 void
5906 {
5912 tree lhs;
5914 source_location loc
5921 {
5923 "failure memory model cannot be stronger than success "
5926 }
5929 {
5931 "invalid failure memory model for "
5935 }
5938 {
5941 }
5943 /* Expand the operands. */
5956 {
5959 }
5963 {
5969 }
5970 }
5972 /* Expand the __atomic_load intrinsic:
5973 TYPE __atomic_load (TYPE *object, enum memmodel)
5974 EXP is the CALL_EXPR.
5975 TARGET is an optional place for us to store the results. */
5977 static rtx
5979 {
5980 rtx mem;
5985 {
5986 source_location loc
5991 }
5996 /* Expand the operand. */
6000 }
6003 /* Expand the __atomic_store intrinsic:
6004 void __atomic_store (TYPE *object, TYPE desired, enum memmodel)
6005 EXP is the CALL_EXPR.
6006 TARGET is an optional place for us to store the results. */
6008 static rtx
6010 {
6017 {
6018 source_location loc
6023 }
6028 /* Expand the operands. */
6033 }
6035 /* Expand the __atomic_fetch_XXX intrinsic:
6036 TYPE __atomic_fetch_XXX (TYPE *object, TYPE val, enum memmodel)
6037 EXP is the CALL_EXPR.
6038 TARGET is an optional place for us to store the results.
6039 CODE is the operation, PLUS, MINUS, ADD, XOR, or IOR.
6040 FETCH_AFTER is true if returning the result of the operation.
6041 FETCH_AFTER is false if returning the value before the operation.
6042 IGNORE is true if the result is not used.
6043 EXT_CALL is the correct builtin for an external call if this cannot be
6044 resolved to an instruction sequence. */
6046 static rtx
6050 {
6053 tree fndecl;
6054 tree addr;
6058 /* Expand the operands. */
6062 /* Only try generating instructions if inlining is turned on. */
6064 {
6068 }
6070 /* Return if a different routine isn't needed for the library call. */
6074 /* Change the call to the specified function. */
6082 /* Expand the call here so we can emit trailing code. */
6085 /* Replace the original function just in case it matters. */
6088 /* Then issue the arithmetic correction to return the right result. */
6090 {
6092 {
6094 OPTAB_LIB_WIDEN);
6096 }
6097 else
6099 OPTAB_LIB_WIDEN);
6100 }
6102 }
6104 /* Expand IFN_ATOMIC_BIT_TEST_AND_* internal function. */
6106 void
6108 {
6116 optab optab;
6128 {
6143 }
6146 {
6153 }
6175 {
6180 }
6181 else
6183 OPTAB_DIRECT);
6186 }
6188 /* Expand an atomic clear operation.
6189 void _atomic_clear (BOOL *obj, enum memmodel)
6190 EXP is the call expression. */
6192 static rtx
6194 {
6195 machine_mode mode;
6204 {
6205 source_location loc
6210 }
6212 /* Try issuing an __atomic_store, and allow fallback to __sync_lock_release.
6213 Failing that, a store is issued by __atomic_store. The only way this can
6214 fail is if the bool type is larger than a word size. Unlikely, but
6215 handle it anyway for completeness. Assume a single threaded model since
6216 there is no atomic support in this case, and no barriers are required. */
6221 }
6223 /* Expand an atomic test_and_set operation.
6224 bool _atomic_test_and_set (BOOL *obj, enum memmodel)
6225 EXP is the call expression. */
6227 static rtx
6229 {
6230 rtx mem;
6232 machine_mode mode;
6239 }
6242 /* Return true if (optional) argument ARG1 of size ARG0 is always lock free on
6243 this architecture. If ARG1 is NULL, use typical alignment for size ARG0. */
6245 static tree
6247 {
6249 machine_mode mode;
6260 {
6263 /* Either this argument is null, or it's a fake pointer encoding
6264 the alignment of the object. */
6270 else
6272 }
6273 else
6274 {
6277 /* This function is usually invoked and folded immediately by the front
6278 end before anything else has a chance to look at it. The pointer
6279 parameter at this point is usually cast to a void *, so check for that
6280 and look past the cast. */
6290 /* Get the underlying type of the object. */
6293 }
6295 /* If the object has smaller alignment, the lock free routines cannot
6296 be used. */
6300 /* Check if a compare_and_swap pattern exists for the mode which represents
6301 the required size. The pattern is not allowed to fail, so the existence
6302 of the pattern indicates support is present. Also require that an
6303 atomic load exists for the required size. */
6306 else
6308 }
6310 /* Return true if the parameters to call EXP represent an object which will
6311 always generate lock free instructions. The first argument represents the
6312 size of the object, and the second parameter is a pointer to the object
6313 itself. If NULL is passed for the object, then the result is based on
6314 typical alignment for an object of the specified size. Otherwise return
6315 false. */
6317 static rtx
6319 {
6320 tree size;
6325 {
6328 }
6334 }
6336 /* Return a one or zero if it can be determined that object ARG1 of size ARG
6337 is lock free on this architecture. */
6339 static tree
6341 {
6345 /* If it isn't always lock free, don't generate a result. */
6350 }
6352 /* Return true if the parameters to call EXP represent an object which will
6353 always generate lock free instructions. The first argument represents the
6354 size of the object, and the second parameter is a pointer to the object
6355 itself. If NULL is passed for the object, then the result is based on
6356 typical alignment for an object of the specified size. Otherwise return
6357 NULL*/
6359 static rtx
6361 {
6362 tree size;
6367 {
6370 }
6375 /* If the value is known at compile time, return the RTX for it. */
6381 }
6383 /* Expand the __atomic_thread_fence intrinsic:
6384 void __atomic_thread_fence (enum memmodel)
6385 EXP is the CALL_EXPR. */
6387 static void
6389 {
6392 }
6394 /* Expand the __atomic_signal_fence intrinsic:
6395 void __atomic_signal_fence (enum memmodel)
6396 EXP is the CALL_EXPR. */
6398 static void
6400 {
6403 }
6405 /* Expand the __sync_synchronize intrinsic. */
6407 static void
6409 {
6411 }
6413 static rtx
6415 {
6421 {
6423 /* If the target is not sutitable then create a new target. */
6431 }
6434 }
6436 static void
6438 {
6444 {
6451 }
6453 }
6455 \f
6456 /* Emit code to restore the current value of stack. */
6458 static void
6460 {
6472 }
6474 /* Emit code to save the current value of stack. */
6476 static rtx
6478 {
6483 }
6486 /* Expand an expression EXP that calls a built-in function,
6487 with result going to TARGET if that's convenient
6488 (and in mode MODE if that's convenient).
6489 SUBTARGET may be used as the target for computing one of EXP's operands.
6490 IGNORE is nonzero if the value is to be ignored. */
6492 rtx
6495 {
6504 /* When ASan is enabled, we don't want to expand some memory/string
6505 builtins and rely on libsanitizer's hooks. This allows us to avoid
6506 redundant checks and be sure, that possible overflow will be detected
6507 by ASan. */
6512 /* When not optimizing, generate calls to library functions for a certain
6513 set of builtins. */
6540 /* The built-in function expanders test for target == const0_rtx
6541 to determine whether the function's result will be ignored. */
6545 /* If the result of a pure or const built-in function is ignored, and
6546 none of its arguments are volatile, we can avoid expanding the
6547 built-in call and just evaluate the arguments for side-effects. */
6551 {
6553 tree arg;
6554 call_expr_arg_iterator iter;
6558 {
6561 }
6564 {
6568 }
6569 }
6571 /* expand_builtin_with_bounds is supposed to be used for
6572 instrumented builtin calls. */
6576 {
6594 /* Just do a normal library call if we were unable to fold
6595 the values. */
6671 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
6672 FUNCTION with a copy of the parameters described by
6673 ARGUMENTS, and ARGSIZE. It returns a block of memory
6674 allocated on the stack into which is stored all the registers
6675 that might possibly be used for returning the result of a
6676 function. ARGUMENTS is the value returned by
6677 __builtin_apply_args. ARGSIZE is the number of bytes of
6678 arguments that must be copied. ??? How should this value be
6679 computed? We'll also need a safe worst case value for varargs
6680 functions. */
6687 else
6688 {
6696 }
6698 /* __builtin_return (RESULT) causes the function to return the
6699 value described by RESULT. RESULT is address of the block of
6700 memory returned by __builtin_apply. */
6710 /* All valid uses of __builtin_va_arg_pack () are removed during
6711 inlining. */
6716 /* All valid uses of __builtin_va_arg_pack_len () are removed during
6717 inlining. */
6721 /* Return the address of the first anonymous stack arg. */
6743 /* Returns the address of the area where the structure is returned.
6744 0 otherwise. */
6750 else
6755 /* If the allocation stems from the declaration of a variable-sized
6756 object, it cannot accumulate. */
6916 {
6919 }
6923 /* This should have been lowered to the builtins below. */
6927 /* __builtin_setjmp_setup is passed a pointer to an array of five words
6928 and the receiver label. */
6930 {
6936 /* This is copied from the handling of non-local gotos. */
6938 nonlocal_goto_handler_labels
6940 nonlocal_goto_handler_labels);
6941 /* ??? Do not let expand_label treat us as such since we would
6942 not want to be both on the list of non-local labels and on
6943 the list of forced labels. */
6946 }
6950 /* __builtin_setjmp_receiver is passed the receiver label. */
6952 {
6958 }
6961 /* __builtin_longjmp is passed a pointer to an array of five words.
6962 It's similar to the C library longjmp function but works with
6963 __builtin_setjmp above. */
6966 {
6972 {
6975 }
6979 }
6988 /* This updates the setjmp buffer that is its argument with the value
6989 of the current stack pointer. */
6992 {
6993 rtx buf_addr
6998 }
7018 /* Various hooks for the DWARF 2 __throw routine. */
7024 #ifdef DWARF2_UNWIND_INFO
7030 #endif
7230 mode = get_builtin_sync_mode
7242 mode = get_builtin_sync_mode
7289 {
7293 mode =
7299 /* If this is turned into an external library call, the weak parameter
7300 must be dropped to match the expected parameter list. */
7305 /* Skip the boolean weak parameter. */
7310 }
7339 {
7349 }
7355 {
7365 }
7371 {
7381 }
7387 {
7397 }
7403 {
7413 }
7419 {
7429 }
7584 /* We allow user CHKP builtins if Pointer Bounds
7585 Checker is off. */
7587 {
7598 else
7600 }
7601 /* FALLTHROUGH */
7613 /* Software implementation of Pointer Bounds Checker is NYI.
7614 Target support is required. */
7619 /* Do library call, if we failed to expand the builtin when
7620 folding. */
7625 }
7627 /* The switch statement above can drop through to cause the function
7628 to be called normally. */
7630 }
7632 /* Similar to expand_builtin but is used for instrumented calls. */
7634 rtx
7636 rtx subtarget ATTRIBUTE_UNUSED,
7638 {
7651 {
7672 }
7674 /* The switch statement above can drop through to cause the function
7675 to be called normally. */
7677 }
7679 /* Determine whether a tree node represents a call to a built-in
7680 function. If the tree T is a call to a built-in function with
7681 the right number of arguments of the appropriate types, return
7682 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
7683 Otherwise the return value is END_BUILTINS. */
7685 enum built_in_function
7687 {
7690 const_call_expr_arg_iterator iter;
7706 {
7707 /* If a function doesn't take a variable number of arguments,
7708 the last element in the list will have type `void'. */
7711 {
7715 }
7724 {
7727 }
7729 {
7732 }
7734 {
7737 }
7739 {
7742 }
7743 else
7745 }
7747 /* Variable-length argument list. */
7749 }
7751 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
7752 evaluate to a constant. */
7754 static tree
7756 {
7757 /* We return 1 for a numeric type that's known to be a constant
7758 value at compile-time or for an aggregate type that's a
7759 literal constant. */
7762 /* If we know this is a constant, emit the constant of one. */
7768 {
7775 }
7777 /* If this expression has side effects, show we don't know it to be a
7778 constant. Likewise if it's a pointer or aggregate type since in
7779 those case we only want literals, since those are only optimized
7780 when generating RTL, not later.
7781 And finally, if we are compiling an initializer, not code, we
7782 need to return a definite result now; there's not going to be any
7783 more optimization done. */
7788 || folding_initializer
7793 }
7795 /* Create builtin_expect with PRED and EXPECTED as its arguments and
7796 return it as a truthvalue. */
7798 static tree
7800 tree predictor)
7801 {
7813 predictor);
7817 }
7819 /* Fold a call to builtin_expect with arguments ARG0 and ARG1. Return
7820 NULL_TREE if no simplification is possible. */
7822 tree
7824 {
7828 /* Distribute the expected value over short-circuiting operators.
7829 See through the cast from truthvalue_type_node to long. */
7836 /* If this is a builtin_expect within a builtin_expect keep the
7837 inner one. See through a comparison against a constant. It
7838 might have been added to create a thruthvalue. */
7854 {
7863 }
7865 /* If the argument isn't invariant then there's nothing else we can do. */
7869 /* If we expect that a comparison against the argument will fold to
7870 a constant return the constant. In practice, this means a true
7871 constant or the address of a non-weak symbol. */
7875 {
7876 do
7877 {
7879 }
7884 }
7886 /* Otherwise, ARG0 already has the proper type for the return value. */
7888 }
7890 /* Fold a call to __builtin_classify_type with argument ARG. */
7892 static tree
7894 {
7899 }
7901 /* Fold a call to __builtin_strlen with argument ARG. */
7903 static tree
7905 {
7908 else
7909 {
7916 }
7917 }
7919 /* Fold a call to __builtin_inf or __builtin_huge_val. */
7921 static tree
7923 {
7924 REAL_VALUE_TYPE real;
7926 /* __builtin_inff is intended to be usable to define INFINITY on all
7927 targets. If an infinity is not available, INFINITY expands "to a
7928 positive constant of type float that overflows at translation
7929 time", footnote "In this case, using INFINITY will violate the
7930 constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
7931 Thus we pedwarn to ensure this constraint violation is
7932 diagnosed. */
7938 }
7940 /* Fold function call to builtin sincos, sincosf, or sincosl. Return
7941 NULL_TREE if no simplification can be made. */
7943 static tree
7946 {
7947 tree type;
7957 /* Calculate the result when the argument is a constant. */
7962 /* Canonicalize sincos to cexpi. */
7964 {
7967 }
7969 {
7976 }
7985 }
7987 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
7988 Return NULL_TREE if no simplification can be made. */
7990 static tree
7992 {
7998 /* If the LEN parameter is zero, return zero. */
8003 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8007 /* If len parameter is one, return an expression corresponding to
8008 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
8010 {
8012 tree cst_uchar_ptr_node
8015 tree ind1
8019 cst_uchar_ptr_node,
8020 arg1)));
8021 tree ind2
8025 cst_uchar_ptr_node,
8026 arg2)));
8028 }
8031 }
8033 /* Fold a call to builtin isascii with argument ARG. */
8035 static tree
8037 {
8040 else
8041 {
8042 /* Transform isascii(c) -> ((c & ~0x7f) == 0). */
8048 }
8049 }
8051 /* Fold a call to builtin toascii with argument ARG. */
8053 static tree
8055 {
8059 /* Transform toascii(c) -> (c & 0x7f). */
8062 }
8064 /* Fold a call to builtin isdigit with argument ARG. */
8066 static tree
8068 {
8071 else
8072 {
8073 /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
8074 /* According to the C standard, isdigit is unaffected by locale.
8075 However, it definitely is affected by the target character set. */
8076 unsigned HOST_WIDE_INT target_digit0
8087 }
8088 }
8090 /* Fold a call to fabs, fabsf or fabsl with argument ARG. */
8092 static tree
8094 {
8100 }
8102 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG. */
8104 static tree
8106 {
8112 }
8114 /* Fold a call to fma, fmaf, or fmal with arguments ARG[012]. */
8116 static tree
8118 {
8119 /* ??? Only expand to FMA_EXPR if it's directly supported. */
8127 }
8129 /* Fold a call to builtin carg(a+bi) -> atan2(b,a). */
8131 static tree
8133 {
8136 {
8140 {
8145 }
8146 }
8149 }
8151 /* Fold a call to builtin frexp, we can assume the base is 2. */
8153 static tree
8155 {
8166 /* Proceed if a valid pointer type was passed in. */
8168 {
8173 {
8175 /* For +-0, return (*exp = 0, +-0). */
8181 /* For +-NaN or +-Inf, *exp is unspecified, return arg0. */
8184 {
8185 /* Since the frexp function always expects base 2, and in
8186 GCC normalized significands are already in the range
8187 [0.5, 1.0), we have exactly what frexp wants. */
8192 }
8196 }
8198 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
8202 }
8205 }
8207 /* Fold a call to builtin modf. */
8209 static tree
8211 {
8222 /* Proceed if a valid pointer type was passed in. */
8224 {
8229 {
8232 /* For +-NaN or +-0, return (*arg1 = arg0, arg0). */
8236 /* For +-Inf, return (*arg1 = arg0, +-0). */
8242 /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)). */
8245 /* If the original number was negative and already
8246 integral, then the fractional part is -0.0. */
8250 }
8252 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
8258 }
8261 }
8263 /* Given a location LOC, an interclass builtin function decl FNDECL
8264 and its single argument ARG, return an folded expression computing
8265 the same, or NULL_TREE if we either couldn't or didn't want to fold
8266 (the latter happen if there's an RTL instruction available). */
8268 static tree
8270 {
8271 machine_mode mode;
8283 /* If there is no optab, try generic code. */
8285 {
8286 tree result;
8289 {
8290 /* isinf(x) -> isgreater(fabs(x),DBL_MAX). */
8293 REAL_VALUE_TYPE r;
8297 {
8298 /* NaN and Inf are encoded in the high-order double value
8299 only. The low-order value is not significant. */
8303 }
8310 }
8313 {
8314 /* isfinite(x) -> islessequal(fabs(x),DBL_MAX). */
8317 REAL_VALUE_TYPE r;
8321 {
8322 /* NaN and Inf are encoded in the high-order double value
8323 only. The low-order value is not significant. */
8327 }
8333 /*result = fold_build2_loc (loc, UNGT_EXPR,
8334 TREE_TYPE (TREE_TYPE (fndecl)),
8335 fold_build1_loc (loc, ABS_EXPR, type, arg),
8336 build_real (type, r));
8337 result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
8338 TREE_TYPE (TREE_TYPE (fndecl)),
8339 result);*/
8341 }
8343 {
8344 /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
8345 islessequal(fabs(x),DBL_MAX). */
8355 {
8356 /* Use double to test the normal range of IBM extended
8357 precision. Emin for IBM extended precision is
8358 different to emin for IEEE double, being 53 higher
8359 since the low double exponent is at least 53 lower
8360 than the high double exponent. */
8364 }
8376 {
8377 /* Testing the high end of the range is done just using
8378 the high double, using the same test as isfinite().
8379 For the subnormal end of the range we first test the
8380 high double, then if its magnitude is equal to the
8381 limit of 0x1p-969, we test whether the low double is
8382 non-zero and opposite sign to the high double. */
8398 integer_type_node,
8404 }
8405 else
8406 {
8407 tree const isge_fn
8410 }
8414 }
8417 }
8420 }
8422 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
8423 ARG is the argument for the call. */
8425 static tree
8427 {
8434 {
8442 {
8443 /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
8444 /* In a boolean context, GCC will fold the inner COND_EXPR to
8445 1. So e.g. "if (isinf_sign(x))" would be folded to just
8446 "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
8454 {
8467 integer_zero_node);
8468 }
8471 }
8484 {
8487 {
8488 /* NaN and Inf are encoded in the high-order double value
8489 only. The low-order value is not significant. */
8491 }
8492 }
8498 }
8499 }
8501 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
8502 This builtin will generate code to return the appropriate floating
8503 point classification depending on the value of the floating point
8504 number passed in. The possible return values must be supplied as
8505 int arguments to the call in the following order: FP_NAN, FP_INFINITE,
8506 FP_NORMAL, FP_SUBNORMAL and FP_ZERO. The ellipses is for exactly
8507 one floating point argument which is "type generic". */
8509 static tree
8511 {
8514 machine_mode mode;
8515 REAL_VALUE_TYPE r;
8518 /* Verify the required arguments in the original call. */
8538 /* fpclassify(x) ->
8539 isnan(x) ? FP_NAN :
8540 (fabs(x) == Inf ? FP_INFINITE :
8541 (fabs(x) >= DBL_MIN ? FP_NORMAL :
8542 (x == 0 ? FP_ZERO : FP_SUBNORMAL))). */
8556 {
8562 }
8565 {
8568 }
8571 }
8573 /* Fold a call to an unordered comparison function such as
8574 __builtin_isgreater(). FNDECL is the FUNCTION_DECL for the function
8575 being called and ARG0 and ARG1 are the arguments for the call.
8576 UNORDERED_CODE and ORDERED_CODE are comparison codes that give
8577 the opposite of the desired result. UNORDERED_CODE is used
8578 for modes that can hold NaNs and ORDERED_CODE is used for
8579 the rest. */
8581 static tree
8585 {
8599 /* Choose the wider of two real types. */
8611 {
8615 }
8620 }
8622 /* Fold __builtin_{,s,u}{add,sub,mul}{,l,ll}_overflow, either into normal
8623 arithmetics if it can never overflow, or into internal functions that
8624 return both result of arithmetics and overflowed boolean flag in
8625 a complex integer result, or some other check for overflow.
8626 Similarly fold __builtin_{add,sub,mul}_overflow_p to just the overflow
8627 checking part of that. */
8629 static tree
8632 {
8634 /* The code of the expression corresponding to the type-generic
8635 built-in, or ERROR_MARK for the type-specific ones. */
8640 {
8643 /* FALLTHRU */
8646 /* FALLTHRU */
8657 /* FALLTHRU */
8660 /* FALLTHRU */
8671 /* FALLTHRU */
8674 /* FALLTHRU */
8685 }
8687 /* For the "generic" overloads, the first two arguments can have different
8688 types and the last argument determines the target type to use to check
8689 for overflow. The arguments of the other overloads all have the same
8690 type. */
8693 /* For the __builtin_{add,sub,mul}_overflow_p builtins, when the first two
8694 arguments are constant, attempt to fold the built-in call into a constant
8695 expression indicating whether or not it detected an overflow. */
8699 /* Perform the computation in the target type and check for overflow. */
8703 arg2);
8717 tree store
8720 }
8722 /* Fold a call to __builtin_FILE to a constant string. */
8726 {
8731 }
8733 /* Fold a call to __builtin_FUNCTION to a constant string. */
8737 {
8739 {
8742 }
8745 }
8747 /* Fold a call to __builtin_LINE to an integer constant. */
8751 {
8753 }
8755 /* Fold a call to built-in function FNDECL with 0 arguments.
8756 This function returns NULL_TREE if no simplification was possible. */
8758 static tree
8760 {
8764 {
8790 }
8792 }
8794 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
8795 This function returns NULL_TREE if no simplification was possible. */
8797 static tree
8799 {
8810 {
8812 {
8815 /* Gimplification will pull the CALL_EXPR for the builtin out of
8816 an if condition. When not optimizing, we'll not CSE it back.
8817 To avoid link error types of regressions, return false now. */
8822 }
8878 {
8883 }
8889 {
8894 }
8915 }
8919 }
8921 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
8922 This function returns NULL_TREE if no simplification was possible. */
8924 static tree
8926 {
8938 {
8982 NOP_EXPR);
8984 /* We do the folding for va_start in the expander. */
8999 }
9001 }
9003 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
9004 and ARG2.
9005 This function returns NULL_TREE if no simplification was possible. */
9007 static tree
9010 {
9024 {
9074 }
9076 }
9078 /* Fold a call to built-in function FNDECL. ARGS is an array of NARGS
9079 arguments. IGNORE is true if the result of the
9080 function call is ignored. This function returns NULL_TREE if no
9081 simplification was possible. */
9083 tree
9085 {
9089 {
9105 }
9107 {
9112 }
9114 }
9116 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
9117 list ARGS along with N new arguments in NEWARGS. SKIP is the number
9118 of arguments in ARGS to be omitted. OLDNARGS is the number of
9119 elements in ARGS. */
9121 static tree
9124 {
9129 {
9137 }
9138 else
9142 }
9144 /* Return true if FNDECL shouldn't be folded right now.
9145 If a built-in function has an inline attribute always_inline
9146 wrapper, defer folding it after always_inline functions have
9147 been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
9148 might not be performed. */
9150 bool
9152 {
9155 && cfun
9158 }
9160 /* A wrapper function for builtin folding that prevents warnings for
9161 "statement without effect" and the like, caused by removing the
9162 call node earlier than the warning is generated. */
9164 tree
9166 {
9172 /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
9173 yet. Defer folding until we see all the arguments
9174 (after inlining). */
9176 {
9179 /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
9180 instead last argument is __builtin_va_arg_pack (). Defer folding
9181 even in that case, until arguments are finalized. */
9183 {
9190 }
9198 else
9199 {
9204 }
9205 }
9207 }
9209 /* Fold a CALL_EXPR with type TYPE with FN as the function expression.
9210 N arguments are passed in the array ARGARRAY. Return a folded
9211 expression or NULL_TREE if no simplification was possible. */
9213 tree
9215 tree fn,
9218 {
9225 {
9226 /* If last argument is __builtin_va_arg_pack (), arguments to this
9227 function are not finalized yet. Defer folding until they are. */
9229 {
9236 }
9241 else
9243 }
9246 }
9248 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
9249 along with N new arguments specified as the "..." parameters. SKIP
9250 is the number of arguments in EXP to be omitted. This function is used
9251 to do varargs-to-varargs transformations. */
9253 static tree
9255 {
9257 tree t;
9265 }
9267 /* Validate a single argument ARG against a tree code CODE representing
9268 a type. Return true when argument is valid. */
9270 static bool
9272 {
9280 }
9282 /* This function validates the types of a function call argument list
9283 against a specified list of tree_codes. If the last specifier is a 0,
9284 that represents an ellipses, otherwise the last specifier must be a
9285 VOID_TYPE.
9287 This is the GIMPLE version of validate_arglist. Eventually we want to
9288 completely convert builtins.c to work from GIMPLEs and the tree based
9289 validate_arglist will then be removed. */
9291 bool
9293 {
9297 const_tree arg;
9303 do
9304 {
9307 {
9309 /* This signifies an ellipses, any further arguments are all ok. */
9313 /* This signifies an endlink, if no arguments remain, return
9314 true, otherwise return false. */
9318 /* If no parameters remain or the parameter's code does not
9319 match the specified code, return false. Otherwise continue
9320 checking any remaining arguments. */
9325 }
9326 }
9329 /* We need gotos here since we can only have one VA_CLOSE in a
9330 function. */
9331 end: ;
9335 }
9337 /* Default target-specific builtin expander that does nothing. */
9339 rtx
9341 rtx target ATTRIBUTE_UNUSED,
9342 rtx subtarget ATTRIBUTE_UNUSED,
9343 machine_mode mode ATTRIBUTE_UNUSED,
9345 {
9347 }
9349 /* Returns true is EXP represents data that would potentially reside
9350 in a readonly section. */
9352 bool
9354 {
9364 /* Make sure we call decl_readonly_section only for trees it
9365 can handle (since it returns true for everything it doesn't
9366 understand). */
9371 else
9373 }
9375 /* Simplify a call to the strpbrk builtin. S1 and S2 are the arguments
9376 to the call, and TYPE is its return type.
9378 Return NULL_TREE if no simplification was possible, otherwise return the
9379 simplified form of the call as a tree.
9381 The simplified form may be a constant or other expression which
9382 computes the same value, but in a more efficient manner (including
9383 calls to other builtin functions).
9385 The call may contain arguments which need to be evaluated, but
9386 which are not useful to determine the result of the call. In
9387 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9388 COMPOUND_EXPR will be an argument which must be evaluated.
9389 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9390 COMPOUND_EXPR in the chain will contain the tree for the simplified
9391 form of the builtin function call. */
9393 static tree
9395 {
9399 else
9400 {
9401 tree fn;
9410 {
9412 tree tem;
9417 /* Return an offset into the constant string argument. */
9420 }
9423 /* strpbrk(x, "") == NULL.
9424 Evaluate and ignore s1 in case it had side-effects. */
9434 /* New argument list transforming strpbrk(s1, s2) to
9435 strchr(s1, s2[0]). */
9438 }
9439 }
9441 /* Simplify a call to the strspn builtin. S1 and S2 are the arguments
9442 to the call.
9444 Return NULL_TREE if no simplification was possible, otherwise return the
9445 simplified form of the call as a tree.
9447 The simplified form may be a constant or other expression which
9448 computes the same value, but in a more efficient manner (including
9449 calls to other builtin functions).
9451 The call may contain arguments which need to be evaluated, but
9452 which are not useful to determine the result of the call. In
9453 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9454 COMPOUND_EXPR will be an argument which must be evaluated.
9455 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9456 COMPOUND_EXPR in the chain will contain the tree for the simplified
9457 form of the builtin function call. */
9459 static tree
9461 {
9465 else
9466 {
9469 /* If either argument is "", return NULL_TREE. */
9471 /* Evaluate and ignore both arguments in case either one has
9472 side-effects. */
9476 }
9477 }
9479 /* Simplify a call to the strcspn builtin. S1 and S2 are the arguments
9480 to the call.
9482 Return NULL_TREE if no simplification was possible, otherwise return the
9483 simplified form of the call as a tree.
9485 The simplified form may be a constant or other expression which
9486 computes the same value, but in a more efficient manner (including
9487 calls to other builtin functions).
9489 The call may contain arguments which need to be evaluated, but
9490 which are not useful to determine the result of the call. In
9491 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9492 COMPOUND_EXPR will be an argument which must be evaluated.
9493 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9494 COMPOUND_EXPR in the chain will contain the tree for the simplified
9495 form of the builtin function call. */
9497 static tree
9499 {
9503 else
9504 {
9505 /* If the first argument is "", return NULL_TREE. */
9508 {
9509 /* Evaluate and ignore argument s2 in case it has
9510 side-effects. */
9513 }
9515 /* If the second argument is "", return __builtin_strlen(s1). */
9518 {
9521 /* If the replacement _DECL isn't initialized, don't do the
9522 transformation. */
9527 }
9529 }
9530 }
9532 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
9533 produced. False otherwise. This is done so that we don't output the error
9534 or warning twice or three times. */
9536 bool
9538 {
9541 tree arg;
9542 /* There is good chance the current input_location points inside the
9543 definition of the va_start macro (perhaps on the token for
9544 builtin) in a system header, so warnings will not be emitted.
9545 Use the location in real source code. */
9546 source_location current_location =
9548 NULL);
9551 {
9554 }
9557 {
9559 {
9562 }
9564 }
9565 /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
9566 when we checked the arguments and if needed issued a warning. */
9567 else
9568 {
9570 {
9571 /* Evidently an out of date version of <stdarg.h>; can't validate
9572 va_start's second argument, but can still work as intended. */
9574 OPT_Wvarargs,
9577 }
9579 {
9582 }
9584 }
9589 /* We destructively modify the call to be __builtin_va_start (ap, 0)
9590 or __builtin_next_arg (0) the first time we see it, after checking
9591 the arguments and if needed issuing a warning. */
9593 {
9596 /* Strip off all nops for the sake of the comparison. This
9597 is not quite the same as STRIP_NOPS. It does more.
9598 We must also strip off INDIRECT_EXPR for C++ reference
9599 parameters. */
9604 {
9605 /* FIXME: Sometimes with the tree optimizers we can get the
9606 not the last argument even though the user used the last
9607 argument. We just warn and set the arg to be the last
9608 argument so that we will get wrong-code because of
9609 it. */
9611 OPT_Wvarargs,
9613 }
9615 /* Undefined by C99 7.15.1.4p4 (va_start):
9616 "If the parameter parmN is declared with the register storage
9617 class, with a function or array type, or with a type that is
9618 not compatible with the type that results after application of
9619 the default argument promotions, the behavior is undefined."
9620 */
9622 {
9624 OPT_Wvarargs,
9625 "undefined behavior when second parameter of "
9627 }
9629 /* We want to verify the second parameter just once before the tree
9630 optimizers are run and then avoid keeping it in the tree,
9631 as otherwise we could warn even for correct code like:
9632 void foo (int i, ...)
9633 { va_list ap; i++; va_start (ap, i); va_end (ap); } */
9636 else
9638 }
9640 }
9643 /* Expand a call EXP to __builtin_object_size. */
9645 static rtx
9647 {
9648 tree ost;
9653 {
9658 }
9666 {
9671 }
9676 }
9678 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
9679 FCODE is the BUILT_IN_* to use.
9680 Return NULL_RTX if we failed; the caller should emit a normal call,
9681 otherwise try to get the result in TARGET, if convenient (and in
9682 mode MODE if that's convenient). */
9684 static rtx
9687 {
9691 POINTER_TYPE,
9692 fcode == BUILT_IN_MEMSET_CHK
9710 {
9711 /* Avoid transforming the checking call to an ordinary one when
9712 an overflow has been detected or when the call couldn't be
9713 validated because the size is not constant. */
9718 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
9719 mem{cpy,pcpy,move,set} is available. */
9721 {
9736 }
9745 }
9748 else
9749 {
9752 /* If DEST is not a pointer type, call the normal function. */
9756 /* If SRC and DEST are the same (and not volatile), do nothing. */
9758 {
9759 tree expr;
9762 {
9763 /* Evaluate and ignore LEN in case it has side-effects. */
9766 }
9770 }
9772 /* __memmove_chk special case. */
9774 {
9780 /* If src is categorized for a readonly section we can use
9781 normal __memcpy_chk. */
9783 {
9792 }
9793 }
9795 }
9796 }
9798 /* Emit warning if a buffer overflow is detected at compile time. */
9800 static void
9802 {
9803 /* The source string. */
9805 /* The size of the destination object. */
9807 /* The string that is being concatenated with (as in __strcat_chk)
9808 or null if it isn't. */
9810 /* The maximum length of the source sequence in a bounded operation
9811 (such as __strncat_chk) or null if the operation isn't bounded
9812 (such as __strcat_chk). */
9816 {
9824 /* For __strcat_chk the warning will be emitted only if overflowing
9825 by at least strlen (dest) + 1 bytes. */
9852 }
9855 {
9856 /* Check __strncat_chk. There is no way to determine the length
9857 of the string to which the source string is being appended so
9858 just warn when the length of the source string is not known. */
9861 }
9865 }
9867 /* Emit warning if a buffer overflow is detected at compile time
9868 in __sprintf_chk/__vsprintf_chk calls. */
9870 static void
9872 {
9877 /* Verify the required arguments in the original call. */
9887 /* Check whether the format is a literal string constant. */
9895 /* If the format doesn't contain % args or %%, we know its size. */
9898 /* If the format is "%s" and first ... argument is a string literal,
9899 we know it too. */
9902 {
9903 tree arg;
9914 }
9915 else
9918 /* Add one for the terminating nul. */
9922 }
9924 /* Emit warning if a free is called with address of a variable. */
9926 static void
9928 {
9942 else
9945 }
9947 /* Fold a call to __builtin_object_size with arguments PTR and OST,
9948 if possible. */
9950 static tree
9952 {
9969 /* __builtin_object_size doesn't evaluate side-effects in its arguments;
9970 if there are any side-effects, it returns (size_t) -1 for types 0 and 1
9971 and (size_t) 0 for types 2 and 3. */
9976 {
9980 }
9982 {
9983 /* If object size is not known yet, delay folding until
9984 later. Maybe subsequent passes will help determining
9985 it. */
9989 }
9992 }
9994 /* Builtins with folding operations that operate on "..." arguments
9995 need special handling; we need to store the arguments in a convenient
9996 data structure before attempting any folding. Fortunately there are
9997 only a few builtins that fall into this category. FNDECL is the
9998 function, EXP is the CALL_EXPR for the call. */
10000 static tree
10002 {
10007 {
10014 }
10016 {
10021 }
10023 }
10025 /* Initialize format string characters in the target charset. */
10027 bool
10029 {
10032 {
10055 }
10057 }
10059 /* Helper function for do_mpfr_arg*(). Ensure M is a normal number
10060 and no overflow/underflow occurred. INEXACT is true if M was not
10061 exactly calculated. TYPE is the tree type for the result. This
10062 function assumes that you cleared the MPFR flags and then
10063 calculated M to see if anything subsequently set a flag prior to
10064 entering this function. Return NULL_TREE if any checks fail. */
10066 static tree
10068 {
10069 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
10070 overflow/underflow occurred. If -frounding-math, proceed iff the
10071 result of calling FUNC was exact. */
10074 {
10075 REAL_VALUE_TYPE rr;
10078 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
10079 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
10080 but the mpft_t is not, then we underflowed in the
10081 conversion. */
10084 {
10085 REAL_VALUE_TYPE rmode;
10088 /* Proceed iff the specified mode can hold the value. */
10091 }
10092 }
10094 }
10096 /* Helper function for do_mpc_arg*(). Ensure M is a normal complex
10097 number and no overflow/underflow occurred. INEXACT is true if M
10098 was not exactly calculated. TYPE is the tree type for the result.
10099 This function assumes that you cleared the MPFR flags and then
10100 calculated M to see if anything subsequently set a flag prior to
10101 entering this function. Return NULL_TREE if any checks fail, if
10102 FORCE_CONVERT is true, then bypass the checks. */
10104 static tree
10106 {
10107 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
10108 overflow/underflow occurred. If -frounding-math, proceed iff the
10109 result of calling FUNC was exact. */
10114 {
10119 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
10120 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
10121 but the mpft_t is not, then we underflowed in the
10122 conversion. */
10127 {
10132 /* Proceed iff the specified mode can hold the value. */
10138 }
10139 }
10141 }
10143 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
10144 the pointer *(ARG_QUO) and return the result. The type is taken
10145 from the type of ARG0 and is used for setting the precision of the
10146 calculation and results. */
10148 static tree
10150 {
10157 /* To proceed, MPFR must exactly represent the target floating point
10158 format, which only happens when the target base equals two. */
10162 {
10167 {
10171 tree result_rem;
10180 /* Remquo is independent of the rounding mode, so pass
10181 inexact=0 to do_mpfr_ckconv(). */
10185 {
10186 /* MPFR calculates quo in the host's long so it may
10187 return more bits in quo than the target int can hold
10188 if sizeof(host long) > sizeof(target int). This can
10189 happen even for native compilers in LP64 mode. In
10190 these cases, modulo the quo value with the largest
10191 number that the target int can hold while leaving one
10192 bit for the sign. */
10196 /* Dereference the quo pointer argument. */
10198 /* Proceed iff a valid pointer type was passed in. */
10200 {
10201 /* Set the value. */
10202 tree result_quo
10205 integer_quo));
10207 /* Combine the quo assignment with the rem. */
10210 }
10211 }
10212 }
10213 }
10215 }
10217 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
10218 resulting value as a tree with type TYPE. The mpfr precision is
10219 set to the precision of TYPE. We assume that this mpfr function
10220 returns zero if the result could be calculated exactly within the
10221 requested precision. In addition, the integer pointer represented
10222 by ARG_SG will be dereferenced and set to the appropriate signgam
10223 (-1,1) value. */
10225 static tree
10227 {
10232 /* To proceed, MPFR must exactly represent the target floating point
10233 format, which only happens when the target base equals two. Also
10234 verify ARG is a constant and that ARG_SG is an int pointer. */
10239 {
10242 /* In addition to NaN and Inf, the argument cannot be zero or a
10243 negative integer. */
10247 {
10252 mpfr_t m;
10253 tree result_lg;
10262 {
10263 tree result_sg;
10265 /* Dereference the arg_sg pointer argument. */
10267 /* Assign the signgam value into *arg_sg. */
10272 /* Combine the signgam assignment with the lgamma result. */
10275 }
10276 }
10277 }
10280 }
10282 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
10283 mpc function FUNC on it and return the resulting value as a tree
10284 with type TYPE. The mpfr precision is set to the precision of
10285 TYPE. We assume that function FUNC returns zero if the result
10286 could be calculated exactly within the requested precision. If
10287 DO_NONFINITE is true, then fold expressions containing Inf or NaN
10288 in the arguments and/or results. */
10290 tree
10293 {
10299 /* To proceed, MPFR must exactly represent the target floating point
10300 format, which only happens when the target base equals two. */
10306 {
10315 {
10335 }
10336 }
10339 }
10341 /* A wrapper function for builtin folding that prevents warnings for
10342 "statement without effect" and the like, caused by removing the
10343 call node earlier than the warning is generated. */
10345 tree
10347 {
10355 {
10364 {
10366 }
10367 else
10368 {
10371 {
10372 /* Propagate location information from original call to
10373 expansion of builtin. Otherwise things like
10374 maybe_emit_chk_warning, that operate on the expansion
10375 of a builtin, will use the wrong location information. */
10377 {
10385 }
10387 }
10388 }
10389 }
10391 }
10393 /* Look up the function in builtin_decl that corresponds to DECL
10394 and set ASMSPEC as its user assembler name. DECL must be a
10395 function decl that declares a builtin. */
10397 void
10399 {
10409 {
10413 }
10414 }
10416 /* Return true if DECL is a builtin that expands to a constant or similarly
10417 simple code. */
10418 bool
10420 {
10423 {
10424 /* Builtins that expand to constants. */
10429 /* Simple register moves or loads from stack. */
10440 /* Exception state returns or moves registers around. */
10448 }
10451 }
10453 /* Return true if DECL is a builtin that is not expensive, i.e., they are
10454 most probably expanded inline into reasonably simple code. This is a
10455 superset of is_simple_builtin. */
10456 bool
10458 {
10465 {
10534 }
10537 }
10539 /* Return true if T is a constant and the value cast to a target char
10540 can be represented by a host char.
10541 Store the casted char constant in *P if so. */
10543 bool
10545 {
10551 }