1 /* Gimple IR support functions.
3 Copyright (C) 2007-2023 Free Software Foundation, Inc.
4 Contributed by Aldy Hernandez <aldyh@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
30 #include "diagnostic.h"
32 #include "fold-const.h"
34 #include "stor-layout.h"
35 #include "internal-fn.h"
37 #include "gimple-iterator.h"
38 #include "gimple-walk.h"
43 #include "gimple-pretty-print.h"
44 #include "stringpool.h"
48 #include "langhooks.h"
49 #include "attr-fnspec.h"
50 #include "ipa-modref-tree.h"
51 #include "ipa-modref.h"
54 /* All the tuples have their operand vector (if present) at the very bottom
55 of the structure. Therefore, the offset required to find the
56 operands vector the size of the structure minus the size of the 1
57 element tree array at the end (see gimple_ops). */
58 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
59 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
60 EXPORTED_CONST
size_t gimple_ops_offset_
[] = {
61 #include "gsstruct.def"
65 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
66 static const size_t gsstruct_code_size
[] = {
67 #include "gsstruct.def"
71 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
72 const char *const gimple_code_name
[] = {
77 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
78 EXPORTED_CONST
enum gimple_statement_structure_enum gss_for_code_
[] = {
85 uint64_t gimple_alloc_counts
[(int) gimple_alloc_kind_all
];
86 uint64_t gimple_alloc_sizes
[(int) gimple_alloc_kind_all
];
88 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
89 static const char * const gimple_alloc_kind_names
[] = {
96 /* Static gimple tuple members. */
97 const enum gimple_code
gassign::code_
;
98 const enum gimple_code
gcall::code_
;
99 const enum gimple_code
gcond::code_
;
102 /* Gimple tuple constructors.
103 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
104 be passed a NULL to start with an empty sequence. */
106 /* Set the code for statement G to CODE. */
109 gimple_set_code (gimple
*g
, enum gimple_code code
)
114 /* Return the number of bytes needed to hold a GIMPLE statement with
118 gimple_size (enum gimple_code code
, unsigned num_ops
)
120 size_t size
= gsstruct_code_size
[gss_for_code (code
)];
122 size
+= (sizeof (tree
) * (num_ops
- 1));
126 /* Initialize GIMPLE statement G with CODE and NUM_OPS. */
129 gimple_init (gimple
*g
, enum gimple_code code
, unsigned num_ops
)
131 gimple_set_code (g
, code
);
132 gimple_set_num_ops (g
, num_ops
);
134 /* Do not call gimple_set_modified here as it has other side
135 effects and this tuple is still not completely built. */
137 gimple_init_singleton (g
);
140 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
144 gimple_alloc (enum gimple_code code
, unsigned num_ops MEM_STAT_DECL
)
149 size
= gimple_size (code
, num_ops
);
150 if (GATHER_STATISTICS
)
152 enum gimple_alloc_kind kind
= gimple_alloc_kind (code
);
153 gimple_alloc_counts
[(int) kind
]++;
154 gimple_alloc_sizes
[(int) kind
] += size
;
157 stmt
= ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT
);
158 gimple_init (stmt
, code
, num_ops
);
162 /* Set SUBCODE to be the code of the expression computed by statement G. */
165 gimple_set_subcode (gimple
*g
, unsigned subcode
)
167 /* We only have 16 bits for the RHS code. Assert that we are not
169 gcc_assert (subcode
< (1 << 16));
170 g
->subcode
= subcode
;
175 /* Build a tuple with operands. CODE is the statement to build (which
176 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
177 for the new tuple. NUM_OPS is the number of operands to allocate. */
179 #define gimple_build_with_ops(c, s, n) \
180 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
183 gimple_build_with_ops_stat (enum gimple_code code
, unsigned subcode
,
184 unsigned num_ops MEM_STAT_DECL
)
186 gimple
*s
= gimple_alloc (code
, num_ops PASS_MEM_STAT
);
187 gimple_set_subcode (s
, subcode
);
193 /* Build a GIMPLE_RETURN statement returning RETVAL. */
196 gimple_build_return (tree retval
)
199 = as_a
<greturn
*> (gimple_build_with_ops (GIMPLE_RETURN
, ERROR_MARK
,
202 gimple_return_set_retval (s
, retval
);
206 /* Reset alias information on call S. */
209 gimple_call_reset_alias_info (gcall
*s
)
211 if (gimple_call_flags (s
) & ECF_CONST
)
212 memset (gimple_call_use_set (s
), 0, sizeof (struct pt_solution
));
214 pt_solution_reset (gimple_call_use_set (s
));
215 if (gimple_call_flags (s
) & (ECF_CONST
|ECF_PURE
|ECF_NOVOPS
))
216 memset (gimple_call_clobber_set (s
), 0, sizeof (struct pt_solution
));
218 pt_solution_reset (gimple_call_clobber_set (s
));
221 /* Helper for gimple_build_call, gimple_build_call_valist,
222 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
223 components of a GIMPLE_CALL statement to function FN with NARGS
226 static inline gcall
*
227 gimple_build_call_1 (tree fn
, unsigned nargs
)
230 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
232 if (TREE_CODE (fn
) == FUNCTION_DECL
)
233 fn
= build_fold_addr_expr (fn
);
234 gimple_set_op (s
, 1, fn
);
235 gimple_call_set_fntype (s
, TREE_TYPE (TREE_TYPE (fn
)));
236 gimple_call_reset_alias_info (s
);
241 /* Build a GIMPLE_CALL statement to function FN with the arguments
242 specified in vector ARGS. */
245 gimple_build_call_vec (tree fn
, const vec
<tree
> &args
)
248 unsigned nargs
= args
.length ();
249 gcall
*call
= gimple_build_call_1 (fn
, nargs
);
251 for (i
= 0; i
< nargs
; i
++)
252 gimple_call_set_arg (call
, i
, args
[i
]);
258 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
259 arguments. The ... are the arguments. */
262 gimple_build_call (tree fn
, unsigned nargs
, ...)
268 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
270 call
= gimple_build_call_1 (fn
, nargs
);
272 va_start (ap
, nargs
);
273 for (i
= 0; i
< nargs
; i
++)
274 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
281 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
282 arguments. AP contains the arguments. */
285 gimple_build_call_valist (tree fn
, unsigned nargs
, va_list ap
)
290 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
292 call
= gimple_build_call_1 (fn
, nargs
);
294 for (i
= 0; i
< nargs
; i
++)
295 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
301 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
302 Build the basic components of a GIMPLE_CALL statement to internal
303 function FN with NARGS arguments. */
305 static inline gcall
*
306 gimple_build_call_internal_1 (enum internal_fn fn
, unsigned nargs
)
309 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
311 s
->subcode
|= GF_CALL_INTERNAL
;
312 gimple_call_set_internal_fn (s
, fn
);
313 gimple_call_reset_alias_info (s
);
318 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
319 the number of arguments. The ... are the arguments. */
322 gimple_build_call_internal (enum internal_fn fn
, unsigned nargs
, ...)
328 call
= gimple_build_call_internal_1 (fn
, nargs
);
329 va_start (ap
, nargs
);
330 for (i
= 0; i
< nargs
; i
++)
331 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
338 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
339 specified in vector ARGS. */
342 gimple_build_call_internal_vec (enum internal_fn fn
, const vec
<tree
> &args
)
347 nargs
= args
.length ();
348 call
= gimple_build_call_internal_1 (fn
, nargs
);
349 for (i
= 0; i
< nargs
; i
++)
350 gimple_call_set_arg (call
, i
, args
[i
]);
356 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
357 assumed to be in GIMPLE form already. Minimal checking is done of
361 gimple_build_call_from_tree (tree t
, tree fnptrtype
)
366 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
368 nargs
= call_expr_nargs (t
);
370 tree fndecl
= NULL_TREE
;
371 if (CALL_EXPR_FN (t
) == NULL_TREE
)
372 call
= gimple_build_call_internal_1 (CALL_EXPR_IFN (t
), nargs
);
375 fndecl
= get_callee_fndecl (t
);
376 call
= gimple_build_call_1 (fndecl
? fndecl
: CALL_EXPR_FN (t
), nargs
);
379 for (i
= 0; i
< nargs
; i
++)
380 gimple_call_set_arg (call
, i
, CALL_EXPR_ARG (t
, i
));
382 gimple_set_block (call
, TREE_BLOCK (t
));
383 gimple_set_location (call
, EXPR_LOCATION (t
));
385 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
386 gimple_call_set_chain (call
, CALL_EXPR_STATIC_CHAIN (t
));
387 gimple_call_set_tail (call
, CALL_EXPR_TAILCALL (t
));
388 gimple_call_set_must_tail (call
, CALL_EXPR_MUST_TAIL_CALL (t
));
389 gimple_call_set_return_slot_opt (call
, CALL_EXPR_RETURN_SLOT_OPT (t
));
391 && fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
)
392 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl
)))
393 gimple_call_set_alloca_for_var (call
, CALL_ALLOCA_FOR_VAR_P (t
));
395 && (DECL_IS_OPERATOR_NEW_P (fndecl
)
396 || DECL_IS_OPERATOR_DELETE_P (fndecl
)))
397 gimple_call_set_from_new_or_delete (call
, CALL_FROM_NEW_OR_DELETE_P (t
));
399 gimple_call_set_from_thunk (call
, CALL_FROM_THUNK_P (t
));
400 gimple_call_set_va_arg_pack (call
, CALL_EXPR_VA_ARG_PACK (t
));
401 gimple_call_set_nothrow (call
, TREE_NOTHROW (t
));
402 gimple_call_set_by_descriptor (call
, CALL_EXPR_BY_DESCRIPTOR (t
));
403 copy_warning (call
, t
);
407 gimple_call_set_fntype (call
, TREE_TYPE (fnptrtype
));
409 /* Check if it's an indirect CALL and the type has the
410 nocf_check attribute. In that case propagate the information
411 to the gimple CALL insn. */
414 gcc_assert (POINTER_TYPE_P (fnptrtype
));
415 tree fntype
= TREE_TYPE (fnptrtype
);
417 if (lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (fntype
)))
418 gimple_call_set_nocf_check (call
, true);
425 /* Build a gcall to __builtin_unreachable as rewritten by
426 -fsanitize=unreachable. */
429 gimple_build_builtin_unreachable (location_t loc
)
431 tree data
= NULL_TREE
;
432 tree fn
= sanitize_unreachable_fn (&data
, loc
);
433 gcall
*g
= gimple_build_call (fn
, data
!= NULL_TREE
, data
);
434 gimple_call_set_ctrl_altering (g
, true);
435 gimple_set_location (g
, loc
);
439 /* Build a GIMPLE_ASSIGN statement.
441 LHS of the assignment.
442 RHS of the assignment which can be unary or binary. */
445 gimple_build_assign (tree lhs
, tree rhs MEM_STAT_DECL
)
447 enum tree_code subcode
;
450 extract_ops_from_tree (rhs
, &subcode
, &op1
, &op2
, &op3
);
451 return gimple_build_assign (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
455 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
458 static inline gassign
*
459 gimple_build_assign_1 (tree lhs
, enum tree_code subcode
, tree op1
,
460 tree op2
, tree op3 MEM_STAT_DECL
)
465 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
467 num_ops
= get_gimple_rhs_num_ops (subcode
) + 1;
469 p
= as_a
<gassign
*> (
470 gimple_build_with_ops_stat (GIMPLE_ASSIGN
, (unsigned)subcode
, num_ops
472 gimple_assign_set_lhs (p
, lhs
);
473 gimple_assign_set_rhs1 (p
, op1
);
476 gcc_assert (num_ops
> 2);
477 gimple_assign_set_rhs2 (p
, op2
);
482 gcc_assert (num_ops
> 3);
483 gimple_assign_set_rhs3 (p
, op3
);
489 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
493 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
494 tree op2
, tree op3 MEM_STAT_DECL
)
496 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
499 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
503 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
504 tree op2 MEM_STAT_DECL
)
506 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, NULL_TREE
510 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
513 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1 MEM_STAT_DECL
)
515 return gimple_build_assign_1 (lhs
, subcode
, op1
, NULL_TREE
, NULL_TREE
520 /* Build a GIMPLE_COND statement.
522 PRED is the condition used to compare LHS and the RHS.
523 T_LABEL is the label to jump to if the condition is true.
524 F_LABEL is the label to jump to otherwise. */
527 gimple_build_cond (enum tree_code pred_code
, tree lhs
, tree rhs
,
528 tree t_label
, tree f_label
)
532 gcc_assert (TREE_CODE_CLASS (pred_code
) == tcc_comparison
);
533 p
= as_a
<gcond
*> (gimple_build_with_ops (GIMPLE_COND
, pred_code
, 4));
534 gimple_cond_set_lhs (p
, lhs
);
535 gimple_cond_set_rhs (p
, rhs
);
536 gimple_cond_set_true_label (p
, t_label
);
537 gimple_cond_set_false_label (p
, f_label
);
541 /* Build a GIMPLE_COND statement from the conditional expression tree
542 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
545 gimple_build_cond_from_tree (tree cond
, tree t_label
, tree f_label
)
550 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
551 return gimple_build_cond (code
, lhs
, rhs
, t_label
, f_label
);
554 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
555 boolean expression tree COND. */
558 gimple_cond_set_condition_from_tree (gcond
*stmt
, tree cond
)
563 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
564 gimple_cond_set_condition (stmt
, code
, lhs
, rhs
);
567 /* Build a GIMPLE_LABEL statement for LABEL. */
570 gimple_build_label (tree label
)
573 = as_a
<glabel
*> (gimple_build_with_ops (GIMPLE_LABEL
, ERROR_MARK
, 1));
574 gimple_label_set_label (p
, label
);
578 /* Build a GIMPLE_GOTO statement to label DEST. */
581 gimple_build_goto (tree dest
)
584 = as_a
<ggoto
*> (gimple_build_with_ops (GIMPLE_GOTO
, ERROR_MARK
, 1));
585 gimple_goto_set_dest (p
, dest
);
590 /* Build a GIMPLE_NOP statement. */
593 gimple_build_nop (void)
595 return gimple_alloc (GIMPLE_NOP
, 0);
599 /* Build a GIMPLE_BIND statement.
600 VARS are the variables in BODY.
601 BLOCK is the containing block. */
604 gimple_build_bind (tree vars
, gimple_seq body
, tree block
)
606 gbind
*p
= as_a
<gbind
*> (gimple_alloc (GIMPLE_BIND
, 0));
607 gimple_bind_set_vars (p
, vars
);
609 gimple_bind_set_body (p
, body
);
611 gimple_bind_set_block (p
, block
);
615 /* Helper function to set the simple fields of a asm stmt.
617 STRING is a pointer to a string that is the asm blocks assembly code.
618 NINPUT is the number of register inputs.
619 NOUTPUT is the number of register outputs.
620 NCLOBBERS is the number of clobbered registers.
624 gimple_build_asm_1 (const char *string
, unsigned ninputs
, unsigned noutputs
,
625 unsigned nclobbers
, unsigned nlabels
)
628 int size
= strlen (string
);
631 gimple_build_with_ops (GIMPLE_ASM
, ERROR_MARK
,
632 ninputs
+ noutputs
+ nclobbers
+ nlabels
));
638 p
->string
= ggc_alloc_string (string
, size
);
640 if (GATHER_STATISTICS
)
641 gimple_alloc_sizes
[(int) gimple_alloc_kind (GIMPLE_ASM
)] += size
;
646 /* Build a GIMPLE_ASM statement.
648 STRING is the assembly code.
649 NINPUT is the number of register inputs.
650 NOUTPUT is the number of register outputs.
651 NCLOBBERS is the number of clobbered registers.
652 INPUTS is a vector of the input register parameters.
653 OUTPUTS is a vector of the output register parameters.
654 CLOBBERS is a vector of the clobbered register parameters.
655 LABELS is a vector of destination labels. */
658 gimple_build_asm_vec (const char *string
, vec
<tree
, va_gc
> *inputs
,
659 vec
<tree
, va_gc
> *outputs
, vec
<tree
, va_gc
> *clobbers
,
660 vec
<tree
, va_gc
> *labels
)
665 p
= gimple_build_asm_1 (string
,
666 vec_safe_length (inputs
),
667 vec_safe_length (outputs
),
668 vec_safe_length (clobbers
),
669 vec_safe_length (labels
));
671 for (i
= 0; i
< vec_safe_length (inputs
); i
++)
672 gimple_asm_set_input_op (p
, i
, (*inputs
)[i
]);
674 for (i
= 0; i
< vec_safe_length (outputs
); i
++)
675 gimple_asm_set_output_op (p
, i
, (*outputs
)[i
]);
677 for (i
= 0; i
< vec_safe_length (clobbers
); i
++)
678 gimple_asm_set_clobber_op (p
, i
, (*clobbers
)[i
]);
680 for (i
= 0; i
< vec_safe_length (labels
); i
++)
681 gimple_asm_set_label_op (p
, i
, (*labels
)[i
]);
686 /* Build a GIMPLE_CATCH statement.
688 TYPES are the catch types.
689 HANDLER is the exception handler. */
692 gimple_build_catch (tree types
, gimple_seq handler
)
694 gcatch
*p
= as_a
<gcatch
*> (gimple_alloc (GIMPLE_CATCH
, 0));
695 gimple_catch_set_types (p
, types
);
697 gimple_catch_set_handler (p
, handler
);
702 /* Build a GIMPLE_EH_FILTER statement.
704 TYPES are the filter's types.
705 FAILURE is the filter's failure action. */
708 gimple_build_eh_filter (tree types
, gimple_seq failure
)
710 geh_filter
*p
= as_a
<geh_filter
*> (gimple_alloc (GIMPLE_EH_FILTER
, 0));
711 gimple_eh_filter_set_types (p
, types
);
713 gimple_eh_filter_set_failure (p
, failure
);
718 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
721 gimple_build_eh_must_not_throw (tree decl
)
723 geh_mnt
*p
= as_a
<geh_mnt
*> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW
, 0));
725 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
726 gcc_assert (flags_from_decl_or_type (decl
) & ECF_NORETURN
);
727 gimple_eh_must_not_throw_set_fndecl (p
, decl
);
732 /* Build a GIMPLE_EH_ELSE statement. */
735 gimple_build_eh_else (gimple_seq n_body
, gimple_seq e_body
)
737 geh_else
*p
= as_a
<geh_else
*> (gimple_alloc (GIMPLE_EH_ELSE
, 0));
738 gimple_eh_else_set_n_body (p
, n_body
);
739 gimple_eh_else_set_e_body (p
, e_body
);
743 /* Build a GIMPLE_TRY statement.
745 EVAL is the expression to evaluate.
746 CLEANUP is the cleanup expression.
747 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
748 whether this is a try/catch or a try/finally respectively. */
751 gimple_build_try (gimple_seq eval
, gimple_seq cleanup
,
752 enum gimple_try_flags kind
)
756 gcc_assert (kind
== GIMPLE_TRY_CATCH
|| kind
== GIMPLE_TRY_FINALLY
);
757 p
= as_a
<gtry
*> (gimple_alloc (GIMPLE_TRY
, 0));
758 gimple_set_subcode (p
, kind
);
760 gimple_try_set_eval (p
, eval
);
762 gimple_try_set_cleanup (p
, cleanup
);
767 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
769 CLEANUP is the cleanup expression. */
772 gimple_build_wce (gimple_seq cleanup
)
774 gimple
*p
= gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR
, 0);
776 gimple_wce_set_cleanup (p
, cleanup
);
782 /* Build a GIMPLE_RESX statement. */
785 gimple_build_resx (int region
)
788 = as_a
<gresx
*> (gimple_build_with_ops (GIMPLE_RESX
, ERROR_MARK
, 0));
794 /* The helper for constructing a gimple switch statement.
795 INDEX is the switch's index.
796 NLABELS is the number of labels in the switch excluding the default.
797 DEFAULT_LABEL is the default label for the switch statement. */
800 gimple_build_switch_nlabels (unsigned nlabels
, tree index
, tree default_label
)
802 /* nlabels + 1 default label + 1 index. */
803 gcc_checking_assert (default_label
);
804 gswitch
*p
= as_a
<gswitch
*> (gimple_build_with_ops (GIMPLE_SWITCH
,
807 gimple_switch_set_index (p
, index
);
808 gimple_switch_set_default_label (p
, default_label
);
812 /* Build a GIMPLE_SWITCH statement.
814 INDEX is the switch's index.
815 DEFAULT_LABEL is the default label
816 ARGS is a vector of labels excluding the default. */
819 gimple_build_switch (tree index
, tree default_label
, const vec
<tree
> &args
)
821 unsigned i
, nlabels
= args
.length ();
823 gswitch
*p
= gimple_build_switch_nlabels (nlabels
, index
, default_label
);
825 /* Copy the labels from the vector to the switch statement. */
826 for (i
= 0; i
< nlabels
; i
++)
827 gimple_switch_set_label (p
, i
+ 1, args
[i
]);
832 /* Build a GIMPLE_EH_DISPATCH statement. */
835 gimple_build_eh_dispatch (int region
)
838 = as_a
<geh_dispatch
*> (
839 gimple_build_with_ops (GIMPLE_EH_DISPATCH
, ERROR_MARK
, 0));
844 /* Build a new GIMPLE_DEBUG_BIND statement.
846 VAR is bound to VALUE; block and location are taken from STMT. */
849 gimple_build_debug_bind (tree var
, tree value
, gimple
*stmt MEM_STAT_DECL
)
852 = as_a
<gdebug
*> (gimple_build_with_ops_stat (GIMPLE_DEBUG
,
853 (unsigned)GIMPLE_DEBUG_BIND
, 2
855 gimple_debug_bind_set_var (p
, var
);
856 gimple_debug_bind_set_value (p
, value
);
858 gimple_set_location (p
, gimple_location (stmt
));
864 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
866 VAR is bound to VALUE; block and location are taken from STMT. */
869 gimple_build_debug_source_bind (tree var
, tree value
,
870 gimple
*stmt MEM_STAT_DECL
)
874 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
875 (unsigned)GIMPLE_DEBUG_SOURCE_BIND
, 2
878 gimple_debug_source_bind_set_var (p
, var
);
879 gimple_debug_source_bind_set_value (p
, value
);
881 gimple_set_location (p
, gimple_location (stmt
));
887 /* Build a new GIMPLE_DEBUG_BEGIN_STMT statement in BLOCK at
891 gimple_build_debug_begin_stmt (tree block
, location_t location
896 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
897 (unsigned)GIMPLE_DEBUG_BEGIN_STMT
, 0
900 gimple_set_location (p
, location
);
901 gimple_set_block (p
, block
);
902 cfun
->debug_marker_count
++;
908 /* Build a new GIMPLE_DEBUG_INLINE_ENTRY statement in BLOCK at
909 LOCATION. The BLOCK links to the inlined function. */
912 gimple_build_debug_inline_entry (tree block
, location_t location
917 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
918 (unsigned)GIMPLE_DEBUG_INLINE_ENTRY
, 0
921 gimple_set_location (p
, location
);
922 gimple_set_block (p
, block
);
923 cfun
->debug_marker_count
++;
929 /* Build a GIMPLE_OMP_CRITICAL statement.
931 BODY is the sequence of statements for which only one thread can execute.
932 NAME is optional identifier for this critical block.
933 CLAUSES are clauses for this critical block. */
936 gimple_build_omp_critical (gimple_seq body
, tree name
, tree clauses
)
939 = as_a
<gomp_critical
*> (gimple_alloc (GIMPLE_OMP_CRITICAL
, 0));
940 gimple_omp_critical_set_name (p
, name
);
941 gimple_omp_critical_set_clauses (p
, clauses
);
943 gimple_omp_set_body (p
, body
);
948 /* Build a GIMPLE_OMP_FOR statement.
950 BODY is sequence of statements inside the for loop.
951 KIND is the `for' variant.
952 CLAUSES are any of the construct's clauses.
953 COLLAPSE is the collapse count.
954 PRE_BODY is the sequence of statements that are loop invariant. */
957 gimple_build_omp_for (gimple_seq body
, int kind
, tree clauses
, size_t collapse
,
960 gomp_for
*p
= as_a
<gomp_for
*> (gimple_alloc (GIMPLE_OMP_FOR
, 0));
962 gimple_omp_set_body (p
, body
);
963 gimple_omp_for_set_clauses (p
, clauses
);
964 gimple_omp_for_set_kind (p
, kind
);
965 p
->collapse
= collapse
;
966 p
->iter
= ggc_cleared_vec_alloc
<gimple_omp_for_iter
> (collapse
);
969 gimple_omp_for_set_pre_body (p
, pre_body
);
975 /* Build a GIMPLE_OMP_PARALLEL statement.
977 BODY is sequence of statements which are executed in parallel.
978 CLAUSES are the OMP parallel construct's clauses.
979 CHILD_FN is the function created for the parallel threads to execute.
980 DATA_ARG are the shared data argument(s). */
983 gimple_build_omp_parallel (gimple_seq body
, tree clauses
, tree child_fn
,
987 = as_a
<gomp_parallel
*> (gimple_alloc (GIMPLE_OMP_PARALLEL
, 0));
989 gimple_omp_set_body (p
, body
);
990 gimple_omp_parallel_set_clauses (p
, clauses
);
991 gimple_omp_parallel_set_child_fn (p
, child_fn
);
992 gimple_omp_parallel_set_data_arg (p
, data_arg
);
998 /* Build a GIMPLE_OMP_TASK statement.
1000 BODY is sequence of statements which are executed by the explicit task.
1001 CLAUSES are the OMP task construct's clauses.
1002 CHILD_FN is the function created for the parallel threads to execute.
1003 DATA_ARG are the shared data argument(s).
1004 COPY_FN is the optional function for firstprivate initialization.
1005 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
1008 gimple_build_omp_task (gimple_seq body
, tree clauses
, tree child_fn
,
1009 tree data_arg
, tree copy_fn
, tree arg_size
,
1012 gomp_task
*p
= as_a
<gomp_task
*> (gimple_alloc (GIMPLE_OMP_TASK
, 0));
1014 gimple_omp_set_body (p
, body
);
1015 gimple_omp_task_set_clauses (p
, clauses
);
1016 gimple_omp_task_set_child_fn (p
, child_fn
);
1017 gimple_omp_task_set_data_arg (p
, data_arg
);
1018 gimple_omp_task_set_copy_fn (p
, copy_fn
);
1019 gimple_omp_task_set_arg_size (p
, arg_size
);
1020 gimple_omp_task_set_arg_align (p
, arg_align
);
1026 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
1028 BODY is the sequence of statements in the section. */
1031 gimple_build_omp_section (gimple_seq body
)
1033 gimple
*p
= gimple_alloc (GIMPLE_OMP_SECTION
, 0);
1035 gimple_omp_set_body (p
, body
);
1041 /* Build a GIMPLE_OMP_STRUCTURED_BLOCK statement.
1043 BODY is the structured block sequence. */
1046 gimple_build_omp_structured_block (gimple_seq body
)
1048 gimple
*p
= gimple_alloc (GIMPLE_OMP_STRUCTURED_BLOCK
, 0);
1050 gimple_omp_set_body (p
, body
);
1056 /* Build a GIMPLE_OMP_MASTER statement.
1058 BODY is the sequence of statements to be executed by just the master. */
1061 gimple_build_omp_master (gimple_seq body
)
1063 gimple
*p
= gimple_alloc (GIMPLE_OMP_MASTER
, 0);
1065 gimple_omp_set_body (p
, body
);
1070 /* Build a GIMPLE_OMP_MASKED statement.
1072 BODY is the sequence of statements to be executed by the selected thread(s). */
1075 gimple_build_omp_masked (gimple_seq body
, tree clauses
)
1077 gimple
*p
= gimple_alloc (GIMPLE_OMP_MASKED
, 0);
1078 gimple_omp_masked_set_clauses (p
, clauses
);
1080 gimple_omp_set_body (p
, body
);
1085 /* Build a GIMPLE_OMP_TASKGROUP statement.
1087 BODY is the sequence of statements to be executed by the taskgroup
1089 CLAUSES are any of the construct's clauses. */
1092 gimple_build_omp_taskgroup (gimple_seq body
, tree clauses
)
1094 gimple
*p
= gimple_alloc (GIMPLE_OMP_TASKGROUP
, 0);
1095 gimple_omp_taskgroup_set_clauses (p
, clauses
);
1097 gimple_omp_set_body (p
, body
);
1103 /* Build a GIMPLE_OMP_CONTINUE statement.
1105 CONTROL_DEF is the definition of the control variable.
1106 CONTROL_USE is the use of the control variable. */
1109 gimple_build_omp_continue (tree control_def
, tree control_use
)
1112 = as_a
<gomp_continue
*> (gimple_alloc (GIMPLE_OMP_CONTINUE
, 0));
1113 gimple_omp_continue_set_control_def (p
, control_def
);
1114 gimple_omp_continue_set_control_use (p
, control_use
);
1118 /* Build a GIMPLE_OMP_ORDERED statement.
1120 BODY is the sequence of statements inside a loop that will executed in
1122 CLAUSES are clauses for this statement. */
1125 gimple_build_omp_ordered (gimple_seq body
, tree clauses
)
1128 = as_a
<gomp_ordered
*> (gimple_alloc (GIMPLE_OMP_ORDERED
, 0));
1129 gimple_omp_ordered_set_clauses (p
, clauses
);
1131 gimple_omp_set_body (p
, body
);
1137 /* Build a GIMPLE_OMP_RETURN statement.
1138 WAIT_P is true if this is a non-waiting return. */
1141 gimple_build_omp_return (bool wait_p
)
1143 gimple
*p
= gimple_alloc (GIMPLE_OMP_RETURN
, 0);
1145 gimple_omp_return_set_nowait (p
);
1151 /* Build a GIMPLE_OMP_SCAN statement.
1153 BODY is the sequence of statements to be executed by the scan
1155 CLAUSES are any of the construct's clauses. */
1158 gimple_build_omp_scan (gimple_seq body
, tree clauses
)
1161 = as_a
<gomp_scan
*> (gimple_alloc (GIMPLE_OMP_SCAN
, 0));
1162 gimple_omp_scan_set_clauses (p
, clauses
);
1164 gimple_omp_set_body (p
, body
);
1170 /* Build a GIMPLE_OMP_SECTIONS statement.
1172 BODY is a sequence of section statements.
1173 CLAUSES are any of the OMP sections contsruct's clauses: private,
1174 firstprivate, lastprivate, reduction, and nowait. */
1177 gimple_build_omp_sections (gimple_seq body
, tree clauses
)
1180 = as_a
<gomp_sections
*> (gimple_alloc (GIMPLE_OMP_SECTIONS
, 0));
1182 gimple_omp_set_body (p
, body
);
1183 gimple_omp_sections_set_clauses (p
, clauses
);
1189 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1192 gimple_build_omp_sections_switch (void)
1194 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH
, 0);
1198 /* Build a GIMPLE_OMP_SINGLE statement.
1200 BODY is the sequence of statements that will be executed once.
1201 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1202 copyprivate, nowait. */
1205 gimple_build_omp_single (gimple_seq body
, tree clauses
)
1208 = as_a
<gomp_single
*> (gimple_alloc (GIMPLE_OMP_SINGLE
, 0));
1210 gimple_omp_set_body (p
, body
);
1211 gimple_omp_single_set_clauses (p
, clauses
);
1217 /* Build a GIMPLE_OMP_SCOPE statement.
1219 BODY is the sequence of statements that will be executed once.
1220 CLAUSES are any of the OMP scope construct's clauses: private, reduction,
1224 gimple_build_omp_scope (gimple_seq body
, tree clauses
)
1226 gimple
*p
= gimple_alloc (GIMPLE_OMP_SCOPE
, 0);
1227 gimple_omp_scope_set_clauses (p
, clauses
);
1229 gimple_omp_set_body (p
, body
);
1235 /* Build a GIMPLE_OMP_TARGET statement.
1237 BODY is the sequence of statements that will be executed.
1238 KIND is the kind of the region.
1239 CLAUSES are any of the construct's clauses. */
1242 gimple_build_omp_target (gimple_seq body
, int kind
, tree clauses
)
1245 = as_a
<gomp_target
*> (gimple_alloc (GIMPLE_OMP_TARGET
, 0));
1247 gimple_omp_set_body (p
, body
);
1248 gimple_omp_target_set_clauses (p
, clauses
);
1249 gimple_omp_target_set_kind (p
, kind
);
1255 /* Build a GIMPLE_OMP_TEAMS statement.
1257 BODY is the sequence of statements that will be executed.
1258 CLAUSES are any of the OMP teams construct's clauses. */
1261 gimple_build_omp_teams (gimple_seq body
, tree clauses
)
1263 gomp_teams
*p
= as_a
<gomp_teams
*> (gimple_alloc (GIMPLE_OMP_TEAMS
, 0));
1265 gimple_omp_set_body (p
, body
);
1266 gimple_omp_teams_set_clauses (p
, clauses
);
1272 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1275 gimple_build_omp_atomic_load (tree lhs
, tree rhs
, enum omp_memory_order mo
)
1278 = as_a
<gomp_atomic_load
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD
, 0));
1279 gimple_omp_atomic_load_set_lhs (p
, lhs
);
1280 gimple_omp_atomic_load_set_rhs (p
, rhs
);
1281 gimple_omp_atomic_set_memory_order (p
, mo
);
1285 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1287 VAL is the value we are storing. */
1290 gimple_build_omp_atomic_store (tree val
, enum omp_memory_order mo
)
1292 gomp_atomic_store
*p
1293 = as_a
<gomp_atomic_store
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE
, 0));
1294 gimple_omp_atomic_store_set_val (p
, val
);
1295 gimple_omp_atomic_set_memory_order (p
, mo
);
1299 /* Build a GIMPLE_ASSUME statement. */
1302 gimple_build_assume (tree guard
, gimple_seq body
)
1304 gimple_statement_assume
*p
1305 = as_a
<gimple_statement_assume
*> (gimple_alloc (GIMPLE_ASSUME
, 0));
1306 gimple_assume_set_guard (p
, guard
);
1307 *gimple_assume_body_ptr (p
) = body
;
1311 /* Build a GIMPLE_TRANSACTION statement. */
1314 gimple_build_transaction (gimple_seq body
)
1317 = as_a
<gtransaction
*> (gimple_alloc (GIMPLE_TRANSACTION
, 0));
1318 gimple_transaction_set_body (p
, body
);
1319 gimple_transaction_set_label_norm (p
, 0);
1320 gimple_transaction_set_label_uninst (p
, 0);
1321 gimple_transaction_set_label_over (p
, 0);
1325 #if defined ENABLE_GIMPLE_CHECKING
1326 /* Complain of a gimple type mismatch and die. */
1329 gimple_check_failed (const gimple
*gs
, const char *file
, int line
,
1330 const char *function
, enum gimple_code code
,
1331 enum tree_code subcode
)
1333 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1334 gimple_code_name
[code
],
1335 get_tree_code_name (subcode
),
1336 gimple_code_name
[gimple_code (gs
)],
1338 ? get_tree_code_name ((enum tree_code
) gs
->subcode
)
1340 function
, trim_filename (file
), line
);
1342 #endif /* ENABLE_GIMPLE_CHECKING */
1345 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1346 *SEQ_P is NULL, a new sequence is allocated. */
1349 gimple_seq_add_stmt (gimple_seq
*seq_p
, gimple
*gs
)
1351 gimple_stmt_iterator si
;
1355 si
= gsi_last (*seq_p
);
1356 gsi_insert_after (&si
, gs
, GSI_NEW_STMT
);
1359 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1360 *SEQ_P is NULL, a new sequence is allocated. This function is
1361 similar to gimple_seq_add_stmt, but does not scan the operands.
1362 During gimplification, we need to manipulate statement sequences
1363 before the def/use vectors have been constructed. */
1366 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple
*gs
)
1368 gimple_stmt_iterator si
;
1373 si
= gsi_last (*seq_p
);
1374 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
1377 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1378 NULL, a new sequence is allocated. */
1381 gimple_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
1383 gimple_stmt_iterator si
;
1387 si
= gsi_last (*dst_p
);
1388 gsi_insert_seq_after (&si
, src
, GSI_NEW_STMT
);
1391 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1392 NULL, a new sequence is allocated. This function is
1393 similar to gimple_seq_add_seq, but does not scan the operands. */
1396 gimple_seq_add_seq_without_update (gimple_seq
*dst_p
, gimple_seq src
)
1398 gimple_stmt_iterator si
;
1402 si
= gsi_last (*dst_p
);
1403 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
1406 /* Determine whether to assign a location to the statement GS. */
1409 should_carry_location_p (gimple
*gs
)
1411 /* Don't emit a line note for a label. We particularly don't want to
1412 emit one for the break label, since it doesn't actually correspond
1413 to the beginning of the loop/switch. */
1414 if (gimple_code (gs
) == GIMPLE_LABEL
)
1420 /* Set the location for gimple statement GS to LOCATION. */
1423 annotate_one_with_location (gimple
*gs
, location_t location
)
1425 if (!gimple_has_location (gs
)
1426 && !gimple_do_not_emit_location_p (gs
)
1427 && should_carry_location_p (gs
))
1428 gimple_set_location (gs
, location
);
1431 /* Set LOCATION for all the statements after iterator GSI in sequence
1432 SEQ. If GSI is pointing to the end of the sequence, start with the
1433 first statement in SEQ. */
1436 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
1437 location_t location
)
1439 if (gsi_end_p (gsi
))
1440 gsi
= gsi_start (seq
);
1444 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
1445 annotate_one_with_location (gsi_stmt (gsi
), location
);
1448 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1451 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
1453 gimple_stmt_iterator i
;
1455 if (gimple_seq_empty_p (stmt_p
))
1458 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
1460 gimple
*gs
= gsi_stmt (i
);
1461 annotate_one_with_location (gs
, location
);
1465 /* Helper function of empty_body_p. Return true if STMT is an empty
1469 empty_stmt_p (gimple
*stmt
)
1471 if (gimple_code (stmt
) == GIMPLE_NOP
)
1473 if (gbind
*bind_stmt
= dyn_cast
<gbind
*> (stmt
))
1474 return empty_body_p (gimple_bind_body (bind_stmt
));
1479 /* Return true if BODY contains nothing but empty statements. */
1482 empty_body_p (gimple_seq body
)
1484 gimple_stmt_iterator i
;
1486 if (gimple_seq_empty_p (body
))
1488 for (i
= gsi_start (body
); !gsi_end_p (i
); gsi_next (&i
))
1489 if (!empty_stmt_p (gsi_stmt (i
))
1490 && !is_gimple_debug (gsi_stmt (i
)))
1497 /* Perform a deep copy of sequence SRC and return the result. */
1500 gimple_seq_copy (gimple_seq src
)
1502 gimple_stmt_iterator gsi
;
1503 gimple_seq new_seq
= NULL
;
1506 for (gsi
= gsi_start (src
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1508 stmt
= gimple_copy (gsi_stmt (gsi
));
1509 gimple_seq_add_stmt (&new_seq
, stmt
);
1517 /* Return true if calls C1 and C2 are known to go to the same function. */
1520 gimple_call_same_target_p (const gimple
*c1
, const gimple
*c2
)
1522 if (gimple_call_internal_p (c1
))
1523 return (gimple_call_internal_p (c2
)
1524 && gimple_call_internal_fn (c1
) == gimple_call_internal_fn (c2
)
1525 && (!gimple_call_internal_unique_p (as_a
<const gcall
*> (c1
))
1528 return (gimple_call_fn (c1
) == gimple_call_fn (c2
)
1529 || (gimple_call_fndecl (c1
)
1530 && gimple_call_fndecl (c1
) == gimple_call_fndecl (c2
)));
1533 /* Detect flags from a GIMPLE_CALL. This is just like
1534 call_expr_flags, but for gimple tuples. */
1537 gimple_call_flags (const gimple
*stmt
)
1541 if (gimple_call_internal_p (stmt
))
1542 flags
= internal_fn_flags (gimple_call_internal_fn (stmt
));
1545 tree decl
= gimple_call_fndecl (stmt
);
1547 flags
= flags_from_decl_or_type (decl
);
1548 flags
|= flags_from_decl_or_type (gimple_call_fntype (stmt
));
1551 if (stmt
->subcode
& GF_CALL_NOTHROW
)
1552 flags
|= ECF_NOTHROW
;
1554 if (stmt
->subcode
& GF_CALL_BY_DESCRIPTOR
)
1555 flags
|= ECF_BY_DESCRIPTOR
;
1560 /* Return the "fn spec" string for call STMT. */
1563 gimple_call_fnspec (const gcall
*stmt
)
1567 if (gimple_call_internal_p (stmt
))
1569 const_tree spec
= internal_fn_fnspec (gimple_call_internal_fn (stmt
));
1576 type
= gimple_call_fntype (stmt
);
1579 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
1581 return TREE_VALUE (TREE_VALUE (attr
));
1583 if (gimple_call_builtin_p (stmt
, BUILT_IN_NORMAL
))
1584 return builtin_fnspec (gimple_call_fndecl (stmt
));
1585 tree fndecl
= gimple_call_fndecl (stmt
);
1586 /* If the call is to a replaceable operator delete and results
1587 from a delete expression as opposed to a direct call to
1588 such operator, then we can treat it as free. */
1590 && DECL_IS_OPERATOR_DELETE_P (fndecl
)
1591 && DECL_IS_REPLACEABLE_OPERATOR (fndecl
)
1592 && gimple_call_from_new_or_delete (stmt
))
1594 /* Similarly operator new can be treated as malloc. */
1596 && DECL_IS_REPLACEABLE_OPERATOR_NEW_P (fndecl
)
1597 && gimple_call_from_new_or_delete (stmt
))
1602 /* Detects argument flags for argument number ARG on call STMT. */
1605 gimple_call_arg_flags (const gcall
*stmt
, unsigned arg
)
1607 attr_fnspec fnspec
= gimple_call_fnspec (stmt
);
1610 if (fnspec
.known_p ())
1611 flags
= fnspec
.arg_eaf_flags (arg
);
1612 tree callee
= gimple_call_fndecl (stmt
);
1615 cgraph_node
*node
= cgraph_node::get (callee
);
1616 modref_summary
*summary
= node
? get_modref_function_summary (node
)
1619 if (summary
&& summary
->arg_flags
.length () > arg
)
1621 int modref_flags
= summary
->arg_flags
[arg
];
1623 /* We have possibly optimized out load. Be conservative here. */
1624 if (!node
->binds_to_current_def_p ())
1625 modref_flags
= interposable_eaf_flags (modref_flags
, flags
);
1626 if (dbg_cnt (ipa_mod_ref_pta
))
1627 flags
|= modref_flags
;
1633 /* Detects argument flags for return slot on call STMT. */
1636 gimple_call_retslot_flags (const gcall
*stmt
)
1638 int flags
= implicit_retslot_eaf_flags
;
1640 tree callee
= gimple_call_fndecl (stmt
);
1643 cgraph_node
*node
= cgraph_node::get (callee
);
1644 modref_summary
*summary
= node
? get_modref_function_summary (node
)
1649 int modref_flags
= summary
->retslot_flags
;
1651 /* We have possibly optimized out load. Be conservative here. */
1652 if (!node
->binds_to_current_def_p ())
1653 modref_flags
= interposable_eaf_flags (modref_flags
, flags
);
1654 if (dbg_cnt (ipa_mod_ref_pta
))
1655 flags
|= modref_flags
;
1661 /* Detects argument flags for static chain on call STMT. */
1664 gimple_call_static_chain_flags (const gcall
*stmt
)
1668 tree callee
= gimple_call_fndecl (stmt
);
1671 cgraph_node
*node
= cgraph_node::get (callee
);
1672 modref_summary
*summary
= node
? get_modref_function_summary (node
)
1675 /* Nested functions should always bind to current def since
1676 there is no public ABI for them. */
1677 gcc_checking_assert (node
->binds_to_current_def_p ());
1680 int modref_flags
= summary
->static_chain_flags
;
1682 if (dbg_cnt (ipa_mod_ref_pta
))
1683 flags
|= modref_flags
;
1689 /* Detects return flags for the call STMT. */
1692 gimple_call_return_flags (const gcall
*stmt
)
1694 if (gimple_call_flags (stmt
) & ECF_MALLOC
)
1697 attr_fnspec fnspec
= gimple_call_fnspec (stmt
);
1699 unsigned int arg_no
;
1700 if (fnspec
.returns_arg (&arg_no
))
1701 return ERF_RETURNS_ARG
| arg_no
;
1703 if (fnspec
.returns_noalias_p ())
1709 /* Return true if call STMT is known to return a non-zero result. */
1712 gimple_call_nonnull_result_p (gcall
*call
)
1714 tree fndecl
= gimple_call_fndecl (call
);
1717 if (flag_delete_null_pointer_checks
&& !flag_check_new
1718 && DECL_IS_OPERATOR_NEW_P (fndecl
)
1719 && !TREE_NOTHROW (fndecl
))
1722 /* References are always non-NULL. */
1723 if (flag_delete_null_pointer_checks
1724 && TREE_CODE (TREE_TYPE (fndecl
)) == REFERENCE_TYPE
)
1727 if (flag_delete_null_pointer_checks
1728 && lookup_attribute ("returns_nonnull",
1729 TYPE_ATTRIBUTES (gimple_call_fntype (call
))))
1731 return gimple_alloca_call_p (call
);
1735 /* If CALL returns a non-null result in an argument, return that arg. */
1738 gimple_call_nonnull_arg (gcall
*call
)
1740 tree fndecl
= gimple_call_fndecl (call
);
1744 unsigned rf
= gimple_call_return_flags (call
);
1745 if (rf
& ERF_RETURNS_ARG
)
1747 unsigned argnum
= rf
& ERF_RETURN_ARG_MASK
;
1748 if (argnum
< gimple_call_num_args (call
))
1750 tree arg
= gimple_call_arg (call
, argnum
);
1752 && infer_nonnull_range_by_attribute (call
, arg
))
1760 /* Return true if GS is a copy assignment. */
1763 gimple_assign_copy_p (gimple
*gs
)
1765 return (gimple_assign_single_p (gs
)
1766 && is_gimple_val (gimple_op (gs
, 1)));
1770 /* Return true if GS is a SSA_NAME copy assignment. */
1773 gimple_assign_ssa_name_copy_p (gimple
*gs
)
1775 return (gimple_assign_single_p (gs
)
1776 && TREE_CODE (gimple_assign_lhs (gs
)) == SSA_NAME
1777 && TREE_CODE (gimple_assign_rhs1 (gs
)) == SSA_NAME
);
1781 /* Return true if GS is an assignment with a unary RHS, but the
1782 operator has no effect on the assigned value. The logic is adapted
1783 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1784 instances in which STRIP_NOPS was previously applied to the RHS of
1787 NOTE: In the use cases that led to the creation of this function
1788 and of gimple_assign_single_p, it is typical to test for either
1789 condition and to proceed in the same manner. In each case, the
1790 assigned value is represented by the single RHS operand of the
1791 assignment. I suspect there may be cases where gimple_assign_copy_p,
1792 gimple_assign_single_p, or equivalent logic is used where a similar
1793 treatment of unary NOPs is appropriate. */
1796 gimple_assign_unary_nop_p (gimple
*gs
)
1798 return (is_gimple_assign (gs
)
1799 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs
))
1800 || gimple_assign_rhs_code (gs
) == NON_LVALUE_EXPR
)
1801 && gimple_assign_rhs1 (gs
) != error_mark_node
1802 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs
)))
1803 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs
)))));
1806 /* Return true if GS is an assignment that loads from its rhs1. */
1809 gimple_assign_load_p (const gimple
*gs
)
1812 if (!gimple_assign_single_p (gs
))
1814 rhs
= gimple_assign_rhs1 (gs
);
1815 if (TREE_CODE (rhs
) == WITH_SIZE_EXPR
)
1817 if (handled_component_p (rhs
))
1818 rhs
= TREE_OPERAND (rhs
, 0);
1819 return (handled_component_p (rhs
)
1821 || TREE_CODE (rhs
) == MEM_REF
1822 || TREE_CODE (rhs
) == TARGET_MEM_REF
);
1826 /* Set BB to be the basic block holding G. */
1829 gimple_set_bb (gimple
*stmt
, basic_block bb
)
1833 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1836 /* If the statement is a label, add the label to block-to-labels map
1837 so that we can speed up edge creation for GIMPLE_GOTOs. */
1843 t
= gimple_label_label (as_a
<glabel
*> (stmt
));
1844 uid
= LABEL_DECL_UID (t
);
1848 vec_safe_length (label_to_block_map_for_fn (cfun
));
1849 LABEL_DECL_UID (t
) = uid
= cfun
->cfg
->last_label_uid
++;
1850 if (old_len
<= (unsigned) uid
)
1851 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun
), uid
+ 1);
1854 (*label_to_block_map_for_fn (cfun
))[uid
] = bb
;
1859 /* Modify the RHS of the assignment pointed-to by GSI using the
1860 operands in the expression tree EXPR.
1862 NOTE: The statement pointed-to by GSI may be reallocated if it
1863 did not have enough operand slots.
1865 This function is useful to convert an existing tree expression into
1866 the flat representation used for the RHS of a GIMPLE assignment.
1867 It will reallocate memory as needed to expand or shrink the number
1868 of operand slots needed to represent EXPR.
1870 NOTE: If you find yourself building a tree and then calling this
1871 function, you are most certainly doing it the slow way. It is much
1872 better to build a new assignment or to use the function
1873 gimple_assign_set_rhs_with_ops, which does not require an
1874 expression tree to be built. */
1877 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*gsi
, tree expr
)
1879 enum tree_code subcode
;
1882 extract_ops_from_tree (expr
, &subcode
, &op1
, &op2
, &op3
);
1883 gimple_assign_set_rhs_with_ops (gsi
, subcode
, op1
, op2
, op3
);
1887 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1888 operands OP1, OP2 and OP3.
1890 NOTE: The statement pointed-to by GSI may be reallocated if it
1891 did not have enough operand slots. */
1894 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*gsi
, enum tree_code code
,
1895 tree op1
, tree op2
, tree op3
)
1897 unsigned new_rhs_ops
= get_gimple_rhs_num_ops (code
);
1898 gimple
*stmt
= gsi_stmt (*gsi
);
1899 gimple
*old_stmt
= stmt
;
1901 /* If the new CODE needs more operands, allocate a new statement. */
1902 if (gimple_num_ops (stmt
) < new_rhs_ops
+ 1)
1904 tree lhs
= gimple_assign_lhs (old_stmt
);
1905 stmt
= gimple_alloc (gimple_code (old_stmt
), new_rhs_ops
+ 1);
1906 memcpy (stmt
, old_stmt
, gimple_size (gimple_code (old_stmt
)));
1907 gimple_init_singleton (stmt
);
1909 /* The LHS needs to be reset as this also changes the SSA name
1911 gimple_assign_set_lhs (stmt
, lhs
);
1914 gimple_set_num_ops (stmt
, new_rhs_ops
+ 1);
1915 gimple_set_subcode (stmt
, code
);
1916 gimple_assign_set_rhs1 (stmt
, op1
);
1917 if (new_rhs_ops
> 1)
1918 gimple_assign_set_rhs2 (stmt
, op2
);
1919 if (new_rhs_ops
> 2)
1920 gimple_assign_set_rhs3 (stmt
, op3
);
1921 if (stmt
!= old_stmt
)
1922 gsi_replace (gsi
, stmt
, false);
1926 /* Return the LHS of a statement that performs an assignment,
1927 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1928 for a call to a function that returns no value, or for a
1929 statement other than an assignment or a call. */
1932 gimple_get_lhs (const gimple
*stmt
)
1934 enum gimple_code code
= gimple_code (stmt
);
1936 if (code
== GIMPLE_ASSIGN
)
1937 return gimple_assign_lhs (stmt
);
1938 else if (code
== GIMPLE_CALL
)
1939 return gimple_call_lhs (stmt
);
1940 else if (code
== GIMPLE_PHI
)
1941 return gimple_phi_result (stmt
);
1947 /* Set the LHS of a statement that performs an assignment,
1948 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1951 gimple_set_lhs (gimple
*stmt
, tree lhs
)
1953 enum gimple_code code
= gimple_code (stmt
);
1955 if (code
== GIMPLE_ASSIGN
)
1956 gimple_assign_set_lhs (stmt
, lhs
);
1957 else if (code
== GIMPLE_CALL
)
1958 gimple_call_set_lhs (stmt
, lhs
);
1964 /* Return a deep copy of statement STMT. All the operands from STMT
1965 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1966 and VUSE operand arrays are set to empty in the new copy. The new
1967 copy isn't part of any sequence. */
1970 gimple_copy (gimple
*stmt
)
1972 enum gimple_code code
= gimple_code (stmt
);
1973 unsigned num_ops
= gimple_num_ops (stmt
);
1974 gimple
*copy
= gimple_alloc (code
, num_ops
);
1977 /* Shallow copy all the fields from STMT. */
1978 memcpy (copy
, stmt
, gimple_size (code
));
1979 gimple_init_singleton (copy
);
1981 /* If STMT has sub-statements, deep-copy them as well. */
1982 if (gimple_has_substatements (stmt
))
1987 switch (gimple_code (stmt
))
1991 gbind
*bind_stmt
= as_a
<gbind
*> (stmt
);
1992 gbind
*bind_copy
= as_a
<gbind
*> (copy
);
1993 new_seq
= gimple_seq_copy (gimple_bind_body (bind_stmt
));
1994 gimple_bind_set_body (bind_copy
, new_seq
);
1995 gimple_bind_set_vars (bind_copy
,
1996 unshare_expr (gimple_bind_vars (bind_stmt
)));
1997 gimple_bind_set_block (bind_copy
, gimple_bind_block (bind_stmt
));
2003 gcatch
*catch_stmt
= as_a
<gcatch
*> (stmt
);
2004 gcatch
*catch_copy
= as_a
<gcatch
*> (copy
);
2005 new_seq
= gimple_seq_copy (gimple_catch_handler (catch_stmt
));
2006 gimple_catch_set_handler (catch_copy
, new_seq
);
2007 t
= unshare_expr (gimple_catch_types (catch_stmt
));
2008 gimple_catch_set_types (catch_copy
, t
);
2012 case GIMPLE_EH_FILTER
:
2014 geh_filter
*eh_filter_stmt
= as_a
<geh_filter
*> (stmt
);
2015 geh_filter
*eh_filter_copy
= as_a
<geh_filter
*> (copy
);
2017 = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt
));
2018 gimple_eh_filter_set_failure (eh_filter_copy
, new_seq
);
2019 t
= unshare_expr (gimple_eh_filter_types (eh_filter_stmt
));
2020 gimple_eh_filter_set_types (eh_filter_copy
, t
);
2024 case GIMPLE_EH_ELSE
:
2026 geh_else
*eh_else_stmt
= as_a
<geh_else
*> (stmt
);
2027 geh_else
*eh_else_copy
= as_a
<geh_else
*> (copy
);
2028 new_seq
= gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt
));
2029 gimple_eh_else_set_n_body (eh_else_copy
, new_seq
);
2030 new_seq
= gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt
));
2031 gimple_eh_else_set_e_body (eh_else_copy
, new_seq
);
2037 gtry
*try_stmt
= as_a
<gtry
*> (stmt
);
2038 gtry
*try_copy
= as_a
<gtry
*> (copy
);
2039 new_seq
= gimple_seq_copy (gimple_try_eval (try_stmt
));
2040 gimple_try_set_eval (try_copy
, new_seq
);
2041 new_seq
= gimple_seq_copy (gimple_try_cleanup (try_stmt
));
2042 gimple_try_set_cleanup (try_copy
, new_seq
);
2046 case GIMPLE_OMP_FOR
:
2047 new_seq
= gimple_seq_copy (gimple_omp_for_pre_body (stmt
));
2048 gimple_omp_for_set_pre_body (copy
, new_seq
);
2049 t
= unshare_expr (gimple_omp_for_clauses (stmt
));
2050 gimple_omp_for_set_clauses (copy
, t
);
2052 gomp_for
*omp_for_copy
= as_a
<gomp_for
*> (copy
);
2053 omp_for_copy
->iter
= ggc_vec_alloc
<gimple_omp_for_iter
>
2054 ( gimple_omp_for_collapse (stmt
));
2056 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
2058 gimple_omp_for_set_cond (copy
, i
,
2059 gimple_omp_for_cond (stmt
, i
));
2060 gimple_omp_for_set_index (copy
, i
,
2061 gimple_omp_for_index (stmt
, i
));
2062 t
= unshare_expr (gimple_omp_for_initial (stmt
, i
));
2063 gimple_omp_for_set_initial (copy
, i
, t
);
2064 t
= unshare_expr (gimple_omp_for_final (stmt
, i
));
2065 gimple_omp_for_set_final (copy
, i
, t
);
2066 t
= unshare_expr (gimple_omp_for_incr (stmt
, i
));
2067 gimple_omp_for_set_incr (copy
, i
, t
);
2071 case GIMPLE_OMP_PARALLEL
:
2073 gomp_parallel
*omp_par_stmt
= as_a
<gomp_parallel
*> (stmt
);
2074 gomp_parallel
*omp_par_copy
= as_a
<gomp_parallel
*> (copy
);
2075 t
= unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt
));
2076 gimple_omp_parallel_set_clauses (omp_par_copy
, t
);
2077 t
= unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt
));
2078 gimple_omp_parallel_set_child_fn (omp_par_copy
, t
);
2079 t
= unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt
));
2080 gimple_omp_parallel_set_data_arg (omp_par_copy
, t
);
2084 case GIMPLE_OMP_TASK
:
2085 t
= unshare_expr (gimple_omp_task_clauses (stmt
));
2086 gimple_omp_task_set_clauses (copy
, t
);
2087 t
= unshare_expr (gimple_omp_task_child_fn (stmt
));
2088 gimple_omp_task_set_child_fn (copy
, t
);
2089 t
= unshare_expr (gimple_omp_task_data_arg (stmt
));
2090 gimple_omp_task_set_data_arg (copy
, t
);
2091 t
= unshare_expr (gimple_omp_task_copy_fn (stmt
));
2092 gimple_omp_task_set_copy_fn (copy
, t
);
2093 t
= unshare_expr (gimple_omp_task_arg_size (stmt
));
2094 gimple_omp_task_set_arg_size (copy
, t
);
2095 t
= unshare_expr (gimple_omp_task_arg_align (stmt
));
2096 gimple_omp_task_set_arg_align (copy
, t
);
2099 case GIMPLE_OMP_CRITICAL
:
2100 t
= unshare_expr (gimple_omp_critical_name
2101 (as_a
<gomp_critical
*> (stmt
)));
2102 gimple_omp_critical_set_name (as_a
<gomp_critical
*> (copy
), t
);
2103 t
= unshare_expr (gimple_omp_critical_clauses
2104 (as_a
<gomp_critical
*> (stmt
)));
2105 gimple_omp_critical_set_clauses (as_a
<gomp_critical
*> (copy
), t
);
2108 case GIMPLE_OMP_ORDERED
:
2109 t
= unshare_expr (gimple_omp_ordered_clauses
2110 (as_a
<gomp_ordered
*> (stmt
)));
2111 gimple_omp_ordered_set_clauses (as_a
<gomp_ordered
*> (copy
), t
);
2114 case GIMPLE_OMP_SCAN
:
2115 t
= gimple_omp_scan_clauses (as_a
<gomp_scan
*> (stmt
));
2116 t
= unshare_expr (t
);
2117 gimple_omp_scan_set_clauses (as_a
<gomp_scan
*> (copy
), t
);
2120 case GIMPLE_OMP_TASKGROUP
:
2121 t
= unshare_expr (gimple_omp_taskgroup_clauses (stmt
));
2122 gimple_omp_taskgroup_set_clauses (copy
, t
);
2125 case GIMPLE_OMP_SECTIONS
:
2126 t
= unshare_expr (gimple_omp_sections_clauses (stmt
));
2127 gimple_omp_sections_set_clauses (copy
, t
);
2128 t
= unshare_expr (gimple_omp_sections_control (stmt
));
2129 gimple_omp_sections_set_control (copy
, t
);
2132 case GIMPLE_OMP_SINGLE
:
2134 gomp_single
*omp_single_copy
= as_a
<gomp_single
*> (copy
);
2135 t
= unshare_expr (gimple_omp_single_clauses (stmt
));
2136 gimple_omp_single_set_clauses (omp_single_copy
, t
);
2140 case GIMPLE_OMP_SCOPE
:
2141 t
= unshare_expr (gimple_omp_scope_clauses (stmt
));
2142 gimple_omp_scope_set_clauses (copy
, t
);
2145 case GIMPLE_OMP_TARGET
:
2147 gomp_target
*omp_target_stmt
= as_a
<gomp_target
*> (stmt
);
2148 gomp_target
*omp_target_copy
= as_a
<gomp_target
*> (copy
);
2149 t
= unshare_expr (gimple_omp_target_clauses (omp_target_stmt
));
2150 gimple_omp_target_set_clauses (omp_target_copy
, t
);
2151 t
= unshare_expr (gimple_omp_target_data_arg (omp_target_stmt
));
2152 gimple_omp_target_set_data_arg (omp_target_copy
, t
);
2156 case GIMPLE_OMP_TEAMS
:
2158 gomp_teams
*omp_teams_copy
= as_a
<gomp_teams
*> (copy
);
2159 t
= unshare_expr (gimple_omp_teams_clauses (stmt
));
2160 gimple_omp_teams_set_clauses (omp_teams_copy
, t
);
2164 case GIMPLE_OMP_SECTION
:
2165 case GIMPLE_OMP_MASTER
:
2166 case GIMPLE_OMP_STRUCTURED_BLOCK
:
2168 new_seq
= gimple_seq_copy (gimple_omp_body (stmt
));
2169 gimple_omp_set_body (copy
, new_seq
);
2172 case GIMPLE_OMP_MASKED
:
2173 t
= unshare_expr (gimple_omp_masked_clauses (stmt
));
2174 gimple_omp_masked_set_clauses (copy
, t
);
2178 new_seq
= gimple_seq_copy (gimple_assume_body (stmt
));
2179 *gimple_assume_body_ptr (copy
) = new_seq
;
2180 gimple_assume_set_guard (copy
,
2181 unshare_expr (gimple_assume_guard (stmt
)));
2184 case GIMPLE_TRANSACTION
:
2185 new_seq
= gimple_seq_copy (gimple_transaction_body (
2186 as_a
<gtransaction
*> (stmt
)));
2187 gimple_transaction_set_body (as_a
<gtransaction
*> (copy
),
2191 case GIMPLE_WITH_CLEANUP_EXPR
:
2192 new_seq
= gimple_seq_copy (gimple_wce_cleanup (stmt
));
2193 gimple_wce_set_cleanup (copy
, new_seq
);
2201 /* Make copy of operands. */
2202 for (i
= 0; i
< num_ops
; i
++)
2203 gimple_set_op (copy
, i
, unshare_expr (gimple_op (stmt
, i
)));
2205 if (gimple_has_mem_ops (stmt
))
2207 gimple_set_vdef (copy
, gimple_vdef (stmt
));
2208 gimple_set_vuse (copy
, gimple_vuse (stmt
));
2211 /* Clear out SSA operand vectors on COPY. */
2212 if (gimple_has_ops (stmt
))
2214 gimple_set_use_ops (copy
, NULL
);
2216 /* SSA operands need to be updated. */
2217 gimple_set_modified (copy
, true);
2220 if (gimple_debug_nonbind_marker_p (stmt
))
2221 cfun
->debug_marker_count
++;
2226 /* Move OLD_STMT's vuse and vdef operands to NEW_STMT, on the assumption
2227 that OLD_STMT is about to be removed. */
2230 gimple_move_vops (gimple
*new_stmt
, gimple
*old_stmt
)
2232 tree vdef
= gimple_vdef (old_stmt
);
2233 gimple_set_vuse (new_stmt
, gimple_vuse (old_stmt
));
2234 gimple_set_vdef (new_stmt
, vdef
);
2235 if (vdef
&& TREE_CODE (vdef
) == SSA_NAME
)
2236 SSA_NAME_DEF_STMT (vdef
) = new_stmt
;
2239 /* Return true if statement S has side-effects. We consider a
2240 statement to have side effects if:
2242 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
2243 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
2246 gimple_has_side_effects (const gimple
*s
)
2248 if (is_gimple_debug (s
))
2251 /* We don't have to scan the arguments to check for
2252 volatile arguments, though, at present, we still
2253 do a scan to check for TREE_SIDE_EFFECTS. */
2254 if (gimple_has_volatile_ops (s
))
2257 if (gimple_code (s
) == GIMPLE_ASM
2258 && gimple_asm_volatile_p (as_a
<const gasm
*> (s
)))
2261 if (is_gimple_call (s
))
2263 int flags
= gimple_call_flags (s
);
2265 /* An infinite loop is considered a side effect. */
2266 if (!(flags
& (ECF_CONST
| ECF_PURE
))
2267 || (flags
& ECF_LOOPING_CONST_OR_PURE
))
2276 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
2277 Return true if S can trap. When INCLUDE_MEM is true, check whether
2278 the memory operations could trap. When INCLUDE_STORES is true and
2279 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
2282 gimple_could_trap_p_1 (const gimple
*s
, bool include_mem
, bool include_stores
)
2284 tree t
, div
= NULL_TREE
;
2289 unsigned i
, start
= (is_gimple_assign (s
) && !include_stores
) ? 1 : 0;
2291 for (i
= start
; i
< gimple_num_ops (s
); i
++)
2292 if (tree_could_trap_p (gimple_op (s
, i
)))
2296 switch (gimple_code (s
))
2299 return gimple_asm_volatile_p (as_a
<const gasm
*> (s
));
2302 if (gimple_call_internal_p (s
))
2304 t
= gimple_call_fndecl (s
);
2305 /* Assume that indirect and calls to weak functions may trap. */
2306 if (!t
|| !DECL_P (t
) || DECL_WEAK (t
))
2311 op
= gimple_assign_rhs_code (s
);
2313 /* For COND_EXPR only the condition may trap. */
2314 if (op
== COND_EXPR
)
2315 return tree_could_trap_p (gimple_assign_rhs1 (s
));
2317 /* For comparisons we need to check rhs operand types instead of lhs type
2318 (which is BOOLEAN_TYPE). */
2319 if (TREE_CODE_CLASS (op
) == tcc_comparison
)
2320 t
= TREE_TYPE (gimple_assign_rhs1 (s
));
2322 t
= TREE_TYPE (gimple_assign_lhs (s
));
2324 if (get_gimple_rhs_class (op
) == GIMPLE_BINARY_RHS
)
2325 div
= gimple_assign_rhs2 (s
);
2327 return (operation_could_trap_p (op
, FLOAT_TYPE_P (t
),
2328 (INTEGRAL_TYPE_P (t
)
2329 && TYPE_OVERFLOW_TRAPS (t
)),
2333 t
= TREE_TYPE (gimple_cond_lhs (s
));
2334 return operation_could_trap_p (gimple_cond_code (s
),
2335 FLOAT_TYPE_P (t
), false, NULL_TREE
);
2344 /* Return true if statement S can trap. */
2347 gimple_could_trap_p (const gimple
*s
)
2349 return gimple_could_trap_p_1 (s
, true, true);
2352 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
2355 gimple_assign_rhs_could_trap_p (gimple
*s
)
2357 gcc_assert (is_gimple_assign (s
));
2358 return gimple_could_trap_p_1 (s
, true, false);
2362 /* Print debugging information for gimple stmts generated. */
2365 dump_gimple_statistics (void)
2368 uint64_t total_tuples
= 0, total_bytes
= 0;
2370 if (! GATHER_STATISTICS
)
2372 fprintf (stderr
, "No GIMPLE statistics\n");
2376 fprintf (stderr
, "\nGIMPLE statements\n");
2377 fprintf (stderr
, "Kind Stmts Bytes\n");
2378 fprintf (stderr
, "---------------------------------------\n");
2379 for (i
= 0; i
< (int) gimple_alloc_kind_all
; ++i
)
2381 fprintf (stderr
, "%-20s %7" PRIu64
"%c %10" PRIu64
"%c\n",
2382 gimple_alloc_kind_names
[i
],
2383 SIZE_AMOUNT (gimple_alloc_counts
[i
]),
2384 SIZE_AMOUNT (gimple_alloc_sizes
[i
]));
2385 total_tuples
+= gimple_alloc_counts
[i
];
2386 total_bytes
+= gimple_alloc_sizes
[i
];
2388 fprintf (stderr
, "---------------------------------------\n");
2389 fprintf (stderr
, "%-20s %7" PRIu64
"%c %10" PRIu64
"%c\n", "Total",
2390 SIZE_AMOUNT (total_tuples
), SIZE_AMOUNT (total_bytes
));
2391 fprintf (stderr
, "---------------------------------------\n");
2395 /* Return the number of operands needed on the RHS of a GIMPLE
2396 assignment for an expression with tree code CODE. */
2399 get_gimple_rhs_num_ops (enum tree_code code
)
2401 switch (get_gimple_rhs_class (code
))
2403 case GIMPLE_UNARY_RHS
:
2404 case GIMPLE_SINGLE_RHS
:
2406 case GIMPLE_BINARY_RHS
:
2408 case GIMPLE_TERNARY_RHS
:
2415 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2417 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2418 : ((TYPE) == tcc_binary \
2419 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2420 : ((TYPE) == tcc_constant \
2421 || (TYPE) == tcc_declaration \
2422 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2423 : ((SYM) == TRUTH_AND_EXPR \
2424 || (SYM) == TRUTH_OR_EXPR \
2425 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2426 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2427 : ((SYM) == COND_EXPR \
2428 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2429 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2430 || (SYM) == DOT_PROD_EXPR \
2431 || (SYM) == SAD_EXPR \
2432 || (SYM) == REALIGN_LOAD_EXPR \
2433 || (SYM) == VEC_COND_EXPR \
2434 || (SYM) == VEC_PERM_EXPR \
2435 || (SYM) == BIT_INSERT_EXPR) ? GIMPLE_TERNARY_RHS \
2436 : ((SYM) == CONSTRUCTOR \
2437 || (SYM) == OBJ_TYPE_REF \
2438 || (SYM) == ADDR_EXPR \
2439 || (SYM) == WITH_SIZE_EXPR \
2440 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2441 : GIMPLE_INVALID_RHS),
2442 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2444 const unsigned char gimple_rhs_class_table
[] = {
2445 #include "all-tree.def"
2449 #undef END_OF_BASE_TREE_CODES
2451 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2452 the positions marked by the set ARGS_TO_SKIP. */
2455 gimple_call_copy_skip_args (gcall
*stmt
, bitmap args_to_skip
)
2458 int nargs
= gimple_call_num_args (stmt
);
2459 auto_vec
<tree
> vargs (nargs
);
2462 for (i
= 0; i
< nargs
; i
++)
2463 if (!bitmap_bit_p (args_to_skip
, i
))
2464 vargs
.quick_push (gimple_call_arg (stmt
, i
));
2466 if (gimple_call_internal_p (stmt
))
2467 new_stmt
= gimple_build_call_internal_vec (gimple_call_internal_fn (stmt
),
2470 new_stmt
= gimple_build_call_vec (gimple_call_fn (stmt
), vargs
);
2472 if (gimple_call_lhs (stmt
))
2473 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2475 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2476 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
2478 if (gimple_has_location (stmt
))
2479 gimple_set_location (new_stmt
, gimple_location (stmt
));
2480 gimple_call_copy_flags (new_stmt
, stmt
);
2481 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2483 gimple_set_modified (new_stmt
, true);
2490 /* Return true if the field decls F1 and F2 are at the same offset.
2492 This is intended to be used on GIMPLE types only. */
2495 gimple_compare_field_offset (tree f1
, tree f2
)
2497 if (DECL_OFFSET_ALIGN (f1
) == DECL_OFFSET_ALIGN (f2
))
2499 tree offset1
= DECL_FIELD_OFFSET (f1
);
2500 tree offset2
= DECL_FIELD_OFFSET (f2
);
2501 return ((offset1
== offset2
2502 /* Once gimplification is done, self-referential offsets are
2503 instantiated as operand #2 of the COMPONENT_REF built for
2504 each access and reset. Therefore, they are not relevant
2505 anymore and fields are interchangeable provided that they
2506 represent the same access. */
2507 || (TREE_CODE (offset1
) == PLACEHOLDER_EXPR
2508 && TREE_CODE (offset2
) == PLACEHOLDER_EXPR
2509 && (DECL_SIZE (f1
) == DECL_SIZE (f2
)
2510 || (TREE_CODE (DECL_SIZE (f1
)) == PLACEHOLDER_EXPR
2511 && TREE_CODE (DECL_SIZE (f2
)) == PLACEHOLDER_EXPR
)
2512 || operand_equal_p (DECL_SIZE (f1
), DECL_SIZE (f2
), 0))
2513 && DECL_ALIGN (f1
) == DECL_ALIGN (f2
))
2514 || operand_equal_p (offset1
, offset2
, 0))
2515 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1
),
2516 DECL_FIELD_BIT_OFFSET (f2
)));
2519 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2520 should be, so handle differing ones specially by decomposing
2521 the offset into a byte and bit offset manually. */
2522 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1
))
2523 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2
)))
2525 unsigned HOST_WIDE_INT byte_offset1
, byte_offset2
;
2526 unsigned HOST_WIDE_INT bit_offset1
, bit_offset2
;
2527 bit_offset1
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1
));
2528 byte_offset1
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1
))
2529 + bit_offset1
/ BITS_PER_UNIT
);
2530 bit_offset2
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2
));
2531 byte_offset2
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2
))
2532 + bit_offset2
/ BITS_PER_UNIT
);
2533 if (byte_offset1
!= byte_offset2
)
2535 return bit_offset1
% BITS_PER_UNIT
== bit_offset2
% BITS_PER_UNIT
;
2542 /* Return a type the same as TYPE except unsigned or
2543 signed according to UNSIGNEDP. */
2546 gimple_signed_or_unsigned_type (bool unsignedp
, tree type
)
2551 type1
= TYPE_MAIN_VARIANT (type
);
2552 if (type1
== signed_char_type_node
2553 || type1
== char_type_node
2554 || type1
== unsigned_char_type_node
)
2555 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2556 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2557 return unsignedp
? unsigned_type_node
: integer_type_node
;
2558 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2559 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2560 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2561 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2562 if (type1
== long_long_integer_type_node
2563 || type1
== long_long_unsigned_type_node
)
2565 ? long_long_unsigned_type_node
2566 : long_long_integer_type_node
;
2568 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2569 if (int_n_enabled_p
[i
]
2570 && (type1
== int_n_trees
[i
].unsigned_type
2571 || type1
== int_n_trees
[i
].signed_type
))
2573 ? int_n_trees
[i
].unsigned_type
2574 : int_n_trees
[i
].signed_type
;
2576 #if HOST_BITS_PER_WIDE_INT >= 64
2577 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2578 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2580 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2581 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2582 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2583 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2584 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2585 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2586 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2587 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2589 #define GIMPLE_FIXED_TYPES(NAME) \
2590 if (type1 == short_ ## NAME ## _type_node \
2591 || type1 == unsigned_short_ ## NAME ## _type_node) \
2592 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2593 : short_ ## NAME ## _type_node; \
2594 if (type1 == NAME ## _type_node \
2595 || type1 == unsigned_ ## NAME ## _type_node) \
2596 return unsignedp ? unsigned_ ## NAME ## _type_node \
2597 : NAME ## _type_node; \
2598 if (type1 == long_ ## NAME ## _type_node \
2599 || type1 == unsigned_long_ ## NAME ## _type_node) \
2600 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2601 : long_ ## NAME ## _type_node; \
2602 if (type1 == long_long_ ## NAME ## _type_node \
2603 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2604 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2605 : long_long_ ## NAME ## _type_node;
2607 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2608 if (type1 == NAME ## _type_node \
2609 || type1 == u ## NAME ## _type_node) \
2610 return unsignedp ? u ## NAME ## _type_node \
2611 : NAME ## _type_node;
2613 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2614 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2615 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2616 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2617 : sat_ ## short_ ## NAME ## _type_node; \
2618 if (type1 == sat_ ## NAME ## _type_node \
2619 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2620 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2621 : sat_ ## NAME ## _type_node; \
2622 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2623 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2624 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2625 : sat_ ## long_ ## NAME ## _type_node; \
2626 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2627 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2628 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2629 : sat_ ## long_long_ ## NAME ## _type_node;
2631 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2632 if (type1 == sat_ ## NAME ## _type_node \
2633 || type1 == sat_ ## u ## NAME ## _type_node) \
2634 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2635 : sat_ ## NAME ## _type_node;
2637 GIMPLE_FIXED_TYPES (fract
);
2638 GIMPLE_FIXED_TYPES_SAT (fract
);
2639 GIMPLE_FIXED_TYPES (accum
);
2640 GIMPLE_FIXED_TYPES_SAT (accum
);
2642 GIMPLE_FIXED_MODE_TYPES (qq
);
2643 GIMPLE_FIXED_MODE_TYPES (hq
);
2644 GIMPLE_FIXED_MODE_TYPES (sq
);
2645 GIMPLE_FIXED_MODE_TYPES (dq
);
2646 GIMPLE_FIXED_MODE_TYPES (tq
);
2647 GIMPLE_FIXED_MODE_TYPES_SAT (qq
);
2648 GIMPLE_FIXED_MODE_TYPES_SAT (hq
);
2649 GIMPLE_FIXED_MODE_TYPES_SAT (sq
);
2650 GIMPLE_FIXED_MODE_TYPES_SAT (dq
);
2651 GIMPLE_FIXED_MODE_TYPES_SAT (tq
);
2652 GIMPLE_FIXED_MODE_TYPES (ha
);
2653 GIMPLE_FIXED_MODE_TYPES (sa
);
2654 GIMPLE_FIXED_MODE_TYPES (da
);
2655 GIMPLE_FIXED_MODE_TYPES (ta
);
2656 GIMPLE_FIXED_MODE_TYPES_SAT (ha
);
2657 GIMPLE_FIXED_MODE_TYPES_SAT (sa
);
2658 GIMPLE_FIXED_MODE_TYPES_SAT (da
);
2659 GIMPLE_FIXED_MODE_TYPES_SAT (ta
);
2661 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2662 the precision; they have precision set to match their range, but
2663 may use a wider mode to match an ABI. If we change modes, we may
2664 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2665 the precision as well, so as to yield correct results for
2666 bit-field types. C++ does not have these separate bit-field
2667 types, and producing a signed or unsigned variant of an
2668 ENUMERAL_TYPE may cause other problems as well. */
2669 if (!INTEGRAL_TYPE_P (type
)
2670 || TYPE_UNSIGNED (type
) == unsignedp
)
2673 #define TYPE_OK(node) \
2674 (TYPE_MODE (type) == TYPE_MODE (node) \
2675 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2676 if (TYPE_OK (signed_char_type_node
))
2677 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2678 if (TYPE_OK (integer_type_node
))
2679 return unsignedp
? unsigned_type_node
: integer_type_node
;
2680 if (TYPE_OK (short_integer_type_node
))
2681 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2682 if (TYPE_OK (long_integer_type_node
))
2683 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2684 if (TYPE_OK (long_long_integer_type_node
))
2686 ? long_long_unsigned_type_node
2687 : long_long_integer_type_node
);
2689 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2690 if (int_n_enabled_p
[i
]
2691 && TYPE_MODE (type
) == int_n_data
[i
].m
2692 && TYPE_PRECISION (type
) == int_n_data
[i
].bitsize
)
2694 ? int_n_trees
[i
].unsigned_type
2695 : int_n_trees
[i
].signed_type
;
2697 #if HOST_BITS_PER_WIDE_INT >= 64
2698 if (TYPE_OK (intTI_type_node
))
2699 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2701 if (TYPE_OK (intDI_type_node
))
2702 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2703 if (TYPE_OK (intSI_type_node
))
2704 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2705 if (TYPE_OK (intHI_type_node
))
2706 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2707 if (TYPE_OK (intQI_type_node
))
2708 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2710 #undef GIMPLE_FIXED_TYPES
2711 #undef GIMPLE_FIXED_MODE_TYPES
2712 #undef GIMPLE_FIXED_TYPES_SAT
2713 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2716 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2720 /* Return an unsigned type the same as TYPE in other respects. */
2723 gimple_unsigned_type (tree type
)
2725 return gimple_signed_or_unsigned_type (true, type
);
2729 /* Return a signed type the same as TYPE in other respects. */
2732 gimple_signed_type (tree type
)
2734 return gimple_signed_or_unsigned_type (false, type
);
2738 /* Return the typed-based alias set for T, which may be an expression
2739 or a type. Return -1 if we don't do anything special. */
2742 gimple_get_alias_set (tree t
)
2744 /* That's all the expressions we handle specially. */
2748 /* For convenience, follow the C standard when dealing with
2749 character types. Any object may be accessed via an lvalue that
2750 has character type. */
2751 if (t
== char_type_node
2752 || t
== signed_char_type_node
2753 || t
== unsigned_char_type_node
)
2756 /* Allow aliasing between signed and unsigned variants of the same
2757 type. We treat the signed variant as canonical. */
2758 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2760 tree t1
= gimple_signed_type (t
);
2762 /* t1 == t can happen for boolean nodes which are always unsigned. */
2764 return get_alias_set (t1
);
2767 /* Allow aliasing between enumeral types and the underlying
2768 integer type. This is required for C since those are
2769 compatible types. */
2770 else if (TREE_CODE (t
) == ENUMERAL_TYPE
)
2772 tree t1
= lang_hooks
.types
.type_for_size (tree_to_uhwi (TYPE_SIZE (t
)),
2773 false /* short-cut above */);
2774 return get_alias_set (t1
);
2781 /* Helper for gimple_ior_addresses_taken_1. */
2784 gimple_ior_addresses_taken_1 (gimple
*, tree addr
, tree
, void *data
)
2786 bitmap addresses_taken
= (bitmap
)data
;
2787 addr
= get_base_address (addr
);
2791 bitmap_set_bit (addresses_taken
, DECL_UID (addr
));
2797 /* Set the bit for the uid of all decls that have their address taken
2798 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2799 were any in this stmt. */
2802 gimple_ior_addresses_taken (bitmap addresses_taken
, gimple
*stmt
)
2804 return walk_stmt_load_store_addr_ops (stmt
, addresses_taken
, NULL
, NULL
,
2805 gimple_ior_addresses_taken_1
);
2809 /* Return true when STMTs arguments and return value match those of FNDECL,
2810 a decl of a builtin function. */
2813 gimple_builtin_call_types_compatible_p (const gimple
*stmt
, tree fndecl
)
2815 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
);
2817 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
2818 if (tree decl
= builtin_decl_explicit (DECL_FUNCTION_CODE (fndecl
)))
2821 tree ret
= gimple_call_lhs (stmt
);
2823 && !useless_type_conversion_p (TREE_TYPE (ret
),
2824 TREE_TYPE (TREE_TYPE (fndecl
))))
2827 tree targs
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2828 unsigned nargs
= gimple_call_num_args (stmt
);
2829 for (unsigned i
= 0; i
< nargs
; ++i
)
2831 /* Variadic args follow. */
2834 tree arg
= gimple_call_arg (stmt
, i
);
2835 tree type
= TREE_VALUE (targs
);
2836 if (!useless_type_conversion_p (type
, TREE_TYPE (arg
))
2837 /* char/short integral arguments are promoted to int
2838 by several frontends if targetm.calls.promote_prototypes
2839 is true. Allow such promotion too. */
2840 && !(INTEGRAL_TYPE_P (type
)
2841 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)
2842 && targetm
.calls
.promote_prototypes (TREE_TYPE (fndecl
))
2843 && useless_type_conversion_p (integer_type_node
,
2846 targs
= TREE_CHAIN (targs
);
2848 if (targs
&& !VOID_TYPE_P (TREE_VALUE (targs
)))
2853 /* Return true when STMT is operator a replaceable delete call. */
2856 gimple_call_operator_delete_p (const gcall
*stmt
)
2860 if ((fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
)
2861 return DECL_IS_OPERATOR_DELETE_P (fndecl
);
2865 /* Return true when STMT is builtins call. */
2868 gimple_call_builtin_p (const gimple
*stmt
)
2871 if (is_gimple_call (stmt
)
2872 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2873 && DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
)
2874 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2878 /* Return true when STMT is builtins call to CLASS. */
2881 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_class klass
)
2884 if (is_gimple_call (stmt
)
2885 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2886 && DECL_BUILT_IN_CLASS (fndecl
) == klass
)
2887 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2891 /* Return true when STMT is builtins call to CODE of CLASS. */
2894 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_function code
)
2897 if (is_gimple_call (stmt
)
2898 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2899 && fndecl_built_in_p (fndecl
, code
))
2900 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2904 /* If CALL is a call to a combined_fn (i.e. an internal function or
2905 a normal built-in function), return its code, otherwise return
2909 gimple_call_combined_fn (const gimple
*stmt
)
2911 if (const gcall
*call
= dyn_cast
<const gcall
*> (stmt
))
2913 if (gimple_call_internal_p (call
))
2914 return as_combined_fn (gimple_call_internal_fn (call
));
2916 tree fndecl
= gimple_call_fndecl (stmt
);
2918 && fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
)
2919 && gimple_builtin_call_types_compatible_p (stmt
, fndecl
))
2920 return as_combined_fn (DECL_FUNCTION_CODE (fndecl
));
2925 /* Return true if STMT clobbers memory. STMT is required to be a
2929 gimple_asm_clobbers_memory_p (const gasm
*stmt
)
2933 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
2935 tree op
= gimple_asm_clobber_op (stmt
, i
);
2936 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op
)), "memory") == 0)
2940 /* Non-empty basic ASM implicitly clobbers memory. */
2941 if (gimple_asm_input_p (stmt
) && strlen (gimple_asm_string (stmt
)) != 0)
2947 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2950 dump_decl_set (FILE *file
, bitmap set
)
2957 fprintf (file
, "{ ");
2959 EXECUTE_IF_SET_IN_BITMAP (set
, 0, i
, bi
)
2961 fprintf (file
, "D.%u", i
);
2962 fprintf (file
, " ");
2965 fprintf (file
, "}");
2968 fprintf (file
, "NIL");
2971 /* Return true when CALL is a call stmt that definitely doesn't
2972 free any memory or makes it unavailable otherwise. */
2974 nonfreeing_call_p (gimple
*call
)
2976 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2977 && gimple_call_flags (call
) & ECF_LEAF
)
2978 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call
)))
2980 /* Just in case these become ECF_LEAF in the future. */
2982 case BUILT_IN_TM_FREE
:
2983 case BUILT_IN_REALLOC
:
2984 case BUILT_IN_STACK_RESTORE
:
2989 else if (gimple_call_internal_p (call
))
2990 switch (gimple_call_internal_fn (call
))
2992 case IFN_ABNORMAL_DISPATCHER
:
2995 return tree_to_uhwi (gimple_call_arg (call
, 0)) == ASAN_MARK_UNPOISON
;
2997 if (gimple_call_flags (call
) & ECF_LEAF
)
3002 tree fndecl
= gimple_call_fndecl (call
);
3005 struct cgraph_node
*n
= cgraph_node::get (fndecl
);
3008 enum availability availability
;
3009 n
= n
->function_symbol (&availability
);
3010 if (!n
|| availability
<= AVAIL_INTERPOSABLE
)
3012 return n
->nonfreeing_fn
;
3015 /* Return true when CALL is a call stmt that definitely need not
3016 be considered to be a memory barrier. */
3018 nonbarrier_call_p (gimple
*call
)
3020 if (gimple_call_flags (call
) & (ECF_PURE
| ECF_CONST
))
3022 /* Should extend this to have a nonbarrier_fn flag, just as above in
3023 the nonfreeing case. */
3027 /* Callback for walk_stmt_load_store_ops.
3029 Return TRUE if OP will dereference the tree stored in DATA, FALSE
3032 This routine only makes a superficial check for a dereference. Thus
3033 it must only be used if it is safe to return a false negative. */
3035 check_loadstore (gimple
*, tree op
, tree
, void *data
)
3037 if (TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
3039 /* Some address spaces may legitimately dereference zero. */
3040 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (op
));
3041 if (targetm
.addr_space
.zero_address_valid (as
))
3044 return operand_equal_p (TREE_OPERAND (op
, 0), (tree
)data
, 0);
3050 /* Return true if OP can be inferred to be non-NULL after STMT executes,
3051 either by using a pointer dereference or attributes. */
3053 infer_nonnull_range (gimple
*stmt
, tree op
)
3055 return (infer_nonnull_range_by_dereference (stmt
, op
)
3056 || infer_nonnull_range_by_attribute (stmt
, op
));
3059 /* Return true if OP can be inferred to be non-NULL after STMT
3060 executes by using a pointer dereference. */
3062 infer_nonnull_range_by_dereference (gimple
*stmt
, tree op
)
3064 /* We can only assume that a pointer dereference will yield
3065 non-NULL if -fdelete-null-pointer-checks is enabled. */
3066 if (!flag_delete_null_pointer_checks
3067 || !POINTER_TYPE_P (TREE_TYPE (op
))
3068 || gimple_code (stmt
) == GIMPLE_ASM
3069 || gimple_clobber_p (stmt
))
3072 if (walk_stmt_load_store_ops (stmt
, (void *)op
,
3073 check_loadstore
, check_loadstore
))
3079 /* Return true if OP can be inferred to be a non-NULL after STMT
3080 executes by using attributes. */
3082 infer_nonnull_range_by_attribute (gimple
*stmt
, tree op
)
3084 /* We can only assume that a pointer dereference will yield
3085 non-NULL if -fdelete-null-pointer-checks is enabled. */
3086 if (!flag_delete_null_pointer_checks
3087 || !POINTER_TYPE_P (TREE_TYPE (op
))
3088 || gimple_code (stmt
) == GIMPLE_ASM
)
3091 if (is_gimple_call (stmt
) && !gimple_call_internal_p (stmt
))
3093 tree fntype
= gimple_call_fntype (stmt
);
3094 tree attrs
= TYPE_ATTRIBUTES (fntype
);
3095 for (; attrs
; attrs
= TREE_CHAIN (attrs
))
3097 attrs
= lookup_attribute ("nonnull", attrs
);
3099 /* If "nonnull" wasn't specified, we know nothing about
3101 if (attrs
== NULL_TREE
)
3104 /* If "nonnull" applies to all the arguments, then ARG
3105 is non-null if it's in the argument list. */
3106 if (TREE_VALUE (attrs
) == NULL_TREE
)
3108 for (unsigned int i
= 0; i
< gimple_call_num_args (stmt
); i
++)
3110 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt
, i
)))
3111 && operand_equal_p (op
, gimple_call_arg (stmt
, i
), 0))
3117 /* Now see if op appears in the nonnull list. */
3118 for (tree t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
3120 unsigned int idx
= TREE_INT_CST_LOW (TREE_VALUE (t
)) - 1;
3121 if (idx
< gimple_call_num_args (stmt
))
3123 tree arg
= gimple_call_arg (stmt
, idx
);
3124 if (operand_equal_p (op
, arg
, 0))
3131 /* If this function is marked as returning non-null, then we can
3132 infer OP is non-null if it is used in the return statement. */
3133 if (greturn
*return_stmt
= dyn_cast
<greturn
*> (stmt
))
3134 if (gimple_return_retval (return_stmt
)
3135 && operand_equal_p (gimple_return_retval (return_stmt
), op
, 0)
3136 && lookup_attribute ("returns_nonnull",
3137 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
))))
3143 /* Compare two case labels. Because the front end should already have
3144 made sure that case ranges do not overlap, it is enough to only compare
3145 the CASE_LOW values of each case label. */
3148 compare_case_labels (const void *p1
, const void *p2
)
3150 const_tree
const case1
= *(const_tree
const*)p1
;
3151 const_tree
const case2
= *(const_tree
const*)p2
;
3153 /* The 'default' case label always goes first. */
3154 if (!CASE_LOW (case1
))
3156 else if (!CASE_LOW (case2
))
3159 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
3162 /* Sort the case labels in LABEL_VEC in place in ascending order. */
3165 sort_case_labels (vec
<tree
> &label_vec
)
3167 label_vec
.qsort (compare_case_labels
);
3170 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
3172 LABELS is a vector that contains all case labels to look at.
3174 INDEX_TYPE is the type of the switch index expression. Case labels
3175 in LABELS are discarded if their values are not in the value range
3176 covered by INDEX_TYPE. The remaining case label values are folded
3179 If a default case exists in LABELS, it is removed from LABELS and
3180 returned in DEFAULT_CASEP. If no default case exists, but the
3181 case labels already cover the whole range of INDEX_TYPE, a default
3182 case is returned pointing to one of the existing case labels.
3183 Otherwise DEFAULT_CASEP is set to NULL_TREE.
3185 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
3186 apply and no action is taken regardless of whether a default case is
3190 preprocess_case_label_vec_for_gimple (vec
<tree
> &labels
,
3192 tree
*default_casep
)
3194 tree min_value
, max_value
;
3195 tree default_case
= NULL_TREE
;
3199 min_value
= TYPE_MIN_VALUE (index_type
);
3200 max_value
= TYPE_MAX_VALUE (index_type
);
3201 while (i
< labels
.length ())
3203 tree elt
= labels
[i
];
3204 tree low
= CASE_LOW (elt
);
3205 tree high
= CASE_HIGH (elt
);
3206 bool remove_element
= false;
3210 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
3211 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
3213 /* This is a non-default case label, i.e. it has a value.
3215 See if the case label is reachable within the range of
3216 the index type. Remove out-of-range case values. Turn
3217 case ranges into a canonical form (high > low strictly)
3218 and convert the case label values to the index type.
3220 NB: The type of gimple_switch_index() may be the promoted
3221 type, but the case labels retain the original type. */
3225 /* This is a case range. Discard empty ranges.
3226 If the bounds or the range are equal, turn this
3227 into a simple (one-value) case. */
3228 int cmp
= tree_int_cst_compare (high
, low
);
3230 remove_element
= true;
3237 /* If the simple case value is unreachable, ignore it. */
3238 if ((TREE_CODE (min_value
) == INTEGER_CST
3239 && tree_int_cst_compare (low
, min_value
) < 0)
3240 || (TREE_CODE (max_value
) == INTEGER_CST
3241 && tree_int_cst_compare (low
, max_value
) > 0))
3242 remove_element
= true;
3244 low
= fold_convert (index_type
, low
);
3248 /* If the entire case range is unreachable, ignore it. */
3249 if ((TREE_CODE (min_value
) == INTEGER_CST
3250 && tree_int_cst_compare (high
, min_value
) < 0)
3251 || (TREE_CODE (max_value
) == INTEGER_CST
3252 && tree_int_cst_compare (low
, max_value
) > 0))
3253 remove_element
= true;
3256 /* If the lower bound is less than the index type's
3257 minimum value, truncate the range bounds. */
3258 if (TREE_CODE (min_value
) == INTEGER_CST
3259 && tree_int_cst_compare (low
, min_value
) < 0)
3261 low
= fold_convert (index_type
, low
);
3263 /* If the upper bound is greater than the index type's
3264 maximum value, truncate the range bounds. */
3265 if (TREE_CODE (max_value
) == INTEGER_CST
3266 && tree_int_cst_compare (high
, max_value
) > 0)
3268 high
= fold_convert (index_type
, high
);
3270 /* We may have folded a case range to a one-value case. */
3271 if (tree_int_cst_equal (low
, high
))
3276 CASE_LOW (elt
) = low
;
3277 CASE_HIGH (elt
) = high
;
3281 gcc_assert (!default_case
);
3283 /* The default case must be passed separately to the
3284 gimple_build_switch routine. But if DEFAULT_CASEP
3285 is NULL, we do not remove the default case (it would
3286 be completely lost). */
3288 remove_element
= true;
3292 labels
.ordered_remove (i
);
3298 if (!labels
.is_empty ())
3299 sort_case_labels (labels
);
3301 if (default_casep
&& !default_case
)
3303 /* If the switch has no default label, add one, so that we jump
3304 around the switch body. If the labels already cover the whole
3305 range of the switch index_type, add the default label pointing
3306 to one of the existing labels. */
3308 && TYPE_MIN_VALUE (index_type
)
3309 && TYPE_MAX_VALUE (index_type
)
3310 && tree_int_cst_equal (CASE_LOW (labels
[0]),
3311 TYPE_MIN_VALUE (index_type
)))
3313 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
3315 high
= CASE_LOW (labels
[len
- 1]);
3316 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
3318 tree widest_label
= labels
[0];
3319 for (i
= 1; i
< len
; i
++)
3321 high
= CASE_LOW (labels
[i
]);
3322 low
= CASE_HIGH (labels
[i
- 1]);
3324 low
= CASE_LOW (labels
[i
- 1]);
3326 if (CASE_HIGH (labels
[i
]) != NULL_TREE
3327 && (CASE_HIGH (widest_label
) == NULL_TREE
3329 (wi::to_wide (CASE_HIGH (labels
[i
]))
3330 - wi::to_wide (CASE_LOW (labels
[i
])),
3331 wi::to_wide (CASE_HIGH (widest_label
))
3332 - wi::to_wide (CASE_LOW (widest_label
))))))
3333 widest_label
= labels
[i
];
3335 if (wi::to_wide (low
) + 1 != wi::to_wide (high
))
3340 /* Designate the label with the widest range to be the
3342 tree label
= CASE_LABEL (widest_label
);
3343 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
3351 *default_casep
= default_case
;
3354 /* Set the location of all statements in SEQ to LOC. */
3357 gimple_seq_set_location (gimple_seq seq
, location_t loc
)
3359 for (gimple_stmt_iterator i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
3360 gimple_set_location (gsi_stmt (i
), loc
);
3363 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
3366 gimple_seq_discard (gimple_seq seq
)
3368 gimple_stmt_iterator gsi
;
3370 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); )
3372 gimple
*stmt
= gsi_stmt (gsi
);
3373 gsi_remove (&gsi
, true);
3374 release_defs (stmt
);
3379 /* See if STMT now calls function that takes no parameters and if so, drop
3380 call arguments. This is used when devirtualization machinery redirects
3381 to __builtin_unreachable or __cxa_pure_virtual. */
3384 maybe_remove_unused_call_args (struct function
*fn
, gimple
*stmt
)
3386 tree decl
= gimple_call_fndecl (stmt
);
3387 if (TYPE_ARG_TYPES (TREE_TYPE (decl
))
3388 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
))) == void_type_node
3389 && gimple_call_num_args (stmt
))
3391 gimple_set_num_ops (stmt
, 3);
3392 update_stmt_fn (fn
, stmt
);
3396 /* Return false if STMT will likely expand to real function call. */
3399 gimple_inexpensive_call_p (gcall
*stmt
)
3401 if (gimple_call_internal_p (stmt
))
3403 tree decl
= gimple_call_fndecl (stmt
);
3404 if (decl
&& is_inexpensive_builtin (decl
))
3409 /* Return a non-artificial location for STMT. If STMT does not have
3410 location information, get the location from EXPR. */
3413 gimple_or_expr_nonartificial_location (gimple
*stmt
, tree expr
)
3415 location_t loc
= gimple_nonartificial_location (stmt
);
3416 if (loc
== UNKNOWN_LOCATION
&& EXPR_HAS_LOCATION (expr
))
3417 loc
= tree_nonartificial_location (expr
);
3418 return expansion_point_location_if_in_system_header (loc
);
3424 namespace selftest
{
3426 /* Selftests for core gimple structures. */
3428 /* Verify that STMT is pretty-printed as EXPECTED.
3429 Helper function for selftests. */
3432 verify_gimple_pp (const char *expected
, gimple
*stmt
)
3435 pp_gimple_stmt_1 (&pp
, stmt
, 0 /* spc */, TDF_NONE
/* flags */);
3436 ASSERT_STREQ (expected
, pp_formatted_text (&pp
));
3439 /* Build a GIMPLE_ASSIGN equivalent to
3441 and verify various properties of it. */
3444 test_assign_single ()
3446 tree type
= integer_type_node
;
3447 tree lhs
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3448 get_identifier ("tmp"),
3450 tree rhs
= build_int_cst (type
, 5);
3451 gassign
*stmt
= gimple_build_assign (lhs
, rhs
);
3452 verify_gimple_pp ("tmp = 5;", stmt
);
3454 ASSERT_TRUE (is_gimple_assign (stmt
));
3455 ASSERT_EQ (lhs
, gimple_assign_lhs (stmt
));
3456 ASSERT_EQ (lhs
, gimple_get_lhs (stmt
));
3457 ASSERT_EQ (rhs
, gimple_assign_rhs1 (stmt
));
3458 ASSERT_EQ (NULL
, gimple_assign_rhs2 (stmt
));
3459 ASSERT_EQ (NULL
, gimple_assign_rhs3 (stmt
));
3460 ASSERT_TRUE (gimple_assign_single_p (stmt
));
3461 ASSERT_EQ (INTEGER_CST
, gimple_assign_rhs_code (stmt
));
3464 /* Build a GIMPLE_ASSIGN equivalent to
3466 and verify various properties of it. */
3469 test_assign_binop ()
3471 tree type
= integer_type_node
;
3472 tree lhs
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3473 get_identifier ("tmp"),
3475 tree a
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3476 get_identifier ("a"),
3478 tree b
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3479 get_identifier ("b"),
3481 gassign
*stmt
= gimple_build_assign (lhs
, MULT_EXPR
, a
, b
);
3482 verify_gimple_pp ("tmp = a * b;", stmt
);
3484 ASSERT_TRUE (is_gimple_assign (stmt
));
3485 ASSERT_EQ (lhs
, gimple_assign_lhs (stmt
));
3486 ASSERT_EQ (lhs
, gimple_get_lhs (stmt
));
3487 ASSERT_EQ (a
, gimple_assign_rhs1 (stmt
));
3488 ASSERT_EQ (b
, gimple_assign_rhs2 (stmt
));
3489 ASSERT_EQ (NULL
, gimple_assign_rhs3 (stmt
));
3490 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3491 ASSERT_EQ (MULT_EXPR
, gimple_assign_rhs_code (stmt
));
3494 /* Build a GIMPLE_NOP and verify various properties of it. */
3499 gimple
*stmt
= gimple_build_nop ();
3500 verify_gimple_pp ("GIMPLE_NOP", stmt
);
3501 ASSERT_EQ (GIMPLE_NOP
, gimple_code (stmt
));
3502 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3503 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3506 /* Build a GIMPLE_RETURN equivalent to
3508 and verify various properties of it. */
3513 tree type
= integer_type_node
;
3514 tree val
= build_int_cst (type
, 7);
3515 greturn
*stmt
= gimple_build_return (val
);
3516 verify_gimple_pp ("return 7;", stmt
);
3518 ASSERT_EQ (GIMPLE_RETURN
, gimple_code (stmt
));
3519 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3520 ASSERT_EQ (val
, gimple_return_retval (stmt
));
3521 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3524 /* Build a GIMPLE_RETURN equivalent to
3526 and verify various properties of it. */
3529 test_return_without_value ()
3531 greturn
*stmt
= gimple_build_return (NULL
);
3532 verify_gimple_pp ("return;", stmt
);
3534 ASSERT_EQ (GIMPLE_RETURN
, gimple_code (stmt
));
3535 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3536 ASSERT_EQ (NULL
, gimple_return_retval (stmt
));
3537 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3540 /* Run all of the selftests within this file. */
3545 test_assign_single ();
3546 test_assign_binop ();
3548 test_return_stmt ();
3549 test_return_without_value ();
3552 } // namespace selftest
3555 #endif /* CHECKING_P */