| blob | 6716aabfa7319d76cac4ffa1626528ce458feb6d |
1 /* Expand builtin functions.
2 Copyright (C) 1988-2018 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. */
77 #if SWITCHABLE_TARGET
79 #endif
81 /* Define the names of the builtin function types and codes. */
85 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
87 {
89 };
91 /* Setup an array of builtin_info_type, make sure each element decl is
92 initialized to NULL_TREE. */
95 /* Non-zero if __builtin_constant_p should be folded right away. */
197 /* Return true if NAME starts with __builtin_ or __sync_. */
199 static bool
201 {
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 }
378 /* Account for the alignment of runtime coefficients, so that the constant
379 bitpos is guaranteed to be accurate. */
382 {
385 }
390 }
392 /* For a memory reference expression EXP compute values M and N such that M
393 divides (&EXP - N) and such that N < M. If these numbers can be determined,
394 store M in alignp and N in *BITPOSP and return true. Otherwise return false
395 and store BITS_PER_UNIT to *alignp and any bit-offset to *bitposp. */
397 bool
400 {
402 }
404 /* Return the alignment in bits of EXP, an object. */
406 unsigned int
408 {
414 /* align and bitpos now specify known low bits of the pointer.
415 ptr & (align - 1) == bitpos. */
420 }
422 /* For a pointer valued expression EXP compute values M and N such that M
423 divides (EXP - N) and such that N < M. If these numbers can be determined,
424 store M in alignp and N in *BITPOSP and return true. Return false if
425 the results are just a conservative approximation.
427 If EXP is not a pointer, false is returned too. */
429 bool
432 {
439 {
446 else
447 {
450 {
454 }
455 }
459 }
462 {
467 {
470 /* Make sure to return a sensible alignment when the multiplication
471 by BITS_PER_UNIT overflowed. */
474 /* We cannot really tell whether this result is an approximation. */
476 }
477 else
478 {
482 }
483 }
485 {
490 }
495 }
497 /* Return the alignment in bits of EXP, a pointer valued expression.
498 The alignment returned is, by default, the alignment of the thing that
499 EXP points to. If it is not a POINTER_TYPE, 0 is returned.
501 Otherwise, look at the expression to see if we can do better, i.e., if the
502 expression is actually pointing at an object whose alignment is tighter. */
504 unsigned int
506 {
512 /* align and bitpos now specify known low bits of the pointer.
513 ptr & (align - 1) == bitpos. */
519 }
521 /* Return the number of leading non-zero elements in the sequence
522 [ PTR, PTR + MAXELTS ) where each element's size is ELTSIZE bytes.
523 ELTSIZE must be a power of 2 less than 8. Used by c_strlen. */
525 unsigned
527 {
533 {
534 /* Optimize the common case of plain char. */
536 {
540 }
541 }
542 else
543 {
545 {
549 }
550 }
552 }
554 /* Compute the length of a null-terminated character string or wide
555 character string handling character sizes of 1, 2, and 4 bytes.
556 TREE_STRING_LENGTH is not the right way because it evaluates to
557 the size of the character array in bytes (as opposed to characters)
558 and because it can contain a zero byte in the middle.
560 ONLY_VALUE should be nonzero if the result is not going to be emitted
561 into the instruction stream and zero if it is going to be expanded.
562 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
563 is returned, otherwise NULL, since
564 len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
565 evaluate the side-effects.
567 If ONLY_VALUE is two then we do not emit warnings about out-of-bound
568 accesses. Note that this implies the result is not going to be emitted
569 into the instruction stream.
571 The value returned is of type `ssizetype'.
573 Unfortunately, string_constant can't access the values of const char
574 arrays with initializers, so neither can we do so here. */
576 tree
578 {
582 {
589 }
597 /* Offset from the beginning of the string in bytes. */
598 tree byteoff;
603 /* Determine the size of the string element. */
604 unsigned eltsize
607 /* Set MAXELTS to sizeof (SRC) / sizeof (*SRC) - 1, the maximum possible
608 length of SRC. Prefer TYPE_SIZE() to TREE_STRING_LENGTH() if possible
609 in case the latter is less than the size of the array, such as when
610 SRC refers to a short string literal used to initialize a large array.
611 In that case, the elements of the array after the terminating NUL are
612 all NUL. */
620 {
623 }
625 /* PTR can point to the byte representation of any string type, including
626 char* and wchar_t*. */
630 {
631 /* If the string has an internal NUL character followed by any
632 non-NUL characters (e.g., "foo\0bar"), we can't compute
633 the offset to the following NUL if we don't know where to
634 start searching for it. */
637 {
638 /* Return when an embedded null character is found. */
640 }
645 /* We don't know the starting offset, but we do know that the string
646 has no internal zero bytes. If the offset falls within the bounds
647 of the string subtract the offset from the length of the string,
648 and return that. Otherwise the length is zero. Take care to
649 use SAVE_EXPR in case the OFFSET has side-effects. */
657 }
659 /* Offset from the beginning of the string in elements. */
660 HOST_WIDE_INT eltoff;
662 /* We have a known offset into the string. Start searching there for
663 a null character if we can represent it as a single HOST_WIDE_INT. */
668 else
671 /* If the offset is known to be out of bounds, warn, and call strlen at
672 runtime. */
674 {
675 /* Suppress multiple warnings for propagated constant strings. */
678 {
681 eltoff);
683 }
685 }
687 /* Use strlen to search for the first zero byte. Since any strings
688 constructed with build_string will have nulls appended, we win even
689 if we get handed something like (char[4])"abcd".
691 Since ELTOFF is our starting index into the string, no further
692 calculation is needed. */
697 }
699 /* Return a constant integer corresponding to target reading
700 GET_MODE_BITSIZE (MODE) bits from string constant STR. */
702 static rtx
704 {
705 HOST_WIDE_INT ch;
719 {
731 }
735 }
737 /* Cast a target constant CST to target CHAR and if that value fits into
738 host char type, return zero and put that value into variable pointed to by
739 P. */
741 static int
743 {
750 /* Do not care if it fits or not right here. */
765 }
767 /* Similar to save_expr, but assumes that arbitrary code is not executed
768 in between the multiple evaluations. In particular, we assume that a
769 non-addressable local variable will not be modified. */
771 static tree
773 {
781 }
783 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
784 times to get the address of either a higher stack frame, or a return
785 address located within it (depending on FNDECL_CODE). */
787 static rtx
789 {
793 {
794 /* For a zero count with __builtin_return_address, we don't care what
795 frame address we return, because target-specific definitions will
796 override us. Therefore frame pointer elimination is OK, and using
797 the soft frame pointer is OK.
799 For a nonzero count, or a zero count with __builtin_frame_address,
800 we require a stable offset from the current frame pointer to the
801 previous one, so we must use the hard frame pointer, and
802 we must disable frame pointer elimination. */
805 else
806 {
809 /* Tell reload not to eliminate the frame pointer. */
811 }
812 }
817 /* On the SPARC, the return address is not in the frame, it is in a
818 register. There is no way to access it off of the current frame
819 pointer, but it can be accessed off the previous frame pointer by
820 reading the value from the register window save area. */
822 count--;
824 /* Scan back COUNT frames to the specified frame. */
826 {
827 /* Assume the dynamic chain pointer is in the word that the
828 frame address points to, unless otherwise specified. */
833 }
835 /* For __builtin_frame_address, return what we've got. But, on
836 the SPARC for example, we may have to add a bias. */
840 /* For __builtin_return_address, get the return address from that frame. */
841 #ifdef RETURN_ADDR_RTX
843 #else
847 #endif
849 }
851 /* Alias set used for setjmp buffer. */
854 /* Construct the leading half of a __builtin_setjmp call. Control will
855 return to RECEIVER_LABEL. This is also called directly by the SJLJ
856 exception handling code. */
858 void
860 {
862 rtx stack_save;
863 rtx mem;
872 /* We store the frame pointer and the address of receiver_label in
873 the buffer and use the rest of it for the stack save area, which
874 is machine-dependent. */
893 /* If there is further processing to do, do it. */
897 /* We have a nonlocal label. */
899 }
901 /* Construct the trailing part of a __builtin_setjmp call. This is
902 also called directly by the SJLJ exception handling code.
903 If RECEIVER_LABEL is NULL, instead contruct a nonlocal goto handler. */
905 void
907 {
908 rtx chain;
910 /* Mark the FP as used when we get here, so we have to make sure it's
911 marked as used by this function. */
914 /* Mark the static chain as clobbered here so life information
915 doesn't get messed up for it. */
920 /* Now put in the code to restore the frame pointer, and argument
921 pointer, if needed. */
923 {
924 /* First adjust our frame pointer to its actual value. It was
925 previously set to the start of the virtual area corresponding to
926 the stacked variables when we branched here and now needs to be
927 adjusted to the actual hardware fp value.
929 Assignments to virtual registers are converted by
930 instantiate_virtual_regs into the corresponding assignment
931 to the underlying register (fp in this case) that makes
932 the original assignment true.
933 So the following insn will actually be decrementing fp by
934 TARGET_STARTING_FRAME_OFFSET. */
937 /* Restoring the frame pointer also modifies the hard frame pointer.
938 Mark it used (so that the previous assignment remains live once
939 the frame pointer is eliminated) and clobbered (to represent the
940 implicit update from the assignment). */
943 }
946 {
947 /* If the argument pointer can be eliminated in favor of the
948 frame pointer, we don't need to restore it. We assume here
949 that if such an elimination is present, it can always be used.
950 This is the case on all known machines; if we don't make this
951 assumption, we do unnecessary saving on many machines. */
961 {
962 /* Now restore our arg pointer from the address at which it
963 was saved in our stack frame. */
966 }
967 }
973 else
976 /* We must not allow the code we just generated to be reordered by
977 scheduling. Specifically, the update of the frame pointer must
978 happen immediately, not later. */
980 }
982 /* __builtin_longjmp is passed a pointer to an array of five words (not
983 all will be used on all machines). It operates similarly to the C
984 library function of the same name, but is more efficient. Much of
985 the code below is copied from the handling of non-local gotos. */
987 static void
989 {
994 /* DRAP is needed for stack realign if longjmp is expanded to current
995 function */
1006 /* We require that the user must pass a second argument of 1, because
1007 that is what builtin_setjmp will return. */
1013 else
1014 {
1025 /* Pick up FP, label, and SP from the block and jump. This code is
1026 from expand_goto in stmt.c; see there for detailed comments. */
1028 /* We have to pass a value to the nonlocal_goto pattern that will
1029 get copied into the static_chain pointer, but it does not matter
1030 what that value is, because builtin_setjmp does not use it. */
1032 else
1033 {
1045 }
1046 }
1048 /* Search backwards and mark the jump insn as a non-local goto.
1049 Note that this precludes the use of __builtin_longjmp to a
1050 __builtin_setjmp target in the same function. However, we've
1051 already cautioned the user that these functions are for
1052 internal exception handling use only. */
1054 {
1058 {
1061 }
1064 }
1065 }
1069 {
1071 }
1073 /* This function validates the types of a function call argument list
1074 against a specified list of tree_codes. If the last specifier is a 0,
1075 that represents an ellipsis, otherwise the last specifier must be a
1076 VOID_TYPE. */
1078 static bool
1080 {
1084 const_call_expr_arg_iterator iter;
1085 const_tree arg;
1090 /* Get a bitmap of pointer argument numbers declared attribute nonnull. */
1095 {
1099 {
1101 /* This signifies an ellipses, any further arguments are all ok. */
1105 /* This signifies an endlink, if no arguments remain, return
1106 true, otherwise return false. */
1110 /* The actual argument must be nonnull when either the whole
1111 called function has been declared nonnull, or when the formal
1112 argument corresponding to the actual argument has been. */
1115 {
1120 }
1121 /* FALLTHRU */
1123 /* If no parameters remain or the parameter's code does not
1124 match the specified code, return false. Otherwise continue
1125 checking any remaining arguments. */
1130 }
1131 }
1133 /* We need gotos here since we can only have one VA_CLOSE in a
1134 function. */
1135 end: ;
1141 }
1143 /* Expand a call to __builtin_nonlocal_goto. We're passed the target label
1144 and the address of the save area. */
1146 static rtx
1148 {
1163 /* Copy the address of the save location to a register just in case it was
1164 based on the frame pointer. */
1173 /* ??? We no longer need to pass the static chain value, afaik. */
1176 else
1177 {
1183 /* Restore frame pointer for containing function. */
1187 /* USE of hard_frame_pointer_rtx added for consistency;
1188 not clear if really needed. */
1192 /* If the architecture is using a GP register, we must
1193 conservatively assume that the target function makes use of it.
1194 The prologue of functions with nonlocal gotos must therefore
1195 initialize the GP register to the appropriate value, and we
1196 must then make sure that this value is live at the point
1197 of the jump. (Note that this doesn't necessarily apply
1198 to targets with a nonlocal_goto pattern; they are free
1199 to implement it in their own way. Note also that this is
1200 a no-op if the GP register is a global invariant.) */
1206 }
1208 /* Search backwards to the jump insn and mark it as a
1209 non-local goto. */
1211 {
1213 {
1216 }
1219 }
1222 }
1224 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
1225 (not all will be used on all machines) that was passed to __builtin_setjmp.
1226 It updates the stack pointer in that block to the current value. This is
1227 also called directly by the SJLJ exception handling code. */
1229 void
1231 {
1234 rtx stack_save
1236 memory_address
1242 }
1244 /* Expand a call to __builtin_prefetch. For a target that does not support
1245 data prefetch, evaluate the memory address argument in case it has side
1246 effects. */
1248 static void
1250 {
1260 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1261 zero (read) and argument 2 (locality) defaults to 3 (high degree of
1262 locality). */
1266 else
1270 else
1273 /* Argument 0 is an address. */
1276 /* Argument 1 (read/write flag) must be a compile-time constant int. */
1278 {
1281 }
1283 /* Argument 1 must be either zero or one. */
1285 {
1289 }
1291 /* Argument 2 (locality) must be a compile-time constant int. */
1293 {
1296 }
1298 /* Argument 2 must be 0, 1, 2, or 3. */
1300 {
1303 }
1306 {
1314 }
1316 /* Don't do anything with direct references to volatile memory, but
1317 generate code to handle other side effects. */
1320 }
1322 /* Get a MEM rtx for expression EXP which is the address of an operand
1323 to be used in a string instruction (cmpstrsi, movmemsi, ..). LEN is
1324 the maximum length of the block of memory that might be accessed or
1325 NULL if unknown. */
1327 static rtx
1329 {
1333 /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1334 from its expression, for expr->a.b only <variable>.a.b is recorded. */
1341 /* Get an expression we can use to find the attributes to assign to MEM.
1342 First remove any nops. */
1347 /* Build a MEM_REF representing the whole accessed area as a byte blob,
1348 (as builtin stringops may alias with anything). */
1355 /* If the MEM_REF has no acceptable address, try to get the base object
1356 from the original address we got, and build an all-aliasing
1357 unknown-sized access to that one. */
1363 {
1368 size_zero_node,
1369 NULL)),
1372 }
1375 }
1376 \f
1377 /* Built-in functions to perform an untyped call and return. */
1379 #define apply_args_mode \
1380 (this_target_builtins->x_apply_args_mode)
1381 #define apply_result_mode \
1382 (this_target_builtins->x_apply_result_mode)
1384 /* Return the size required for the block returned by __builtin_apply_args,
1385 and initialize apply_args_mode. */
1387 static int
1389 {
1394 /* The values computed by this function never change. */
1396 {
1397 /* The first value is the incoming arg-pointer. */
1400 /* The second value is the structure value address unless this is
1401 passed as an "invisible" first argument. */
1407 {
1417 }
1418 else
1419 {
1421 }
1422 }
1424 }
1426 /* Return the size required for the block returned by __builtin_apply,
1427 and initialize apply_result_mode. */
1429 static int
1431 {
1435 /* The values computed by this function never change. */
1437 {
1442 {
1452 }
1453 else
1456 /* Allow targets that use untyped_call and untyped_return to override
1457 the size so that machine-specific information can be stored here. */
1458 #ifdef APPLY_RESULT_SIZE
1460 #endif
1461 }
1463 }
1465 /* Create a vector describing the result block RESULT. If SAVEP is true,
1466 the result block is used to save the values; otherwise it is used to
1467 restore the values. */
1469 static rtx
1471 {
1473 fixed_size_mode mode;
1480 {
1490 }
1492 }
1494 /* Save the state required to perform an untyped call with the same
1495 arguments as were passed to the current function. */
1497 static rtx
1499 {
1502 fixed_size_mode mode;
1503 rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1505 /* Create a block where the arg-pointer, structure value address,
1506 and argument registers can be saved. */
1509 /* Walk past the arg-pointer and structure value address. */
1514 /* Save each register used in calling a function to the block. */
1517 {
1526 }
1528 /* Save the arg pointer to the block. */
1530 /* We need the pointer as the caller actually passed them to us, not
1531 as we might have pretended they were passed. Make sure it's a valid
1532 operand, as emit_move_insn isn't expected to handle a PLUS. */
1534 tem
1537 NULL_RTX);
1542 /* Save the structure value address unless this is passed as an
1543 "invisible" first argument. */
1545 {
1549 }
1551 /* Return the address of the block. */
1553 }
1555 /* __builtin_apply_args returns block of memory allocated on
1556 the stack into which is stored the arg pointer, structure
1557 value address, static chain, and all the registers that might
1558 possibly be used in performing a function call. The code is
1559 moved to the start of the function so the incoming values are
1560 saved. */
1562 static rtx
1564 {
1565 /* Don't do __builtin_apply_args more than once in a function.
1566 Save the result of the first call and reuse it. */
1569 {
1570 /* When this function is called, it means that registers must be
1571 saved on entry to this function. So we migrate the
1572 call to the first insn of this function. */
1573 rtx temp;
1582 /* Put the insns after the NOTE that starts the function.
1583 If this is inside a start_sequence, make the outer-level insn
1584 chain current, so the code is placed at the start of the
1585 function. If internal_arg_pointer is a non-virtual pseudo,
1586 it needs to be placed after the function that initializes
1587 that pseudo. */
1592 else
1596 }
1597 }
1599 /* Perform an untyped call and save the state required to perform an
1600 untyped return of whatever value was returned by the given function. */
1602 static rtx
1604 {
1606 fixed_size_mode mode;
1615 /* Create a block where the return registers can be saved. */
1618 /* Fetch the arg pointer from the ARGUMENTS block. */
1625 /* Push a new argument block and copy the arguments. Do not allow
1626 the (potential) memcpy call below to interfere with our stack
1627 manipulations. */
1629 NO_DEFER_POP;
1631 /* Save the stack with nonlocal if available. */
1634 else
1637 /* Allocate a block of memory onto the stack and copy the memory
1638 arguments to the outgoing arguments address. We can pass TRUE
1639 as the 4th argument because we just saved the stack pointer
1640 and will restore it right after the call. */
1643 /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1644 may have already set current_function_calls_alloca to true.
1645 current_function_calls_alloca won't be set if argsize is zero,
1646 so we have to guarantee need_drap is true here. */
1652 {
1655 else
1657 }
1664 /* Refer to the argument block. */
1669 /* Walk past the arg-pointer and structure value address. */
1674 /* Restore each of the registers previously saved. Make USE insns
1675 for each of these registers for use in making the call. */
1678 {
1686 }
1688 /* Restore the structure value address unless this is passed as an
1689 "invisible" first argument. */
1692 {
1699 }
1701 /* All arguments and registers used for the call are set up by now! */
1704 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
1705 and we don't want to load it into a register as an optimization,
1706 because prepare_call_address already did it if it should be done. */
1710 /* Generate the actual call instruction and save the return value. */
1712 {
1716 }
1718 {
1721 /* Locate the unique return register. It is not possible to
1722 express a call that sets more than one return register using
1723 call_value; use untyped_call for that. In fact, untyped_call
1724 only needs to save the return registers in the given block. */
1727 {
1731 }
1738 }
1739 else
1742 /* Find the CALL insn we just emitted, and attach the register usage
1743 information. */
1747 /* Restore the stack. */
1750 else
1754 OK_DEFER_POP;
1756 /* Return the address of the result block. */
1759 }
1761 /* Perform an untyped return. */
1763 static void
1765 {
1767 fixed_size_mode mode;
1768 rtx reg;
1777 {
1782 }
1784 /* Restore the return value and note that each value is used. */
1788 {
1800 }
1802 /* Put the USE insns before the return. */
1805 /* Return whatever values was restored by jumping directly to the end
1806 of the function. */
1808 }
1810 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */
1812 static enum type_class
1814 {
1816 {
1835 }
1836 }
1838 /* Expand a call EXP to __builtin_classify_type. */
1840 static rtx
1842 {
1846 }
1848 /* This helper macro, meant to be used in mathfn_built_in below, determines
1849 which among a set of builtin math functions is appropriate for a given type
1850 mode. The `F' (float) and `L' (long double) are automatically generated
1851 from the 'double' case. If a function supports the _Float<N> and _Float<N>X
1852 types, there are additional types that are considered with 'F32', 'F64',
1853 'F128', etc. suffixes. */
1854 #define CASE_MATHFN(MATHFN) \
1855 CASE_CFN_##MATHFN: \
1856 fcode = BUILT_IN_##MATHFN; fcodef = BUILT_IN_##MATHFN##F ; \
1857 fcodel = BUILT_IN_##MATHFN##L ; break;
1858 /* Similar to the above, but also add support for the _Float<N> and _Float<N>X
1859 types. */
1860 #define CASE_MATHFN_FLOATN(MATHFN) \
1861 CASE_CFN_##MATHFN: \
1862 fcode = BUILT_IN_##MATHFN; fcodef = BUILT_IN_##MATHFN##F ; \
1863 fcodel = BUILT_IN_##MATHFN##L ; fcodef16 = BUILT_IN_##MATHFN##F16 ; \
1864 fcodef32 = BUILT_IN_##MATHFN##F32; fcodef64 = BUILT_IN_##MATHFN##F64 ; \
1865 fcodef128 = BUILT_IN_##MATHFN##F128 ; fcodef32x = BUILT_IN_##MATHFN##F32X ; \
1866 fcodef64x = BUILT_IN_##MATHFN##F64X ; fcodef128x = BUILT_IN_##MATHFN##F128X ;\
1867 break;
1868 /* Similar to above, but appends _R after any F/L suffix. */
1869 #define CASE_MATHFN_REENT(MATHFN) \
1870 case CFN_BUILT_IN_##MATHFN##_R: \
1871 case CFN_BUILT_IN_##MATHFN##F_R: \
1872 case CFN_BUILT_IN_##MATHFN##L_R: \
1873 fcode = BUILT_IN_##MATHFN##_R; fcodef = BUILT_IN_##MATHFN##F_R ; \
1874 fcodel = BUILT_IN_##MATHFN##L_R ; break;
1876 /* Return a function equivalent to FN but operating on floating-point
1877 values of type TYPE, or END_BUILTINS if no such function exists.
1878 This is purely an operation on function codes; it does not guarantee
1879 that the target actually has an implementation of the function. */
1881 static built_in_function
1883 {
1884 tree mtype;
1895 {
1986 }
2009 else
2011 }
2013 /* Return mathematic function equivalent to FN but operating directly on TYPE,
2014 if available. If IMPLICIT_P is true use the implicit builtin declaration,
2015 otherwise use the explicit declaration. If we can't do the conversion,
2016 return null. */
2018 static tree
2020 {
2029 }
2031 /* Like mathfn_built_in_1, but always use the implicit array. */
2033 tree
2035 {
2037 }
2039 /* Like mathfn_built_in_1, but take a built_in_function and
2040 always use the implicit array. */
2042 tree
2044 {
2046 }
2048 /* If BUILT_IN_NORMAL function FNDECL has an associated internal function,
2049 return its code, otherwise return IFN_LAST. Note that this function
2050 only tests whether the function is defined in internals.def, not whether
2051 it is actually available on the target. */
2053 internal_fn
2055 {
2059 {
2060 #define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE) \
2061 CASE_FLT_FN (BUILT_IN_##NAME): return IFN_##NAME;
2062 #define DEF_INTERNAL_FLT_FLOATN_FN(NAME, FLAGS, OPTAB, TYPE) \
2063 CASE_FLT_FN (BUILT_IN_##NAME): return IFN_##NAME; \
2064 CASE_FLT_FN_FLOATN_NX (BUILT_IN_##NAME): return IFN_##NAME;
2065 #define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE) \
2066 CASE_INT_FN (BUILT_IN_##NAME): return IFN_##NAME;
2083 }
2084 }
2086 /* If CALL is a call to a BUILT_IN_NORMAL function that could be replaced
2087 on the current target by a call to an internal function, return the
2088 code of that internal function, otherwise return IFN_LAST. The caller
2089 is responsible for ensuring that any side-effects of the built-in
2090 call are dealt with correctly. E.g. if CALL sets errno, the caller
2091 must decide that the errno result isn't needed or make it available
2092 in some other way. */
2094 internal_fn
2096 {
2098 {
2101 {
2106 }
2107 }
2109 }
2111 /* Expand a call to the builtin trinary math functions (fma).
2112 Return NULL_RTX if a normal call should be emitted rather than expanding the
2113 function in-line. EXP is the expression that is a call to the builtin
2114 function; if convenient, the result should be placed in TARGET.
2115 SUBTARGET may be used as the target for computing one of EXP's
2116 operands. */
2118 static rtx
2120 {
2121 optab builtin_optab;
2126 machine_mode mode;
2136 {
2142 }
2144 /* Make a suitable register to place result in. */
2147 /* Before working hard, check whether the instruction is available. */
2153 /* Always stabilize the argument list. */
2164 /* Compute into RESULT.
2165 Set RESULT to wherever the result comes back. */
2169 /* If we were unable to expand via the builtin, stop the sequence
2170 (without outputting the insns) and call to the library function
2171 with the stabilized argument list. */
2173 {
2176 }
2178 /* Output the entire sequence. */
2184 }
2186 /* Expand a call to the builtin sin and cos math functions.
2187 Return NULL_RTX if a normal call should be emitted rather than expanding the
2188 function in-line. EXP is the expression that is a call to the builtin
2189 function; if convenient, the result should be placed in TARGET.
2190 SUBTARGET may be used as the target for computing one of EXP's
2191 operands. */
2193 static rtx
2195 {
2196 optab builtin_optab;
2197 rtx op0;
2200 machine_mode mode;
2201 tree arg;
2209 {
2215 }
2217 /* Make a suitable register to place result in. */
2220 /* Check if sincos insn is available, otherwise fallback
2221 to sin or cos insn. */
2224 {
2231 }
2233 /* Before working hard, check whether the instruction is available. */
2235 {
2238 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2239 need to expand the argument again. This way, we will not perform
2240 side-effects more the once. */
2247 /* Compute into RESULT.
2248 Set RESULT to wherever the result comes back. */
2250 {
2254 {
2263 }
2265 }
2266 else
2270 {
2271 /* Output the entire sequence. */
2276 }
2278 /* If we were unable to expand via the builtin, stop the sequence
2279 (without outputting the insns) and call to the library function
2280 with the stabilized argument list. */
2282 }
2285 }
2287 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2288 return an RTL instruction code that implements the functionality.
2289 If that isn't possible or available return CODE_FOR_nothing. */
2291 static enum insn_code
2293 {
2296 machine_mode mode;
2299 {
2313 /* These builtins have no optabs (yet). */
2317 }
2319 /* There's no easy way to detect the case we need to set EDOM. */
2323 /* Optab mode depends on the mode of the input argument. */
2329 }
2331 /* Expand a call to one of the builtin math functions that operate on
2332 floating point argument and output an integer result (ilogb, isinf,
2333 isnan, etc).
2334 Return 0 if a normal call should be emitted rather than expanding the
2335 function in-line. EXP is the expression that is a call to the builtin
2336 function; if convenient, the result should be placed in TARGET. */
2338 static rtx
2340 {
2342 rtx op0;
2344 machine_mode mode;
2345 tree arg;
2355 {
2360 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2361 need to expand the argument again. This way, we will not perform
2362 side-effects more the once. */
2377 }
2380 }
2382 /* Expand a call to the builtin sincos math function.
2383 Return NULL_RTX if a normal call should be emitted rather than expanding the
2384 function in-line. EXP is the expression that is a call to the builtin
2385 function. */
2387 static rtx
2389 {
2391 machine_mode mode;
2405 /* Make a suitable register to place result in. */
2408 /* Check if sincos insn is available, otherwise emit the call. */
2423 /* Compute into target1 and target2.
2424 Set TARGET to wherever the result comes back. */
2428 /* Move target1 and target2 to the memory locations indicated
2429 by op1 and op2. */
2434 }
2436 /* Expand a call to the internal cexpi builtin to the sincos math function.
2437 EXP is the expression that is a call to the builtin function; if convenient,
2438 the result should be placed in TARGET. */
2440 static rtx
2442 {
2445 machine_mode mode;
2456 /* Try expanding via a sincos optab, fall back to emitting a libcall
2457 to sincos or cexp. We are sure we have sincos or cexp because cexpi
2458 is only generated from sincos, cexp or if we have either of them. */
2460 {
2466 /* Compute into op1 and op2. */
2468 }
2470 {
2481 else
2491 /* Make sure not to fold the sincos call again. */
2495 }
2496 else
2497 {
2507 else
2510 /* If we don't have a decl for cexp create one. This is the
2511 friendliest fallback if the user calls __builtin_cexpi
2512 without full target C99 function support. */
2514 {
2515 tree fntype;
2527 }
2532 /* Make sure not to fold the cexp call again. */
2536 }
2538 /* Now build the proper return type. */
2543 }
2545 /* Conveniently construct a function call expression. FNDECL names the
2546 function to be called, N is the number of arguments, and the "..."
2547 parameters are the argument expressions. Unlike build_call_exr
2548 this doesn't fold the call, hence it will always return a CALL_EXPR. */
2550 static tree
2552 {
2562 }
2564 /* Expand a call to one of the builtin rounding functions gcc defines
2565 as an extension (lfloor and lceil). As these are gcc extensions we
2566 do not need to worry about setting errno to EDOM.
2567 If expanding via optab fails, lower expression to (int)(floor(x)).
2568 EXP is the expression that is a call to the builtin function;
2569 if convenient, the result should be placed in TARGET. */
2571 static rtx
2573 {
2574 convert_optab builtin_optab;
2579 tree fallback_fndecl;
2580 machine_mode mode;
2581 tree arg;
2589 {
2606 }
2608 /* Make a suitable register to place result in. */
2613 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2614 need to expand the argument again. This way, we will not perform
2615 side-effects more the once. */
2622 /* Compute into TARGET. */
2624 {
2625 /* Output the entire sequence. */
2630 }
2632 /* If we were unable to expand via the builtin, stop the sequence
2633 (without outputting the insns). */
2636 /* Fall back to floating point rounding optab. */
2639 /* For non-C99 targets we may end up without a fallback fndecl here
2640 if the user called __builtin_lfloor directly. In this case emit
2641 a call to the floor/ceil variants nevertheless. This should result
2642 in the best user experience for not full C99 targets. */
2644 {
2645 tree fntype;
2649 {
2682 }
2687 }
2694 /* Truncate the result of floating point optab to integer
2695 via expand_fix (). */
2700 }
2702 /* Expand a call to one of the builtin math functions doing integer
2703 conversion (lrint).
2704 Return 0 if a normal call should be emitted rather than expanding the
2705 function in-line. EXP is the expression that is a call to the builtin
2706 function; if convenient, the result should be placed in TARGET. */
2708 static rtx
2710 {
2711 convert_optab builtin_optab;
2712 rtx op0;
2715 tree arg;
2716 machine_mode mode;
2725 {
2744 }
2746 /* There's no easy way to detect the case we need to set EDOM. */
2750 /* Make a suitable register to place result in. */
2753 /* There's no easy way to detect the case we need to set EDOM. */
2755 {
2758 /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2759 need to expand the argument again. This way, we will not perform
2760 side-effects more the once. */
2768 {
2769 /* Output the entire sequence. */
2774 }
2776 /* If we were unable to expand via the builtin, stop the sequence
2777 (without outputting the insns) and call to the library function
2778 with the stabilized argument list. */
2780 }
2783 {
2784 /* Fall back to rounding to long int. Use implicit_p 0 - for non-C99
2785 targets, (int) round (x) should never be transformed into
2786 BUILT_IN_IROUND and if __builtin_iround is called directly, emit
2787 a call to lround in the hope that the target provides at least some
2788 C99 functions. This should result in the best user experience for
2789 not full C99 targets. */
2790 tree fallback_fndecl = mathfn_built_in_1
2799 }
2802 }
2804 /* Expand a call to the powi built-in mathematical function. Return NULL_RTX if
2805 a normal call should be emitted rather than expanding the function
2806 in-line. EXP is the expression that is a call to the builtin
2807 function; if convenient, the result should be placed in TARGET. */
2809 static rtx
2811 {
2814 machine_mode mode;
2815 machine_mode mode2;
2824 /* Emit a libcall to libgcc. */
2826 /* Mode of the 2nd argument must match that of an int. */
2844 }
2846 /* Expand expression EXP which is a call to the strlen builtin. Return
2847 NULL_RTX if we failed and the caller should emit a normal call, otherwise
2848 try to get the result in TARGET, if convenient. */
2850 static rtx
2852 machine_mode target_mode)
2853 {
2858 rtx pat;
2859 tree len;
2861 rtx src_reg;
2863 machine_mode insn_mode;
2867 /* If the length can be computed at compile-time, return it. */
2872 /* If the length can be computed at compile-time and is constant
2873 integer, but there are side-effects in src, evaluate
2874 src for side-effects, then return len.
2875 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
2876 can be optimized into: i++; x = 3; */
2879 {
2882 }
2886 /* If SRC is not a pointer type, don't do this operation inline. */
2890 /* Bail out if we can't compute strlen in the right mode. */
2892 {
2896 }
2900 /* Make a place to hold the source address. We will not expand
2901 the actual source until we are sure that the expansion will
2902 not fail -- there are trees that cannot be expanded twice. */
2905 /* Mark the beginning of the strlen sequence so we can emit the
2906 source operand later. */
2916 /* Check to see if the argument was declared attribute nonstring
2917 and if so, issue a warning since at this point it's not known
2918 to be nul-terminated. */
2921 /* Now that we are assured of success, expand the source. */
2925 {
2926 #ifdef POINTERS_EXTEND_UNSIGNED
2929 POINTERS_EXTEND_UNSIGNED);
2930 #endif
2932 }
2938 else
2941 /* Return the value in the proper mode for this function. */
2946 else
2950 }
2952 /* Expand call EXP to the strnlen built-in, returning the result
2953 and setting it in TARGET. Otherwise return NULL_RTX on failure. */
2955 static rtx
2957 {
2977 {
2981 "%K%qD specified bound %E "
2992 }
3005 "%K%qD specified bound [%wu, %wu] "
3018 }
3020 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3021 bytes from constant string DATA + OFFSET and return it as target
3022 constant. */
3024 static rtx
3026 scalar_int_mode mode)
3027 {
3035 }
3037 /* LEN specify length of the block of memcpy/memset operation.
3038 Figure out its range and put it into MIN_SIZE/MAX_SIZE.
3039 In some cases we can make very likely guess on max size, then we
3040 set it into PROBABLE_MAX_SIZE. */
3042 static void
3047 {
3049 {
3052 }
3053 else
3054 {
3058 /* Determine bounds from the type. */
3061 else
3066 else
3072 {
3077 }
3079 {
3080 /* Anti range 0...N lets us to determine minimal size to N+1. */
3082 {
3085 }
3086 /* Code like
3088 int n;
3089 if (n < 100)
3090 memcpy (a, b, n)
3092 Produce anti range allowing negative values of N. We still
3093 can use the information and make a guess that N is not negative.
3094 */
3097 }
3098 }
3102 }
3104 /* Try to verify that the sizes and lengths of the arguments to a string
3105 manipulation function given by EXP are within valid bounds and that
3106 the operation does not lead to buffer overflow or read past the end.
3107 Arguments other than EXP may be null. When non-null, the arguments
3108 have the following meaning:
3109 DST is the destination of a copy call or NULL otherwise.
3110 SRC is the source of a copy call or NULL otherwise.
3111 DSTWRITE is the number of bytes written into the destination obtained
3112 from the user-supplied size argument to the function (such as in
3113 memcpy(DST, SRCs, DSTWRITE) or strncpy(DST, DRC, DSTWRITE).
3114 MAXREAD is the user-supplied bound on the length of the source sequence
3115 (such as in strncat(d, s, N). It specifies the upper limit on the number
3116 of bytes to write. If NULL, it's taken to be the same as DSTWRITE.
3117 SRCSTR is the source string (such as in strcpy(DST, SRC)) when the
3118 expression EXP is a string function call (as opposed to a memory call
3119 like memcpy). As an exception, SRCSTR can also be an integer denoting
3120 the precomputed size of the source string or object (for functions like
3121 memcpy).
3122 DSTSIZE is the size of the destination object specified by the last
3123 argument to the _chk builtins, typically resulting from the expansion
3124 of __builtin_object_size (such as in __builtin___strcpy_chk(DST, SRC,
3125 DSTSIZE).
3127 When DSTWRITE is null LEN is checked to verify that it doesn't exceed
3128 SIZE_MAX.
3130 If the call is successfully verified as safe return true, otherwise
3131 return false. */
3133 static bool
3136 {
3139 /* The size of the largest object is half the address space, or
3140 PTRDIFF_MAX. (This is way too permissive.) */
3143 /* Either the length of the source string for string functions or
3144 the size of the source object for raw memory functions. */
3149 /* Set to true when the exact number of bytes written by a string
3150 function like strcpy is not known and the only thing that is
3151 known is that it must be at least one (for the terminating nul). */
3154 {
3155 /* SRCSTR is normally a pointer to string but as a special case
3156 it can be an integer denoting the length of a string. */
3158 {
3159 /* Try to determine the range of lengths the source string
3160 refers to. If it can be determined and is less than
3161 the upper bound given by MAXREAD add one to it for
3162 the terminating nul. Otherwise, set it to one for
3163 the same reason, or to MAXREAD as appropriate. */
3166 {
3169 else
3180 }
3181 else
3182 {
3185 }
3186 }
3187 else
3189 }
3192 {
3193 /* When the only available piece of data is the object size
3194 there is nothing to do. */
3198 /* Otherwise, when the length of the source sequence is known
3199 (as with strlen), set DSTWRITE to it. */
3202 }
3212 /* First check the number of bytes to be written against the maximum
3213 object size. */
3217 {
3227 "%K%qD specified size %E "
3230 else
3232 "%K%qD specified size between %E and %E "
3240 }
3242 /* The number of bytes to write is "exact" if DSTWRITE is non-null,
3243 constant, and in range of unsigned HOST_WIDE_INT. */
3246 /* Next check the number of bytes to be written against the destination
3247 object size. */
3249 {
3254 || (dstwrite
3257 {
3265 {
3266 /* This is a call to strcpy with a destination of 0 size
3267 and a source of unknown length. The call will write
3268 at least one byte past the end of the destination. */
3270 "%K%qD writing %E or more bytes into a region "
3273 }
3276 "%K%qD writing %E byte into a region "
3278 "%K%qD writing %E bytes into a region "
3282 {
3283 /* Avoid printing the upper bound if it's invalid. */
3285 "%K%qD writing %E or more bytes into a region "
3288 }
3289 else
3291 "%K%qD writing between %E and %E bytes into "
3294 dstsize);
3296 /* Return error when an overflow has been detected. */
3298 }
3299 }
3301 /* Check the maximum length of the source sequence against the size
3302 of the destination object if known, or against the maximum size
3303 of an object. */
3305 {
3308 /* Use the lower end for MAXREAD from now on. */
3313 {
3318 {
3322 /* Warn about crazy big sizes first since that's more
3323 likely to be meaningful than saying that the bound
3324 is greater than the object size if both are big. */
3327 "%K%qD specified bound %E "
3331 else
3333 "%K%qD specified bound between %E and %E "
3339 }
3342 {
3348 "%K%qD specified bound %E "
3352 else
3354 "%K%qD specified bound between %E and %E "
3359 }
3360 }
3361 }
3363 /* Check for reading past the end of SRC. */
3368 {
3380 {
3381 /* Avoid printing the upper bound if it's invalid. */
3383 "%K%qD reading %E or more bytes from a region "
3386 }
3387 else
3389 "%K%qD reading between %E and %E bytes from a region "
3393 }
3396 }
3398 /* Helper to compute the size of the object referenced by the DEST
3399 expression which must have pointer type, using Object Size type
3400 OSTYPE (only the least significant 2 bits are used). Return
3401 an estimate of the size of the object if successful or NULL when
3402 the size cannot be determined. When the referenced object involves
3403 a non-constant offset in some range the returned value represents
3404 the largest size given the smallest non-negative offset in the
3405 range. The function is intended for diagnostics and should not
3406 be used to influence code generation or optimization. */
3408 tree
3410 {
3413 /* Only the two least significant bits are meaningful. */
3420 {
3429 {
3430 /* compute_builtin_object_size fails for addresses with
3431 non-constant offsets. Try to determine the range of
3432 such an offset here and use it to adjust the constant
3433 size. */
3436 {
3438 {
3442 /* Ignore negative offsets for now. For others,
3443 use the lower bound as the most optimistic
3444 estimate of the (remaining) size. */
3446 ;
3450 else
3452 }
3453 }
3456 {
3461 {
3463 {
3466 /* Ignore negative offsets for now. For others,
3467 use the lower bound as the most optimistic
3468 estimate of the (remaining)size. */
3470 ;
3474 else
3476 }
3477 }
3478 }
3479 }
3482 }
3484 /* Unless computing the largest size (for memcpy and other raw memory
3485 functions), try to determine the size of the object from its type. */
3500 {
3501 /* Return the constant size unless it's zero (that's a zero-length
3502 array likely at the end of a struct). */
3507 }
3510 }
3512 /* Helper to determine and check the sizes of the source and the destination
3513 of calls to __builtin_{bzero,memcpy,mempcpy,memset} calls. EXP is the
3514 call expression, DEST is the destination argument, SRC is the source
3515 argument or null, and LEN is the number of bytes. Use Object Size type-0
3516 regardless of the OPT_Wstringop_overflow_ setting. Return true on success
3517 (no overflow or invalid sizes), false otherwise. */
3519 static bool
3521 {
3522 /* For functions like memset and memcpy that operate on raw memory
3523 try to determine the size of the largest source and destination
3524 object using type-0 Object Size regardless of the object size
3525 type specified by the option. */
3531 }
3533 /* Validate memchr arguments without performing any expansion.
3534 Return NULL_RTX. */
3536 static rtx
3538 {
3546 /* Diagnose calls where the specified length exceeds the size
3547 of the object. */
3549 {
3553 }
3556 }
3558 /* Expand a call EXP to the memcpy builtin.
3559 Return NULL_RTX if we failed, the caller should emit a normal call,
3560 otherwise try to get the result in TARGET, if convenient (and in
3561 mode MODE if that's convenient). */
3563 static rtx
3565 {
3578 }
3580 /* Check a call EXP to the memmove built-in for validity.
3581 Return NULL_RTX on both success and failure. */
3583 static rtx
3585 {
3597 }
3599 /* Expand a call EXP to the mempcpy builtin.
3600 Return NULL_RTX if we failed; the caller should emit a normal call,
3601 otherwise try to get the result in TARGET, if convenient (and in
3602 mode MODE if that's convenient). If ENDP is 0 return the
3603 destination pointer, if ENDP is 1 return the end pointer ala
3604 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3605 stpcpy. */
3607 static rtx
3609 {
3618 /* Policy does not generally allow using compute_objsize (which
3619 is used internally by check_memop_size) to change code generation
3620 or drive optimization decisions.
3622 In this instance it is safe because the code we generate has
3623 the same semantics regardless of the return value of
3624 check_memop_sizes. Exactly the same amount of data is copied
3625 and the return value is exactly the same in both cases.
3627 Furthermore, check_memop_size always uses mode 0 for the call to
3628 compute_objsize, so the imprecise nature of compute_objsize is
3629 avoided. */
3631 /* Avoid expanding mempcpy into memcpy when the call is determined
3632 to overflow the buffer. This also prevents the same overflow
3633 from being diagnosed again when expanding memcpy. */
3639 }
3641 /* Helper function to do the actual work for expand of memory copy family
3642 functions (memcpy, mempcpy, stpcpy). Expansing should assign LEN bytes
3643 of memory from SRC to DEST and assign to TARGET if convenient.
3644 If ENDP is 0 return the
3645 destination pointer, if ENDP is 1 return the end pointer ala
3646 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3647 stpcpy. */
3649 static rtx
3652 {
3663 /* If DEST is not a pointer type, call the normal function. */
3667 /* If either SRC is not a pointer type, don't do this
3668 operation in-line. */
3685 /* If SRC is a string constant and block move would be done
3686 by pieces, we can avoid loading the string from memory
3687 and only stored the computed constants. */
3694 {
3696 builtin_memcpy_read_str,
3702 }
3707 /* Copy word part most expediently. */
3720 {
3723 }
3726 {
3728 /* stpcpy pointer to last byte. */
3731 }
3734 }
3736 static rtx
3739 {
3741 endp);
3742 }
3744 /* Expand into a movstr instruction, if one is available. Return NULL_RTX if
3745 we failed, the caller should emit a normal call, otherwise try to
3746 get the result in TARGET, if convenient. If ENDP is 0 return the
3747 destination pointer, if ENDP is 1 return the end pointer ala
3748 mempcpy, and if ENDP is 2 return the end pointer minus one ala
3749 stpcpy. */
3751 static rtx
3753 {
3755 rtx dest_mem;
3756 rtx src_mem;
3764 {
3767 }
3776 {
3778 /* movstr is supposed to set end to the address of the NUL
3779 terminator. If the caller requested a mempcpy-like return value,
3780 adjust it. */
3782 {
3786 }
3787 }
3789 }
3791 /* Do some very basic size validation of a call to the strcpy builtin
3792 given by EXP. Return NULL_RTX to have the built-in expand to a call
3793 to the library function. */
3795 static rtx
3797 {
3805 /* There is no way here to determine the length of the string in
3806 the destination to which the SRC string is being appended so
3807 just diagnose cases when the souce string is longer than
3808 the destination object. */
3813 destsize);
3816 }
3818 /* Expand expression EXP, which is a call to the strcpy builtin. Return
3819 NULL_RTX if we failed the caller should emit a normal call, otherwise
3820 try to get the result in TARGET, if convenient (and in mode MODE if that's
3821 convenient). */
3823 static rtx
3825 {
3833 {
3837 }
3840 {
3841 /* Check to see if the argument was declared attribute nonstring
3842 and if so, issue a warning since at this point it's not known
3843 to be nul-terminated. */
3847 }
3850 }
3852 /* Helper function to do the actual work for expand_builtin_strcpy. The
3853 arguments to the builtin_strcpy call DEST and SRC are broken out
3854 so that this can also be called without constructing an actual CALL_EXPR.
3855 The other arguments and return value are the same as for
3856 expand_builtin_strcpy. */
3858 static rtx
3860 {
3862 }
3864 /* Expand a call EXP to the stpcpy builtin.
3865 Return NULL_RTX if we failed the caller should emit a normal call,
3866 otherwise try to get the result in TARGET, if convenient (and in
3867 mode MODE if that's convenient). */
3869 static rtx
3871 {
3882 {
3886 }
3888 /* If return value is ignored, transform stpcpy into strcpy. */
3890 {
3894 }
3895 else
3896 {
3898 rtx ret;
3900 /* Ensure we get an actual string whose length can be evaluated at
3901 compile-time, not an expression containing a string. This is
3902 because the latter will potentially produce pessimized code
3903 when used to produce the return value. */
3915 {
3919 {
3923 {
3925 {
3928 else
3930 }
3939 }
3940 }
3941 }
3944 }
3945 }
3947 /* Expand a call EXP to the stpcpy builtin and diagnose uses of nonstring
3948 arguments while being careful to avoid duplicate warnings (which could
3949 be issued if the expander were to expand the call, resulting in it
3950 being emitted in expand_call(). */
3952 static rtx
3954 {
3956 {
3957 /* The call has been successfully expanded. Check for nonstring
3958 arguments and issue warnings as appropriate. */
3961 }
3964 }
3966 /* Check a call EXP to the stpncpy built-in for validity.
3967 Return NULL_RTX on both success and failure. */
3969 static rtx
3971 {
3977 /* The source and destination of the call. */
3981 /* The exact number of bytes to write (not the maximum). */
3984 /* The size of the destination object. */
3990 }
3992 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
3993 bytes from constant string DATA + OFFSET and return it as target
3994 constant. */
3996 rtx
3998 scalar_int_mode mode)
3999 {
4006 }
4008 /* Helper to check the sizes of sequences and the destination of calls
4009 to __builtin_strncat and __builtin___strncat_chk. Returns true on
4010 success (no overflow or invalid sizes), false otherwise. */
4012 static bool
4014 {
4019 /* Try to determine the range of lengths that the source expression
4020 refers to. */
4024 /* Try to verify that the destination is big enough for the shortest
4025 string. */
4028 {
4029 /* If it hasn't been provided by __strncat_chk, try to determine
4030 the size of the destination object into which the source is
4031 being copied. */
4033 }
4035 /* Add one for the terminating nul. */
4038 size_one_node)
4041 /* The strncat function copies at most MAXREAD bytes and always appends
4042 the terminating nul so the specified upper bound should never be equal
4043 to (or greater than) the size of the destination. */
4046 {
4055 }
4063 /* The number of bytes to write is LEN but check_access will also
4064 check SRCLEN if LEN's value isn't known. */
4066 objsize);
4067 }
4069 /* Similar to expand_builtin_strcat, do some very basic size validation
4070 of a call to the strcpy builtin given by EXP. Return NULL_RTX to have
4071 the built-in expand to a call to the library function. */
4073 static rtx
4075 {
4083 /* The upper bound on the number of bytes to write. */
4085 /* The length of the source sequence. */
4088 /* Try to determine the range of lengths that the source expression
4089 refers to. */
4093 else
4096 /* Try to verify that the destination is big enough for the shortest
4097 string. First try to determine the size of the destination object
4098 into which the source is being copied. */
4101 /* Add one for the terminating nul. */
4104 size_one_node)
4107 /* The strncat function copies at most MAXREAD bytes and always appends
4108 the terminating nul so the specified upper bound should never be equal
4109 to (or greater than) the size of the destination. */
4112 {
4121 }
4129 /* The number of bytes to write is SRCLEN. */
4133 }
4135 /* Expand expression EXP, which is a call to the strncpy builtin. Return
4136 NULL_RTX if we failed the caller should emit a normal call. */
4138 static rtx
4140 {
4145 {
4148 /* The number of bytes to write (not the maximum). */
4150 /* The length of the source sequence. */
4154 {
4158 /* The number of bytes to write is LEN but check_access will also
4159 check SLEN if LEN's value isn't known. */
4161 destsize);
4162 }
4164 /* We must be passed a constant len and src parameter. */
4170 /* We're required to pad with trailing zeros if the requested
4171 len is greater than strlen(s2)+1. In that case try to
4172 use store_by_pieces, if it fails, punt. */
4174 {
4177 rtx dest_mem;
4181 builtin_strncpy_read_str,
4188 builtin_strncpy_read_str,
4193 }
4194 }
4196 }
4198 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE)
4199 bytes from constant string DATA + OFFSET and return it as target
4200 constant. */
4202 rtx
4204 scalar_int_mode mode)
4205 {
4212 }
4214 /* Callback routine for store_by_pieces. Return the RTL of a register
4215 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
4216 char value given in the RTL register data. For example, if mode is
4217 4 bytes wide, return the RTL for 0x01010101*data. */
4219 static rtx
4221 scalar_int_mode mode)
4222 {
4238 }
4240 /* Expand expression EXP, which is a call to the memset builtin. Return
4241 NULL_RTX if we failed the caller should emit a normal call, otherwise
4242 try to get the result in TARGET, if convenient (and in mode MODE if that's
4243 convenient). */
4245 static rtx
4247 {
4259 }
4261 /* Helper function to do the actual work for expand_builtin_memset. The
4262 arguments to the builtin_memset call DEST, VAL, and LEN are broken out
4263 so that this can also be called without constructing an actual CALL_EXPR.
4264 The other arguments and return value are the same as for
4265 expand_builtin_memset. */
4267 static rtx
4270 {
4273 machine_mode val_mode;
4285 /* If DEST is not a pointer type, don't do this operation in-line. */
4296 /* If the LEN parameter is zero, return DEST. */
4298 {
4299 /* Evaluate and ignore VAL in case it has side-effects. */
4302 }
4304 /* Stabilize the arguments in case we fail. */
4316 {
4317 rtx val_rtx;
4322 /* Assume that we can memset by pieces if we can store
4323 * the coefficients by pieces (in the required modes).
4324 * We can't pass builtin_memset_gen_str as that emits RTL. */
4330 {
4335 }
4339 probable_max_size))
4345 }
4351 {
4362 probable_max_size))
4368 }
4376 probable_max_size);
4379 {
4382 }
4386 do_libcall:
4395 else
4400 }
4402 /* Expand expression EXP, which is a call to the bzero builtin. Return
4403 NULL_RTX if we failed the caller should emit a normal call. */
4405 static rtx
4407 {
4416 /* New argument list transforming bzero(ptr x, int y) to
4417 memset(ptr x, int 0, size_t y). This is done this way
4418 so that if it isn't expanded inline, we fallback to
4419 calling bzero instead of memset. */
4427 }
4429 /* Try to expand cmpstr operation ICODE with the given operands.
4430 Return the result rtx on success, otherwise return null. */
4432 static rtx
4434 HOST_WIDE_INT align)
4435 {
4449 }
4451 /* Expand expression EXP, which is a call to the memcmp built-in function.
4452 Return NULL_RTX if we failed and the caller should emit a normal call,
4453 otherwise try to get the result in TARGET, if convenient.
4454 RESULT_EQ is true if we can relax the returned value to be either zero
4455 or nonzero, without caring about the sign. */
4457 static rtx
4459 {
4470 /* Diagnose calls where the specified length exceeds the size of either
4471 object. */
4477 {
4482 }
4484 /* If the specified length exceeds the size of either object,
4485 call the function. */
4489 /* Due to the performance benefit, always inline the calls first
4490 when result_eq is false. */
4494 {
4498 }
4506 /* If we don't have POINTER_TYPE, call the function. */
4514 /* Set MEM_SIZE as appropriate. */
4516 {
4519 }
4525 {
4529 }
4531 /* If SRC is a string constant and block move would be done
4532 by pieces, we can avoid loading the string from memory
4533 and only stored the computed constants. */
4545 {
4546 /* Return the value in the proper mode for this function. */
4551 {
4554 }
4557 }
4560 }
4562 /* Expand expression EXP, which is a call to the strcmp builtin. Return NULL_RTX
4563 if we failed the caller should emit a normal call, otherwise try to get
4564 the result in TARGET, if convenient. */
4566 static rtx
4568 {
4572 /* Due to the performance benefit, always inline the calls first. */
4589 /* If we don't have POINTER_TYPE, call the function. */
4593 /* Stabilize the arguments in case gen_cmpstr(n)si fail. */
4600 /* Try to call cmpstrsi. */
4605 /* Try to determine at least one length and call cmpstrnsi. */
4607 {
4608 tree len;
4609 rtx arg3_rtx;
4619 /* If we don't have a constant length for the first, use the length
4620 of the second, if we know it. We don't require a constant for
4621 this case; some cost analysis could be done if both are available
4622 but neither is constant. For now, assume they're equally cheap,
4623 unless one has side effects. If both strings have constant lengths,
4624 use the smaller. */
4640 else
4643 /* If both arguments have side effects, we cannot optimize. */
4645 {
4647 result = expand_cmpstrn_or_cmpmem
4650 }
4651 }
4655 {
4656 /* Check to see if the argument was declared attribute nonstring
4657 and if so, issue a warning since at this point it's not known
4658 to be nul-terminated. */
4661 /* Return the value in the proper mode for this function. */
4669 }
4671 /* Expand the library call ourselves using a stabilized argument
4672 list to avoid re-evaluating the function's arguments twice. */
4677 }
4679 /* Expand expression EXP, which is a call to the strncmp builtin. Return
4680 NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
4681 the result in TARGET, if convenient. */
4683 static rtx
4685 ATTRIBUTE_UNUSED machine_mode mode)
4686 {
4691 /* Due to the performance benefit, always inline the calls first. */
4697 /* If c_strlen can determine an expression for one of the string
4698 lengths, and it doesn't have side effects, then emit cmpstrnsi
4699 using length MIN(strlen(string)+1, arg3). */
4704 tree len;
4725 /* If we don't have a constant length for the first, use the length
4726 of the second, if we know it. If neither string is constant length,
4727 use the given length argument. We don't require a constant for
4728 this case; some cost analysis could be done if both are available
4729 but neither is constant. For now, assume they're equally cheap,
4730 unless one has side effects. If both strings have constant lengths,
4731 use the smaller. */
4749 else
4752 /* If we are not using the given length, we must incorporate it here.
4753 The actual new length parameter will be MIN(len,arg3) in this case. */
4765 {
4766 /* Check to see if the argument was declared attribute nonstring
4767 and if so, issue a warning since at this point it's not known
4768 to be nul-terminated. */
4771 /* Return the value in the proper mode for this function. */
4779 }
4781 /* Expand the library call ourselves using a stabilized argument
4782 list to avoid re-evaluating the function's arguments twice. */
4787 }
4789 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4790 if that's convenient. */
4792 rtx
4794 {
4795 rtx val;
4798 /* Don't do __builtin_saveregs more than once in a function.
4799 Save the result of the first call and reuse it. */
4803 /* When this function is called, it means that registers must be
4804 saved on entry to this function. So we migrate the call to the
4805 first insn of this function. */
4809 /* Do whatever the machine needs done in this case. */
4817 /* Put the insns after the NOTE that starts the function. If this
4818 is inside a start_sequence, make the outer-level insn chain current, so
4819 the code is placed at the start of the function. */
4825 }
4827 /* Expand a call to __builtin_next_arg. */
4829 static rtx
4831 {
4832 /* Checking arguments is already done in fold_builtin_next_arg
4833 that must be called before this function. */
4838 }
4840 /* Make it easier for the backends by protecting the valist argument
4841 from multiple evaluations. */
4843 static tree
4845 {
4848 /* The current way of determining the type of valist is completely
4849 bogus. We should have the information on the va builtin instead. */
4854 {
4858 /* For this case, the backends will be expecting a pointer to
4859 vatype, but it's possible we've actually been given an array
4860 (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4861 So fix it. */
4863 {
4866 }
4867 }
4868 else
4869 {
4873 {
4879 }
4885 }
4888 }
4890 /* The "standard" definition of va_list is void*. */
4892 tree
4894 {
4896 }
4898 /* The "standard" abi va_list is va_list_type_node. */
4900 tree
4902 {
4904 }
4906 /* The "standard" type of va_list is va_list_type_node. */
4908 tree
4910 {
4917 {
4918 /* If va_list is an array type, the argument may have decayed
4919 to a pointer type, e.g. by being passed to another function.
4920 In that case, unwrap both types so that we can compare the
4921 underlying records. */
4924 {
4927 }
4928 }
4933 }
4935 /* The "standard" implementation of va_start: just assign `nextarg' to
4936 the variable. */
4938 void
4940 {
4943 }
4945 /* Expand EXP, a call to __builtin_va_start. */
4947 static rtx
4949 {
4950 rtx nextarg;
4951 tree valist;
4955 {
4958 }
4968 else
4972 }
4974 /* Expand EXP, a call to __builtin_va_end. */
4976 static rtx
4978 {
4981 /* Evaluate for side effects, if needed. I hate macros that don't
4982 do that. */
4987 }
4989 /* Expand EXP, a call to __builtin_va_copy. We do this as a
4990 builtin rather than just as an assignment in stdarg.h because of the
4991 nastiness of array-type va_list types. */
4993 static rtx
4995 {
5008 {
5012 }
5013 else
5014 {
5017 /* Evaluate to pointers. */
5026 /* "Dereference" to BLKmode memories. */
5034 /* Copy. */
5036 }
5039 }
5041 /* Expand a call to one of the builtin functions __builtin_frame_address or
5042 __builtin_return_address. */
5044 static rtx
5046 {
5047 /* The argument must be a nonnegative integer constant.
5048 It counts the number of frames to scan up the stack.
5049 The value is either the frame pointer value or the return
5050 address saved in that frame. */
5052 /* Warning about missing arg was already issued. */
5055 {
5058 }
5059 else
5060 {
5061 /* Number of frames to scan up the stack. */
5066 /* Some ports cannot access arbitrary stack frames. */
5068 {
5071 }
5074 {
5075 /* Warn since no effort is made to ensure that any frame
5076 beyond the current one exists or can be safely reached. */
5079 }
5081 /* For __builtin_frame_address, return what we've got. */
5089 }
5090 }
5092 /* Expand EXP, a call to the alloca builtin. Return NULL_RTX if we
5093 failed and the caller should emit a normal call. */
5095 static rtx
5097 {
5098 rtx op0;
5099 rtx result;
5102 HOST_WIDE_INT max_size;
5105 bool valid_arglist
5108 VOID_TYPE)
5119 || (!alloca_for_var
5122 ))
5123 {
5124 /* -Walloca-larger-than and -Wvla-larger-than settings of
5125 less than HOST_WIDE_INT_MAX override the more general
5126 -Walloc-size-larger-than so unless either of the former
5127 options is smaller than the last one (wchich would imply
5128 that the call was already checked), check the alloca
5129 arguments for overflow. */
5133 }
5135 /* Compute the argument. */
5138 /* Compute the alignment. */
5140 ? BIGGEST_ALIGNMENT
5143 /* Compute the maximum size. */
5148 /* Allocate the desired space. If the allocation stems from the declaration
5149 of a variable-sized object, it cannot accumulate. */
5150 result
5155 }
5157 /* Emit a call to __asan_allocas_unpoison call in EXP. Add to second argument
5158 of the call virtual_stack_dynamic_rtx - stack_pointer_rtx, which is the
5159 STACK_DYNAMIC_OFFSET value. See motivation for this in comment to
5160 handle_builtin_stack_restore function. */
5162 static rtx
5164 {
5171 OPTAB_LIB_WIDEN);
5174 OPTAB_LIB_WIDEN);
5179 }
5181 /* Expand a call to bswap builtin in EXP.
5182 Return NULL_RTX if a normal call should be emitted rather than expanding the
5183 function in-line. If convenient, the result should be placed in TARGET.
5184 SUBTARGET may be used as the target for computing one of EXP's operands. */
5186 static rtx
5188 rtx subtarget)
5189 {
5190 tree arg;
5191 rtx op0;
5209 }
5211 /* Expand a call to a unary builtin in EXP.
5212 Return NULL_RTX if a normal call should be emitted rather than expanding the
5213 function in-line. If convenient, the result should be placed in TARGET.
5214 SUBTARGET may be used as the target for computing one of EXP's operands. */
5216 static rtx
5219 {
5220 rtx op0;
5225 /* Compute the argument. */
5227 (subtarget
5231 /* Compute op, into TARGET if possible.
5232 Set TARGET to wherever the result comes back. */
5238 }
5240 /* Expand a call to __builtin_expect. We just return our argument
5241 as the builtin_expect semantic should've been already executed by
5242 tree branch prediction pass. */
5244 static rtx
5246 {
5247 tree arg;
5254 /* When guessing was done, the hints should be already stripped away. */
5258 }
5260 /* Expand a call to __builtin_expect_with_probability. We just return our
5261 argument as the builtin_expect semantic should've been already executed by
5262 tree branch prediction pass. */
5264 static rtx
5266 {
5267 tree arg;
5274 /* When guessing was done, the hints should be already stripped away. */
5278 }
5281 /* Expand a call to __builtin_assume_aligned. We just return our first
5282 argument as the builtin_assume_aligned semantic should've been already
5283 executed by CCP. */
5285 static rtx
5287 {
5291 EXPAND_NORMAL);
5296 }
5298 void
5300 {
5302 {
5304 /* For trap insns when not accumulating outgoing args force
5305 REG_ARGS_SIZE note to prevent crossjumping of calls with
5306 different args sizes. */
5309 }
5310 else
5311 {
5315 }
5318 }
5320 /* Expand a call to __builtin_unreachable. We do nothing except emit
5321 a barrier saying that control flow will not pass here.
5323 It is the responsibility of the program being compiled to ensure
5324 that control flow does never reach __builtin_unreachable. */
5325 static void
5327 {
5329 }
5331 /* Expand EXP, a call to fabs, fabsf or fabsl.
5332 Return NULL_RTX if a normal call should be emitted rather than expanding
5333 the function inline. If convenient, the result should be placed
5334 in TARGET. SUBTARGET may be used as the target for computing
5335 the operand. */
5337 static rtx
5339 {
5340 machine_mode mode;
5341 tree arg;
5342 rtx op0;
5352 }
5354 /* Expand EXP, a call to copysign, copysignf, or copysignl.
5355 Return NULL is a normal call should be emitted rather than expanding the
5356 function inline. If convenient, the result should be placed in TARGET.
5357 SUBTARGET may be used as the target for computing the operand. */
5359 static rtx
5361 {
5363 tree arg;
5375 }
5377 /* Expand a call to __builtin___clear_cache. */
5379 static rtx
5381 {
5383 {
5384 #ifdef CLEAR_INSN_CACHE
5385 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5386 does something. Just do the default expansion to a call to
5387 __clear_cache(). */
5389 #else
5390 /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5391 does nothing. There is no need to call it. Do nothing. */
5394 }
5396 /* We have a "clear_cache" insn, and it will handle everything. */
5400 /* We must not expand to a library call. If we did, any
5401 fallback library function in libgcc that might contain a call to
5402 __builtin___clear_cache() would recurse infinitely. */
5404 {
5407 }
5410 {
5423 }
5425 }
5427 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */
5429 static rtx
5431 {
5434 /* If we don't need too much alignment, we'll have been guaranteed
5435 proper alignment by get_trampoline_type. */
5439 /* Round address up to desired boundary. */
5450 }
5452 static rtx
5454 {
5470 /* If ONSTACK, the TRAMP argument should be the address of a field
5471 within the local function's FRAME decl. Either way, let's see if
5472 we can fill in the MEM_ATTRs for this memory. */
5476 /* Creator of a heap trampoline is responsible for making sure the
5477 address is aligned to at least STACK_BOUNDARY. Normally malloc
5478 will ensure this anyhow. */
5481 {
5485 }
5487 /* The FUNC argument should be the address of the nested function.
5488 Extract the actual function decl to pass to the hook. */
5495 /* Generate insns to initialize the trampoline. */
5499 {
5505 }
5508 }
5510 static rtx
5512 {
5513 rtx tramp;
5524 }
5526 /* Expand a call to the builtin descriptor initialization routine.
5527 A descriptor is made up of a couple of pointers to the static
5528 chain and the code entry in this order. */
5530 static rtx
5532 {
5537 VOID_TYPE))
5551 /* Generate insns to initialize the descriptor. */
5557 }
5559 /* Expand a call to the builtin descriptor adjustment routine. */
5561 static rtx
5563 {
5564 rtx tramp;
5571 /* Unalign the descriptor to allow runtime identification. */
5576 }
5578 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
5579 function. The function first checks whether the back end provides
5580 an insn to implement signbit for the respective mode. If not, it
5581 checks whether the floating point format of the value is such that
5582 the sign bit can be extracted. If that is not the case, error out.
5583 EXP is the expression that is a call to the builtin function; if
5584 convenient, the result should be placed in TARGET. */
5585 static rtx
5587 {
5589 scalar_float_mode fmode;
5591 tree arg;
5594 rtx temp;
5607 /* Expand the argument yielding a RTX expression. */
5610 /* Check if the back end provides an insn that handles signbit for the
5611 argument's mode. */
5614 {
5620 }
5622 /* For floating point formats without a sign bit, implement signbit
5623 as "ARG < 0.0". */
5626 {
5627 /* But we can't do this if the format supports signed zero. */
5633 }
5636 {
5639 }
5640 else
5641 {
5643 /* Handle targets with different FP word orders. */
5646 else
5650 }
5652 /* Force the intermediate word_mode (or narrower) result into a
5653 register. This avoids attempting to create paradoxical SUBREGs
5654 of floating point modes below. */
5657 /* If the bitpos is within the "result mode" lowpart, the operation
5658 can be implement with a single bitwise AND. Otherwise, we need
5659 a right shift and an AND. */
5662 {
5670 }
5671 else
5672 {
5673 /* Perform a logical right shift to place the signbit in the least
5674 significant bit, then truncate the result to the desired mode
5675 and mask just this bit. */
5680 }
5683 }
5685 /* Expand fork or exec calls. TARGET is the desired target of the
5686 call. EXP is the call. FN is the
5687 identificator of the actual function. IGNORE is nonzero if the
5688 value is to be ignored. */
5690 static rtx
5692 {
5694 tree call;
5696 /* If we are not profiling, just call the function. */
5700 /* Otherwise call the wrapper. This should be equivalent for the rest of
5701 compiler, so the code does not diverge, and the wrapper may run the
5702 code necessary for keeping the profiling sane. */
5705 {
5736 }
5748 }
5751 \f
5752 /* Reconstitute a mode for a __sync intrinsic operation. Since the type of
5753 the pointer in these functions is void*, the tree optimizers may remove
5754 casts. The mode computed in expand_builtin isn't reliable either, due
5755 to __sync_bool_compare_and_swap.
5757 FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5758 group of builtins. This gives us log2 of the mode size. */
5762 {
5763 /* The size is not negotiable, so ask not to get BLKmode in return
5764 if the target indicates that a smaller size would be better. */
5766 }
5768 /* Expand the memory expression LOC and return the appropriate memory operand
5769 for the builtin_sync operations. */
5771 static rtx
5773 {
5779 /* Note that we explicitly do not want any alias information for this
5780 memory, so that we kill all other live memories. Otherwise we don't
5781 satisfy the full barrier semantics of the intrinsic. */
5784 /* The alignment needs to be at least according to that of the mode. */
5791 }
5793 /* Make sure an argument is in the right mode.
5794 EXP is the tree argument.
5795 MODE is the mode it should be in. */
5797 static rtx
5799 {
5800 rtx val;
5801 machine_mode old_mode;
5804 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care
5805 of CONST_INTs, where we know the old_mode only from the call argument. */
5812 }
5815 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5816 EXP is the CALL_EXPR. CODE is the rtx code
5817 that corresponds to the arithmetic or logical operation from the name;
5818 an exception here is that NOT actually means NAND. TARGET is an optional
5819 place for us to store the results; AFTER is true if this is the
5820 fetch_and_xxx form. */
5822 static rtx
5825 rtx target)
5826 {
5831 {
5838 {
5867 }
5868 }
5870 /* Expand the operands. */
5875 after);
5876 }
5878 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5879 intrinsics. EXP is the CALL_EXPR. IS_BOOL is
5880 true if this is the boolean form. TARGET is a place for us to store the
5881 results; this is NOT optional if IS_BOOL is true. */
5883 static rtx
5886 {
5890 /* Expand the operands. */
5897 {
5900 else
5902 }
5905 MEMMODEL_SYNC_SEQ_CST))
5909 }
5911 /* Expand the __sync_lock_test_and_set intrinsic. Note that the most
5912 general form is actually an atomic exchange, and some targets only
5913 support a reduced form with the second argument being a constant 1.
5914 EXP is the CALL_EXPR; TARGET is an optional place for us to store
5915 the results. */
5917 static rtx
5919 rtx target)
5920 {
5923 /* Expand the operands. */
5928 }
5930 /* Expand the __sync_lock_release intrinsic. EXP is the CALL_EXPR. */
5932 static void
5934 {
5935 rtx mem;
5937 /* Expand the operands. */
5941 }
5943 /* Given an integer representing an ``enum memmodel'', verify its
5944 correctness and return the memory model enum. */
5946 static enum memmodel
5948 {
5949 rtx op;
5951 source_location loc
5954 /* If the parameter is not a constant, it's a run time value so we'll just
5955 convert it to MEMMODEL_SEQ_CST to avoid annoying runtime checking. */
5965 {
5969 }
5971 /* Should never see a user explicit SYNC memodel model, so >= LAST works. */
5973 {
5977 }
5979 /* Workaround for Bugzilla 59448. GCC doesn't track consume properly, so
5980 be conservative and promote consume to acquire. */
5985 }
5987 /* Expand the __atomic_exchange intrinsic:
5988 TYPE __atomic_exchange (TYPE *object, TYPE desired, enum memmodel)
5989 EXP is the CALL_EXPR.
5990 TARGET is an optional place for us to store the results. */
5992 static rtx
5994 {
6003 /* Expand the operands. */
6008 }
6010 /* Expand the __atomic_compare_exchange intrinsic:
6011 bool __atomic_compare_exchange (TYPE *object, TYPE *expect,
6012 TYPE desired, BOOL weak,
6013 enum memmodel success,
6014 enum memmodel failure)
6015 EXP is the CALL_EXPR.
6016 TARGET is an optional place for us to store the results. */
6018 static rtx
6020 rtx target)
6021 {
6025 tree weak;
6027 source_location loc
6034 {
6036 "failure memory model cannot be stronger than success "
6039 }
6042 {
6044 "invalid failure memory model for "
6048 }
6054 /* Expand the operands. */
6070 /* Lest the rtl backend create a race condition with an imporoper store
6071 to memory, always create a new pseudo for OLDVAL. */
6078 /* Conditionally store back to EXPECT, lest we create a race condition
6079 with an improper store to memory. */
6080 /* ??? With a rearrangement of atomics at the gimple level, we can handle
6081 the normal case where EXPECT is totally private, i.e. a register. At
6082 which point the store can be unconditional. */
6090 }
6092 /* Helper function for expand_ifn_atomic_compare_exchange - expand
6093 internal ATOMIC_COMPARE_EXCHANGE call into __atomic_compare_exchange_N
6094 call. The weak parameter must be dropped to match the expected parameter
6095 list and the expected argument changed from value to pointer to memory
6096 slot. */
6098 static void
6100 {
6116 /* Skip the boolean weak parameter. */
6119 /* At present we only have BUILT_IN_ATOMIC_COMPARE_EXCHANGE_{1,2,4,8,16}. */
6122 built_in_function fncode
6127 fndecl);
6132 {
6139 }
6140 }
6142 /* Expand IFN_ATOMIC_COMPARE_EXCHANGE internal function. */
6144 void
6146 {
6152 tree lhs;
6154 source_location loc
6161 {
6163 "failure memory model cannot be stronger than success "
6166 }
6169 {
6171 "invalid failure memory model for "
6175 }
6178 {
6181 }
6183 /* Expand the operands. */
6196 {
6199 }
6203 {
6209 }
6210 }
6212 /* Expand the __atomic_load intrinsic:
6213 TYPE __atomic_load (TYPE *object, enum memmodel)
6214 EXP is the CALL_EXPR.
6215 TARGET is an optional place for us to store the results. */
6217 static rtx
6219 {
6220 rtx mem;
6225 {
6226 source_location loc
6231 }
6236 /* Expand the operand. */
6240 }
6243 /* Expand the __atomic_store intrinsic:
6244 void __atomic_store (TYPE *object, TYPE desired, enum memmodel)
6245 EXP is the CALL_EXPR.
6246 TARGET is an optional place for us to store the results. */
6248 static rtx
6250 {
6257 {
6258 source_location loc
6263 }
6268 /* Expand the operands. */
6273 }
6275 /* Expand the __atomic_fetch_XXX intrinsic:
6276 TYPE __atomic_fetch_XXX (TYPE *object, TYPE val, enum memmodel)
6277 EXP is the CALL_EXPR.
6278 TARGET is an optional place for us to store the results.
6279 CODE is the operation, PLUS, MINUS, ADD, XOR, or IOR.
6280 FETCH_AFTER is true if returning the result of the operation.
6281 FETCH_AFTER is false if returning the value before the operation.
6282 IGNORE is true if the result is not used.
6283 EXT_CALL is the correct builtin for an external call if this cannot be
6284 resolved to an instruction sequence. */
6286 static rtx
6290 {
6293 tree fndecl;
6294 tree addr;
6298 /* Expand the operands. */
6302 /* Only try generating instructions if inlining is turned on. */
6304 {
6308 }
6310 /* Return if a different routine isn't needed for the library call. */
6314 /* Change the call to the specified function. */
6322 /* If we will emit code after the call, the call can not be a tail call.
6323 If it is emitted as a tail call, a barrier is emitted after it, and
6324 then all trailing code is removed. */
6328 /* Expand the call here so we can emit trailing code. */
6331 /* Replace the original function just in case it matters. */
6334 /* Then issue the arithmetic correction to return the right result. */
6336 {
6338 {
6340 OPTAB_LIB_WIDEN);
6342 }
6343 else
6345 OPTAB_LIB_WIDEN);
6346 }
6348 }
6350 /* Expand IFN_ATOMIC_BIT_TEST_AND_* internal function. */
6352 void
6354 {
6362 optab optab;
6374 {
6389 }
6392 {
6399 }
6421 {
6426 }
6427 else
6429 OPTAB_DIRECT);
6432 }
6434 /* Expand an atomic clear operation.
6435 void _atomic_clear (BOOL *obj, enum memmodel)
6436 EXP is the call expression. */
6438 static rtx
6440 {
6441 machine_mode mode;
6450 {
6451 source_location loc
6456 }
6458 /* Try issuing an __atomic_store, and allow fallback to __sync_lock_release.
6459 Failing that, a store is issued by __atomic_store. The only way this can
6460 fail is if the bool type is larger than a word size. Unlikely, but
6461 handle it anyway for completeness. Assume a single threaded model since
6462 there is no atomic support in this case, and no barriers are required. */
6467 }
6469 /* Expand an atomic test_and_set operation.
6470 bool _atomic_test_and_set (BOOL *obj, enum memmodel)
6471 EXP is the call expression. */
6473 static rtx
6475 {
6476 rtx mem;
6478 machine_mode mode;
6485 }
6488 /* Return true if (optional) argument ARG1 of size ARG0 is always lock free on
6489 this architecture. If ARG1 is NULL, use typical alignment for size ARG0. */
6491 static tree
6493 {
6495 machine_mode mode;
6501 /* We need a corresponding integer mode for the access to be lock-free. */
6509 {
6512 /* Either this argument is null, or it's a fake pointer encoding
6513 the alignment of the object. */
6519 else
6521 }
6522 else
6523 {
6526 /* This function is usually invoked and folded immediately by the front
6527 end before anything else has a chance to look at it. The pointer
6528 parameter at this point is usually cast to a void *, so check for that
6529 and look past the cast. */
6539 /* Get the underlying type of the object. */
6542 }
6544 /* If the object has smaller alignment, the lock free routines cannot
6545 be used. */
6549 /* Check if a compare_and_swap pattern exists for the mode which represents
6550 the required size. The pattern is not allowed to fail, so the existence
6551 of the pattern indicates support is present. Also require that an
6552 atomic load exists for the required size. */
6555 else
6557 }
6559 /* Return true if the parameters to call EXP represent an object which will
6560 always generate lock free instructions. The first argument represents the
6561 size of the object, and the second parameter is a pointer to the object
6562 itself. If NULL is passed for the object, then the result is based on
6563 typical alignment for an object of the specified size. Otherwise return
6564 false. */
6566 static rtx
6568 {
6569 tree size;
6574 {
6577 }
6583 }
6585 /* Return a one or zero if it can be determined that object ARG1 of size ARG
6586 is lock free on this architecture. */
6588 static tree
6590 {
6594 /* If it isn't always lock free, don't generate a result. */
6599 }
6601 /* Return true if the parameters to call EXP represent an object which will
6602 always generate lock free instructions. The first argument represents the
6603 size of the object, and the second parameter is a pointer to the object
6604 itself. If NULL is passed for the object, then the result is based on
6605 typical alignment for an object of the specified size. Otherwise return
6606 NULL*/
6608 static rtx
6610 {
6611 tree size;
6616 {
6619 }
6624 /* If the value is known at compile time, return the RTX for it. */
6630 }
6632 /* Expand the __atomic_thread_fence intrinsic:
6633 void __atomic_thread_fence (enum memmodel)
6634 EXP is the CALL_EXPR. */
6636 static void
6638 {
6641 }
6643 /* Expand the __atomic_signal_fence intrinsic:
6644 void __atomic_signal_fence (enum memmodel)
6645 EXP is the CALL_EXPR. */
6647 static void
6649 {
6652 }
6654 /* Expand the __sync_synchronize intrinsic. */
6656 static void
6658 {
6660 }
6662 static rtx
6664 {
6670 {
6672 /* If the target is not sutitable then create a new target. */
6680 }
6683 }
6685 static void
6687 {
6693 {
6700 }
6702 }
6704 \f
6705 /* Emit code to restore the current value of stack. */
6707 static void
6709 {
6721 }
6723 /* Emit code to save the current value of stack. */
6725 static rtx
6727 {
6732 }
6734 /* Emit code to get the openacc gang, worker or vector id or size. */
6736 static rtx
6738 {
6740 rtx fallback_retval;
6743 {
6756 }
6759 {
6762 }
6766 {
6769 }
6773 {
6781 }
6790 {
6793 }
6801 }
6803 /* Expand a string compare operation using a sequence of char comparison
6804 to get rid of the calling overhead, with result going to TARGET if
6805 that's convenient.
6807 VAR_STR is the variable string source;
6808 CONST_STR is the constant string source;
6809 LENGTH is the number of chars to compare;
6810 CONST_STR_N indicates which source string is the constant string;
6811 IS_MEMCMP indicates whether it's a memcmp or strcmp.
6813 to: (assume const_str_n is 2, i.e., arg2 is a constant string)
6815 target = (int) (unsigned char) var_str[0]
6816 - (int) (unsigned char) const_str[0];
6817 if (target != 0)
6818 goto ne_label;
6819 ...
6820 target = (int) (unsigned char) var_str[length - 2]
6821 - (int) (unsigned char) const_str[length - 2];
6822 if (target != 0)
6823 goto ne_label;
6824 target = (int) (unsigned char) var_str[length - 1]
6825 - (int) (unsigned char) const_str[length - 1];
6826 ne_label:
6827 */
6829 static rtx
6833 {
6835 rtx var_rtx_array
6842 scalar_int_mode unit_mode
6848 {
6849 var_rtx
6863 }
6871 }
6873 /* Inline expansion a call to str(n)cmp, with result going to
6874 TARGET if that's convenient.
6875 If the call is not been inlined, return NULL_RTX. */
6876 static rtx
6878 {
6884 /* Do NOT apply this inlining expansion when optimizing for size or
6885 optimization level below 2. */
6893 /* On a target where the type of the call (int) has same or narrower presicion
6894 than unsigned char, give up the inlining expansion. */
6910 /* If neither strings is constant string, the call is not qualify. */
6914 /* For strncmp, if the length is not a const, not qualify. */
6925 else
6934 /* If the length of the comparision is larger than the threshold,
6935 do nothing. */
6942 /* Now, start inline expansion the call. */
6946 }
6948 /* Expand a call to __builtin_speculation_safe_value_<N>. MODE
6949 represents the size of the first argument to that call, or VOIDmode
6950 if the argument is a pointer. IGNORE will be true if the result
6951 isn't used. */
6952 static rtx
6955 {
6962 {
6965 }
6969 /* An optional second argument can be used as a failsafe value on
6970 some machines. If it isn't present, then the failsafe value is
6971 assumed to be 0. */
6973 {
6976 }
6977 else
6980 /* If the result isn't used, the behavior is undefined. It would be
6981 nice to emit a warning here, but path splitting means this might
6982 happen with legitimate code. So simply drop the builtin
6983 expansion in that case; we've handled any side-effects above. */
6987 /* If we don't have a suitable target, create one to hold the result. */
6995 }
6997 /* Expand an expression EXP that calls a built-in function,
6998 with result going to TARGET if that's convenient
6999 (and in mode MODE if that's convenient).
7000 SUBTARGET may be used as the target for computing one of EXP's operands.
7001 IGNORE is nonzero if the value is to be ignored. */
7003 rtx
7006 {
7015 /* When ASan is enabled, we don't want to expand some memory/string
7016 builtins and rely on libsanitizer's hooks. This allows us to avoid
7017 redundant checks and be sure, that possible overflow will be detected
7018 by ASan. */
7023 /* When not optimizing, generate calls to library functions for a certain
7024 set of builtins. */
7038 /* The built-in function expanders test for target == const0_rtx
7039 to determine whether the function's result will be ignored. */
7043 /* If the result of a pure or const built-in function is ignored, and
7044 none of its arguments are volatile, we can avoid expanding the
7045 built-in call and just evaluate the arguments for side-effects. */
7049 {
7051 tree arg;
7052 call_expr_arg_iterator iter;
7056 {
7059 }
7062 {
7066 }
7067 }
7070 {
7088 /* Just do a normal library call if we were unable to fold
7089 the values. */
7166 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
7167 FUNCTION with a copy of the parameters described by
7168 ARGUMENTS, and ARGSIZE. It returns a block of memory
7169 allocated on the stack into which is stored all the registers
7170 that might possibly be used for returning the result of a
7171 function. ARGUMENTS is the value returned by
7172 __builtin_apply_args. ARGSIZE is the number of bytes of
7173 arguments that must be copied. ??? How should this value be
7174 computed? We'll also need a safe worst case value for varargs
7175 functions. */
7182 else
7183 {
7191 }
7193 /* __builtin_return (RESULT) causes the function to return the
7194 value described by RESULT. RESULT is address of the block of
7195 memory returned by __builtin_apply. */
7205 /* All valid uses of __builtin_va_arg_pack () are removed during
7206 inlining. */
7211 /* All valid uses of __builtin_va_arg_pack_len () are removed during
7212 inlining. */
7216 /* Return the address of the first anonymous stack arg. */
7238 /* Returns the address of the area where the structure is returned.
7239 0 otherwise. */
7245 else
7248 CASE_BUILT_IN_ALLOCA:
7398 /* Expand it as BUILT_IN_MEMCMP_EQ first. If not successful, change it
7399 back to a BUILT_IN_STRCMP. Remember to delete the 3rd paramater
7400 when changing it to a strcmp call. */
7406 /* Change this call back to a BUILT_IN_STRCMP. */
7410 /* Delete the last parameter. */
7417 /* FALLTHROUGH */
7425 /* Expand it as BUILT_IN_MEMCMP_EQ first. If not successful, change it
7426 back to a BUILT_IN_STRNCMP. */
7432 /* Change it back to a BUILT_IN_STRNCMP. */
7435 /* FALLTHROUGH */
7450 {
7453 }
7457 /* This should have been lowered to the builtins below. */
7461 /* __builtin_setjmp_setup is passed a pointer to an array of five words
7462 and the receiver label. */
7464 {
7470 /* This is copied from the handling of non-local gotos. */
7472 nonlocal_goto_handler_labels
7474 nonlocal_goto_handler_labels);
7475 /* ??? Do not let expand_label treat us as such since we would
7476 not want to be both on the list of non-local labels and on
7477 the list of forced labels. */
7480 }
7484 /* __builtin_setjmp_receiver is passed the receiver label. */
7486 {
7492 }
7495 /* __builtin_longjmp is passed a pointer to an array of five words.
7496 It's similar to the C library longjmp function but works with
7497 __builtin_setjmp above. */
7500 {
7506 {
7509 }
7513 }
7522 /* This updates the setjmp buffer that is its argument with the value
7523 of the current stack pointer. */
7526 {
7527 rtx buf_addr
7532 }
7552 /* Various hooks for the DWARF 2 __throw routine. */
7558 #ifdef DWARF2_UNWIND_INFO
7564 #endif
7766 mode = get_builtin_sync_mode
7778 mode = get_builtin_sync_mode
7825 {
7829 mode =
7835 /* If this is turned into an external library call, the weak parameter
7836 must be dropped to match the expected parameter list. */
7841 /* Skip the boolean weak parameter. */
7846 }
7875 {
7885 }
7891 {
7901 }
7907 {
7917 }
7923 {
7933 }
7939 {
7949 }
7955 {
7965 }
8102 /* Do library call, if we failed to expand the builtin when
8103 folding. */
8123 }
8125 /* The switch statement above can drop through to cause the function
8126 to be called normally. */
8128 }
8130 /* Determine whether a tree node represents a call to a built-in
8131 function. If the tree T is a call to a built-in function with
8132 the right number of arguments of the appropriate types, return
8133 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
8134 Otherwise the return value is END_BUILTINS. */
8136 enum built_in_function
8138 {
8141 const_call_expr_arg_iterator iter;
8156 {
8157 /* If a function doesn't take a variable number of arguments,
8158 the last element in the list will have type `void'. */
8161 {
8165 }
8174 {
8177 }
8179 {
8182 }
8184 {
8187 }
8189 {
8192 }
8193 else
8195 }
8197 /* Variable-length argument list. */
8199 }
8201 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
8202 evaluate to a constant. */
8204 static tree
8206 {
8207 /* We return 1 for a numeric type that's known to be a constant
8208 value at compile-time or for an aggregate type that's a
8209 literal constant. */
8212 /* If we know this is a constant, emit the constant of one. */
8218 {
8225 }
8227 /* If this expression has side effects, show we don't know it to be a
8228 constant. Likewise if it's a pointer or aggregate type since in
8229 those case we only want literals, since those are only optimized
8230 when generating RTL, not later.
8231 And finally, if we are compiling an initializer, not code, we
8232 need to return a definite result now; there's not going to be any
8233 more optimization done. */
8238 || folding_initializer
8243 }
8245 /* Create builtin_expect or builtin_expect_with_probability
8246 with PRED and EXPECTED as its arguments and return it as a truthvalue.
8247 Fortran FE can also produce builtin_expect with PREDICTOR as third argument.
8248 builtin_expect_with_probability instead uses third argument as PROBABILITY
8249 value. */
8251 static tree
8254 {
8269 else
8271 predictor);
8275 }
8277 /* Fold a call to builtin_expect with arguments ARG0, ARG1, ARG2, ARG3. Return
8278 NULL_TREE if no simplification is possible. */
8280 tree
8282 tree arg3)
8283 {
8287 /* Distribute the expected value over short-circuiting operators.
8288 See through the cast from truthvalue_type_node to long. */
8295 /* If this is a builtin_expect within a builtin_expect keep the
8296 inner one. See through a comparison against a constant. It
8297 might have been added to create a thruthvalue. */
8308 BUILT_IN_EXPECT_WITH_PROBABILITY)))
8314 {
8324 }
8326 /* If the argument isn't invariant then there's nothing else we can do. */
8330 /* If we expect that a comparison against the argument will fold to
8331 a constant return the constant. In practice, this means a true
8332 constant or the address of a non-weak symbol. */
8336 {
8337 do
8338 {
8340 }
8345 }
8347 /* Otherwise, ARG0 already has the proper type for the return value. */
8349 }
8351 /* Fold a call to __builtin_classify_type with argument ARG. */
8353 static tree
8355 {
8360 }
8362 /* Fold a call to __builtin_strlen with argument ARG. */
8364 static tree
8366 {
8369 else
8370 {
8377 }
8378 }
8380 /* Fold a call to __builtin_inf or __builtin_huge_val. */
8382 static tree
8384 {
8385 REAL_VALUE_TYPE real;
8387 /* __builtin_inff is intended to be usable to define INFINITY on all
8388 targets. If an infinity is not available, INFINITY expands "to a
8389 positive constant of type float that overflows at translation
8390 time", footnote "In this case, using INFINITY will violate the
8391 constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
8392 Thus we pedwarn to ensure this constraint violation is
8393 diagnosed. */
8399 }
8401 /* Fold function call to builtin sincos, sincosf, or sincosl. Return
8402 NULL_TREE if no simplification can be made. */
8404 static tree
8407 {
8408 tree type;
8418 /* Calculate the result when the argument is a constant. */
8423 /* Canonicalize sincos to cexpi. */
8425 {
8428 }
8430 {
8437 }
8449 }
8451 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
8452 Return NULL_TREE if no simplification can be made. */
8454 static tree
8456 {
8462 /* If the LEN parameter is zero, return zero. */
8467 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
8471 /* If len parameter is one, return an expression corresponding to
8472 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */
8474 {
8476 tree cst_uchar_ptr_node
8479 tree ind1
8483 cst_uchar_ptr_node,
8484 arg1)));
8485 tree ind2
8489 cst_uchar_ptr_node,
8490 arg2)));
8492 }
8495 }
8497 /* Fold a call to builtin isascii with argument ARG. */
8499 static tree
8501 {
8504 else
8505 {
8506 /* Transform isascii(c) -> ((c & ~0x7f) == 0). */
8512 }
8513 }
8515 /* Fold a call to builtin toascii with argument ARG. */
8517 static tree
8519 {
8523 /* Transform toascii(c) -> (c & 0x7f). */
8526 }
8528 /* Fold a call to builtin isdigit with argument ARG. */
8530 static tree
8532 {
8535 else
8536 {
8537 /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */
8538 /* According to the C standard, isdigit is unaffected by locale.
8539 However, it definitely is affected by the target character set. */
8540 unsigned HOST_WIDE_INT target_digit0
8551 }
8552 }
8554 /* Fold a call to fabs, fabsf or fabsl with argument ARG. */
8556 static tree
8558 {
8564 }
8566 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG. */
8568 static tree
8570 {
8576 }
8578 /* Fold a call to builtin carg(a+bi) -> atan2(b,a). */
8580 static tree
8582 {
8585 {
8589 {
8594 }
8595 }
8598 }
8600 /* Fold a call to builtin frexp, we can assume the base is 2. */
8602 static tree
8604 {
8615 /* Proceed if a valid pointer type was passed in. */
8617 {
8622 {
8624 /* For +-0, return (*exp = 0, +-0). */
8630 /* For +-NaN or +-Inf, *exp is unspecified, return arg0. */
8633 {
8634 /* Since the frexp function always expects base 2, and in
8635 GCC normalized significands are already in the range
8636 [0.5, 1.0), we have exactly what frexp wants. */
8641 }
8645 }
8647 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
8651 }
8654 }
8656 /* Fold a call to builtin modf. */
8658 static tree
8660 {
8671 /* Proceed if a valid pointer type was passed in. */
8673 {
8678 {
8681 /* For +-NaN or +-0, return (*arg1 = arg0, arg0). */
8685 /* For +-Inf, return (*arg1 = arg0, +-0). */
8691 /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)). */
8694 /* If the original number was negative and already
8695 integral, then the fractional part is -0.0. */
8699 }
8701 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
8707 }
8710 }
8712 /* Given a location LOC, an interclass builtin function decl FNDECL
8713 and its single argument ARG, return an folded expression computing
8714 the same, or NULL_TREE if we either couldn't or didn't want to fold
8715 (the latter happen if there's an RTL instruction available). */
8717 static tree
8719 {
8720 machine_mode mode;
8732 /* If there is no optab, try generic code. */
8734 {
8735 tree result;
8738 {
8739 /* isinf(x) -> isgreater(fabs(x),DBL_MAX). */
8742 REAL_VALUE_TYPE r;
8746 {
8747 /* NaN and Inf are encoded in the high-order double value
8748 only. The low-order value is not significant. */
8752 }
8759 }
8762 {
8763 /* isfinite(x) -> islessequal(fabs(x),DBL_MAX). */
8766 REAL_VALUE_TYPE r;
8770 {
8771 /* NaN and Inf are encoded in the high-order double value
8772 only. The low-order value is not significant. */
8776 }
8782 /*result = fold_build2_loc (loc, UNGT_EXPR,
8783 TREE_TYPE (TREE_TYPE (fndecl)),
8784 fold_build1_loc (loc, ABS_EXPR, type, arg),
8785 build_real (type, r));
8786 result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
8787 TREE_TYPE (TREE_TYPE (fndecl)),
8788 result);*/
8790 }
8792 {
8793 /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
8794 islessequal(fabs(x),DBL_MAX). */
8804 {
8805 /* Use double to test the normal range of IBM extended
8806 precision. Emin for IBM extended precision is
8807 different to emin for IEEE double, being 53 higher
8808 since the low double exponent is at least 53 lower
8809 than the high double exponent. */
8813 }
8825 {
8826 /* Testing the high end of the range is done just using
8827 the high double, using the same test as isfinite().
8828 For the subnormal end of the range we first test the
8829 high double, then if its magnitude is equal to the
8830 limit of 0x1p-969, we test whether the low double is
8831 non-zero and opposite sign to the high double. */
8847 integer_type_node,
8853 }
8854 else
8855 {
8856 tree const isge_fn
8859 }
8863 }
8866 }
8869 }
8871 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
8872 ARG is the argument for the call. */
8874 static tree
8876 {
8883 {
8891 {
8892 /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
8893 /* In a boolean context, GCC will fold the inner COND_EXPR to
8894 1. So e.g. "if (isinf_sign(x))" would be folded to just
8895 "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
8903 {
8916 integer_zero_node);
8917 }
8920 }
8933 {
8936 {
8937 /* NaN and Inf are encoded in the high-order double value
8938 only. The low-order value is not significant. */
8940 }
8941 }
8947 }
8948 }
8950 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
8951 This builtin will generate code to return the appropriate floating
8952 point classification depending on the value of the floating point
8953 number passed in. The possible return values must be supplied as
8954 int arguments to the call in the following order: FP_NAN, FP_INFINITE,
8955 FP_NORMAL, FP_SUBNORMAL and FP_ZERO. The ellipses is for exactly
8956 one floating point argument which is "type generic". */
8958 static tree
8960 {
8963 machine_mode mode;
8964 REAL_VALUE_TYPE r;
8967 /* Verify the required arguments in the original call. */
8987 /* fpclassify(x) ->
8988 isnan(x) ? FP_NAN :
8989 (fabs(x) == Inf ? FP_INFINITE :
8990 (fabs(x) >= DBL_MIN ? FP_NORMAL :
8991 (x == 0 ? FP_ZERO : FP_SUBNORMAL))). */
9005 {
9011 }
9014 {
9017 }
9020 }
9022 /* Fold a call to an unordered comparison function such as
9023 __builtin_isgreater(). FNDECL is the FUNCTION_DECL for the function
9024 being called and ARG0 and ARG1 are the arguments for the call.
9025 UNORDERED_CODE and ORDERED_CODE are comparison codes that give
9026 the opposite of the desired result. UNORDERED_CODE is used
9027 for modes that can hold NaNs and ORDERED_CODE is used for
9028 the rest. */
9030 static tree
9034 {
9048 /* Choose the wider of two real types. */
9060 {
9064 }
9069 }
9071 /* Fold __builtin_{,s,u}{add,sub,mul}{,l,ll}_overflow, either into normal
9072 arithmetics if it can never overflow, or into internal functions that
9073 return both result of arithmetics and overflowed boolean flag in
9074 a complex integer result, or some other check for overflow.
9075 Similarly fold __builtin_{add,sub,mul}_overflow_p to just the overflow
9076 checking part of that. */
9078 static tree
9081 {
9083 /* The code of the expression corresponding to the type-generic
9084 built-in, or ERROR_MARK for the type-specific ones. */
9089 {
9092 /* FALLTHRU */
9095 /* FALLTHRU */
9106 /* FALLTHRU */
9109 /* FALLTHRU */
9120 /* FALLTHRU */
9123 /* FALLTHRU */
9134 }
9136 /* For the "generic" overloads, the first two arguments can have different
9137 types and the last argument determines the target type to use to check
9138 for overflow. The arguments of the other overloads all have the same
9139 type. */
9142 /* For the __builtin_{add,sub,mul}_overflow_p builtins, when the first two
9143 arguments are constant, attempt to fold the built-in call into a constant
9144 expression indicating whether or not it detected an overflow. */
9148 /* Perform the computation in the target type and check for overflow. */
9152 arg2);
9166 tree store
9169 }
9171 /* Fold a call to __builtin_FILE to a constant string. */
9175 {
9177 {
9178 /* The documentation says this builtin is equivalent to the preprocessor
9179 __FILE__ macro so it appears appropriate to use the same file prefix
9180 mappings. */
9183 }
9186 }
9188 /* Fold a call to __builtin_FUNCTION to a constant string. */
9192 {
9199 }
9201 /* Fold a call to __builtin_LINE to an integer constant. */
9205 {
9207 }
9209 /* Fold a call to built-in function FNDECL with 0 arguments.
9210 This function returns NULL_TREE if no simplification was possible. */
9212 static tree
9214 {
9218 {
9244 }
9246 }
9248 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
9249 This function returns NULL_TREE if no simplification was possible. */
9251 static tree
9253 {
9264 {
9266 {
9269 /* Gimplification will pull the CALL_EXPR for the builtin out of
9270 an if condition. When not optimizing, we'll not CSE it back.
9271 To avoid link error types of regressions, return false now. */
9276 }
9332 {
9337 }
9343 {
9348 }
9369 }
9373 }
9375 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
9376 This function returns NULL_TREE if no simplification was possible. */
9378 static tree
9380 {
9392 {
9436 NOP_EXPR);
9438 /* We do the folding for va_start in the expander. */
9453 }
9455 }
9457 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
9458 and ARG2.
9459 This function returns NULL_TREE if no simplification was possible. */
9461 static tree
9464 {
9478 {
9527 }
9529 }
9531 /* Fold a call to built-in function FNDECL. ARGS is an array of NARGS
9532 arguments. IGNORE is true if the result of the
9533 function call is ignored. This function returns NULL_TREE if no
9534 simplification was possible. */
9536 tree
9538 {
9542 {
9558 }
9560 {
9564 }
9566 }
9568 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
9569 list ARGS along with N new arguments in NEWARGS. SKIP is the number
9570 of arguments in ARGS to be omitted. OLDNARGS is the number of
9571 elements in ARGS. */
9573 static tree
9576 {
9581 {
9589 }
9590 else
9594 }
9596 /* Return true if FNDECL shouldn't be folded right now.
9597 If a built-in function has an inline attribute always_inline
9598 wrapper, defer folding it after always_inline functions have
9599 been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
9600 might not be performed. */
9602 bool
9604 {
9607 && cfun
9610 }
9612 /* A wrapper function for builtin folding that prevents warnings for
9613 "statement without effect" and the like, caused by removing the
9614 call node earlier than the warning is generated. */
9616 tree
9618 {
9624 /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
9625 yet. Defer folding until we see all the arguments
9626 (after inlining). */
9628 {
9631 /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
9632 instead last argument is __builtin_va_arg_pack (). Defer folding
9633 even in that case, until arguments are finalized. */
9635 {
9642 }
9650 else
9651 {
9656 }
9657 }
9659 }
9661 /* Fold a CALL_EXPR with type TYPE with FN as the function expression.
9662 N arguments are passed in the array ARGARRAY. Return a folded
9663 expression or NULL_TREE if no simplification was possible. */
9665 tree
9667 tree fn,
9670 {
9677 {
9678 /* If last argument is __builtin_va_arg_pack (), arguments to this
9679 function are not finalized yet. Defer folding until they are. */
9681 {
9688 }
9693 else
9695 }
9698 }
9700 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
9701 along with N new arguments specified as the "..." parameters. SKIP
9702 is the number of arguments in EXP to be omitted. This function is used
9703 to do varargs-to-varargs transformations. */
9705 static tree
9707 {
9709 tree t;
9717 }
9719 /* Validate a single argument ARG against a tree code CODE representing
9720 a type. Return true when argument is valid. */
9722 static bool
9724 {
9732 }
9734 /* This function validates the types of a function call argument list
9735 against a specified list of tree_codes. If the last specifier is a 0,
9736 that represents an ellipses, otherwise the last specifier must be a
9737 VOID_TYPE.
9739 This is the GIMPLE version of validate_arglist. Eventually we want to
9740 completely convert builtins.c to work from GIMPLEs and the tree based
9741 validate_arglist will then be removed. */
9743 bool
9745 {
9749 const_tree arg;
9755 do
9756 {
9759 {
9761 /* This signifies an ellipses, any further arguments are all ok. */
9765 /* This signifies an endlink, if no arguments remain, return
9766 true, otherwise return false. */
9770 /* If no parameters remain or the parameter's code does not
9771 match the specified code, return false. Otherwise continue
9772 checking any remaining arguments. */
9777 }
9778 }
9781 /* We need gotos here since we can only have one VA_CLOSE in a
9782 function. */
9783 end: ;
9787 }
9789 /* Default target-specific builtin expander that does nothing. */
9791 rtx
9793 rtx target ATTRIBUTE_UNUSED,
9794 rtx subtarget ATTRIBUTE_UNUSED,
9795 machine_mode mode ATTRIBUTE_UNUSED,
9797 {
9799 }
9801 /* Returns true is EXP represents data that would potentially reside
9802 in a readonly section. */
9804 bool
9806 {
9816 /* Make sure we call decl_readonly_section only for trees it
9817 can handle (since it returns true for everything it doesn't
9818 understand). */
9823 else
9825 }
9827 /* Simplify a call to the strpbrk builtin. S1 and S2 are the arguments
9828 to the call, and TYPE is its return type.
9830 Return NULL_TREE if no simplification was possible, otherwise return the
9831 simplified form of the call as a tree.
9833 The simplified form may be a constant or other expression which
9834 computes the same value, but in a more efficient manner (including
9835 calls to other builtin functions).
9837 The call may contain arguments which need to be evaluated, but
9838 which are not useful to determine the result of the call. In
9839 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9840 COMPOUND_EXPR will be an argument which must be evaluated.
9841 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9842 COMPOUND_EXPR in the chain will contain the tree for the simplified
9843 form of the builtin function call. */
9845 static tree
9847 {
9851 else
9852 {
9853 tree fn;
9862 {
9864 tree tem;
9869 /* Return an offset into the constant string argument. */
9872 }
9875 /* strpbrk(x, "") == NULL.
9876 Evaluate and ignore s1 in case it had side-effects. */
9886 /* New argument list transforming strpbrk(s1, s2) to
9887 strchr(s1, s2[0]). */
9890 }
9891 }
9893 /* Simplify a call to the strspn builtin. S1 and S2 are the arguments
9894 to the call.
9896 Return NULL_TREE if no simplification was possible, otherwise return the
9897 simplified form of the call as a tree.
9899 The simplified form may be a constant or other expression which
9900 computes the same value, but in a more efficient manner (including
9901 calls to other builtin functions).
9903 The call may contain arguments which need to be evaluated, but
9904 which are not useful to determine the result of the call. In
9905 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9906 COMPOUND_EXPR will be an argument which must be evaluated.
9907 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9908 COMPOUND_EXPR in the chain will contain the tree for the simplified
9909 form of the builtin function call. */
9911 static tree
9913 {
9917 else
9918 {
9921 /* If either argument is "", return NULL_TREE. */
9923 /* Evaluate and ignore both arguments in case either one has
9924 side-effects. */
9928 }
9929 }
9931 /* Simplify a call to the strcspn builtin. S1 and S2 are the arguments
9932 to the call.
9934 Return NULL_TREE if no simplification was possible, otherwise return the
9935 simplified form of the call as a tree.
9937 The simplified form may be a constant or other expression which
9938 computes the same value, but in a more efficient manner (including
9939 calls to other builtin functions).
9941 The call may contain arguments which need to be evaluated, but
9942 which are not useful to determine the result of the call. In
9943 this case we return a chain of COMPOUND_EXPRs. The LHS of each
9944 COMPOUND_EXPR will be an argument which must be evaluated.
9945 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
9946 COMPOUND_EXPR in the chain will contain the tree for the simplified
9947 form of the builtin function call. */
9949 static tree
9951 {
9955 else
9956 {
9957 /* If the first argument is "", return NULL_TREE. */
9960 {
9961 /* Evaluate and ignore argument s2 in case it has
9962 side-effects. */
9965 }
9967 /* If the second argument is "", return __builtin_strlen(s1). */
9970 {
9973 /* If the replacement _DECL isn't initialized, don't do the
9974 transformation. */
9979 }
9981 }
9982 }
9984 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
9985 produced. False otherwise. This is done so that we don't output the error
9986 or warning twice or three times. */
9988 bool
9990 {
9993 tree arg;
9994 /* There is good chance the current input_location points inside the
9995 definition of the va_start macro (perhaps on the token for
9996 builtin) in a system header, so warnings will not be emitted.
9997 Use the location in real source code. */
9998 source_location current_location =
10000 NULL);
10003 {
10006 }
10009 {
10011 {
10014 }
10016 }
10017 /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
10018 when we checked the arguments and if needed issued a warning. */
10019 else
10020 {
10022 {
10023 /* Evidently an out of date version of <stdarg.h>; can't validate
10024 va_start's second argument, but can still work as intended. */
10026 OPT_Wvarargs,
10029 }
10031 {
10034 }
10036 }
10041 /* We destructively modify the call to be __builtin_va_start (ap, 0)
10042 or __builtin_next_arg (0) the first time we see it, after checking
10043 the arguments and if needed issuing a warning. */
10045 {
10048 /* Strip off all nops for the sake of the comparison. This
10049 is not quite the same as STRIP_NOPS. It does more.
10050 We must also strip off INDIRECT_EXPR for C++ reference
10051 parameters. */
10056 {
10057 /* FIXME: Sometimes with the tree optimizers we can get the
10058 not the last argument even though the user used the last
10059 argument. We just warn and set the arg to be the last
10060 argument so that we will get wrong-code because of
10061 it. */
10063 OPT_Wvarargs,
10065 }
10067 /* Undefined by C99 7.15.1.4p4 (va_start):
10068 "If the parameter parmN is declared with the register storage
10069 class, with a function or array type, or with a type that is
10070 not compatible with the type that results after application of
10071 the default argument promotions, the behavior is undefined."
10072 */
10074 {
10076 OPT_Wvarargs,
10077 "undefined behavior when second parameter of "
10079 }
10081 /* We want to verify the second parameter just once before the tree
10082 optimizers are run and then avoid keeping it in the tree,
10083 as otherwise we could warn even for correct code like:
10084 void foo (int i, ...)
10085 { va_list ap; i++; va_start (ap, i); va_end (ap); } */
10088 else
10090 }
10092 }
10095 /* Expand a call EXP to __builtin_object_size. */
10097 static rtx
10099 {
10100 tree ost;
10105 {
10110 }
10118 {
10123 }
10128 }
10130 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
10131 FCODE is the BUILT_IN_* to use.
10132 Return NULL_RTX if we failed; the caller should emit a normal call,
10133 otherwise try to get the result in TARGET, if convenient (and in
10134 mode MODE if that's convenient). */
10136 static rtx
10139 {
10141 POINTER_TYPE,
10142 fcode == BUILT_IN_MEMSET_CHK
10159 {
10160 /* Avoid transforming the checking call to an ordinary one when
10161 an overflow has been detected or when the call couldn't be
10162 validated because the size is not constant. */
10167 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
10168 mem{cpy,pcpy,move,set} is available. */
10170 {
10185 }
10194 }
10197 else
10198 {
10201 /* If DEST is not a pointer type, call the normal function. */
10205 /* If SRC and DEST are the same (and not volatile), do nothing. */
10207 {
10208 tree expr;
10211 {
10212 /* Evaluate and ignore LEN in case it has side-effects. */
10215 }
10219 }
10221 /* __memmove_chk special case. */
10223 {
10229 /* If src is categorized for a readonly section we can use
10230 normal __memcpy_chk. */
10232 {
10241 }
10242 }
10244 }
10245 }
10247 /* Emit warning if a buffer overflow is detected at compile time. */
10249 static void
10251 {
10252 /* The source string. */
10254 /* The size of the destination object. */
10256 /* The string that is being concatenated with (as in __strcat_chk)
10257 or null if it isn't. */
10259 /* The maximum length of the source sequence in a bounded operation
10260 (such as __strncat_chk) or null if the operation isn't bounded
10261 (such as __strcat_chk). */
10263 /* The exact size of the access (such as in __strncpy_chk). */
10267 {
10275 /* For __strcat_chk the warning will be emitted only if overflowing
10276 by at least strlen (dest) + 1 bytes. */
10303 }
10306 {
10307 /* Check __strncat_chk. There is no way to determine the length
10308 of the string to which the source string is being appended so
10309 just warn when the length of the source string is not known. */
10312 }
10314 /* The destination argument is the first one for all built-ins above. */
10318 }
10320 /* Emit warning if a buffer overflow is detected at compile time
10321 in __sprintf_chk/__vsprintf_chk calls. */
10323 static void
10325 {
10330 /* Verify the required arguments in the original call. */
10340 /* Check whether the format is a literal string constant. */
10348 /* If the format doesn't contain % args or %%, we know its size. */
10351 /* If the format is "%s" and first ... argument is a string literal,
10352 we know it too. */
10355 {
10356 tree arg;
10367 }
10368 else
10371 /* Add one for the terminating nul. */
10376 }
10378 /* Emit warning if a free is called with address of a variable. */
10380 static void
10382 {
10396 else
10399 }
10401 /* Fold a call to __builtin_object_size with arguments PTR and OST,
10402 if possible. */
10404 static tree
10406 {
10423 /* __builtin_object_size doesn't evaluate side-effects in its arguments;
10424 if there are any side-effects, it returns (size_t) -1 for types 0 and 1
10425 and (size_t) 0 for types 2 and 3. */
10430 {
10434 }
10436 {
10437 /* If object size is not known yet, delay folding until
10438 later. Maybe subsequent passes will help determining
10439 it. */
10443 }
10446 }
10448 /* Builtins with folding operations that operate on "..." arguments
10449 need special handling; we need to store the arguments in a convenient
10450 data structure before attempting any folding. Fortunately there are
10451 only a few builtins that fall into this category. FNDECL is the
10452 function, EXP is the CALL_EXPR for the call. */
10454 static tree
10456 {
10461 {
10468 }
10470 {
10475 }
10477 }
10479 /* Initialize format string characters in the target charset. */
10481 bool
10483 {
10486 {
10509 }
10511 }
10513 /* Helper function for do_mpfr_arg*(). Ensure M is a normal number
10514 and no overflow/underflow occurred. INEXACT is true if M was not
10515 exactly calculated. TYPE is the tree type for the result. This
10516 function assumes that you cleared the MPFR flags and then
10517 calculated M to see if anything subsequently set a flag prior to
10518 entering this function. Return NULL_TREE if any checks fail. */
10520 static tree
10522 {
10523 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
10524 overflow/underflow occurred. If -frounding-math, proceed iff the
10525 result of calling FUNC was exact. */
10528 {
10529 REAL_VALUE_TYPE rr;
10532 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
10533 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
10534 but the mpft_t is not, then we underflowed in the
10535 conversion. */
10538 {
10539 REAL_VALUE_TYPE rmode;
10542 /* Proceed iff the specified mode can hold the value. */
10545 }
10546 }
10548 }
10550 /* Helper function for do_mpc_arg*(). Ensure M is a normal complex
10551 number and no overflow/underflow occurred. INEXACT is true if M
10552 was not exactly calculated. TYPE is the tree type for the result.
10553 This function assumes that you cleared the MPFR flags and then
10554 calculated M to see if anything subsequently set a flag prior to
10555 entering this function. Return NULL_TREE if any checks fail, if
10556 FORCE_CONVERT is true, then bypass the checks. */
10558 static tree
10560 {
10561 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
10562 overflow/underflow occurred. If -frounding-math, proceed iff the
10563 result of calling FUNC was exact. */
10568 {
10573 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
10574 check for overflow/underflow. If the REAL_VALUE_TYPE is zero
10575 but the mpft_t is not, then we underflowed in the
10576 conversion. */
10581 {
10586 /* Proceed iff the specified mode can hold the value. */
10592 }
10593 }
10595 }
10597 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
10598 the pointer *(ARG_QUO) and return the result. The type is taken
10599 from the type of ARG0 and is used for setting the precision of the
10600 calculation and results. */
10602 static tree
10604 {
10611 /* To proceed, MPFR must exactly represent the target floating point
10612 format, which only happens when the target base equals two. */
10616 {
10621 {
10625 tree result_rem;
10634 /* Remquo is independent of the rounding mode, so pass
10635 inexact=0 to do_mpfr_ckconv(). */
10639 {
10640 /* MPFR calculates quo in the host's long so it may
10641 return more bits in quo than the target int can hold
10642 if sizeof(host long) > sizeof(target int). This can
10643 happen even for native compilers in LP64 mode. In
10644 these cases, modulo the quo value with the largest
10645 number that the target int can hold while leaving one
10646 bit for the sign. */
10650 /* Dereference the quo pointer argument. */
10652 /* Proceed iff a valid pointer type was passed in. */
10654 {
10655 /* Set the value. */
10656 tree result_quo
10659 integer_quo));
10661 /* Combine the quo assignment with the rem. */
10664 }
10665 }
10666 }
10667 }
10669 }
10671 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
10672 resulting value as a tree with type TYPE. The mpfr precision is
10673 set to the precision of TYPE. We assume that this mpfr function
10674 returns zero if the result could be calculated exactly within the
10675 requested precision. In addition, the integer pointer represented
10676 by ARG_SG will be dereferenced and set to the appropriate signgam
10677 (-1,1) value. */
10679 static tree
10681 {
10686 /* To proceed, MPFR must exactly represent the target floating point
10687 format, which only happens when the target base equals two. Also
10688 verify ARG is a constant and that ARG_SG is an int pointer. */
10693 {
10696 /* In addition to NaN and Inf, the argument cannot be zero or a
10697 negative integer. */
10701 {
10706 mpfr_t m;
10707 tree result_lg;
10716 {
10717 tree result_sg;
10719 /* Dereference the arg_sg pointer argument. */
10721 /* Assign the signgam value into *arg_sg. */
10726 /* Combine the signgam assignment with the lgamma result. */
10729 }
10730 }
10731 }
10734 }
10736 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
10737 mpc function FUNC on it and return the resulting value as a tree
10738 with type TYPE. The mpfr precision is set to the precision of
10739 TYPE. We assume that function FUNC returns zero if the result
10740 could be calculated exactly within the requested precision. If
10741 DO_NONFINITE is true, then fold expressions containing Inf or NaN
10742 in the arguments and/or results. */
10744 tree
10747 {
10753 /* To proceed, MPFR must exactly represent the target floating point
10754 format, which only happens when the target base equals two. */
10760 {
10769 {
10789 }
10790 }
10793 }
10795 /* A wrapper function for builtin folding that prevents warnings for
10796 "statement without effect" and the like, caused by removing the
10797 call node earlier than the warning is generated. */
10799 tree
10801 {
10809 {
10818 {
10820 }
10821 else
10822 {
10825 {
10826 /* Propagate location information from original call to
10827 expansion of builtin. Otherwise things like
10828 maybe_emit_chk_warning, that operate on the expansion
10829 of a builtin, will use the wrong location information. */
10831 {
10839 }
10841 }
10842 }
10843 }
10845 }
10847 /* Look up the function in builtin_decl that corresponds to DECL
10848 and set ASMSPEC as its user assembler name. DECL must be a
10849 function decl that declares a builtin. */
10851 void
10853 {
10863 {
10867 }
10868 }
10870 /* Return true if DECL is a builtin that expands to a constant or similarly
10871 simple code. */
10872 bool
10874 {
10877 {
10878 /* Builtins that expand to constants. */
10883 /* Simple register moves or loads from stack. */
10894 /* Exception state returns or moves registers around. */
10902 }
10905 }
10907 /* Return true if DECL is a builtin that is not expensive, i.e., they are
10908 most probably expanded inline into reasonably simple code. This is a
10909 superset of is_simple_builtin. */
10910 bool
10912 {
10919 {
10921 CASE_BUILT_IN_ALLOCA:
10987 }
10990 }
10992 /* Return true if T is a constant and the value cast to a target char
10993 can be represented by a host char.
10994 Store the casted char constant in *P if so. */
10996 bool
10998 {
11004 }
11006 /* Return the maximum object size. */
11008 tree
11010 {
11011 /* To do: Make this a configurable parameter. */
11013 }