1 /* Gimple IR support functions.
3 Copyright (C) 2007-2021 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"
47 #include "langhooks.h"
48 #include "attr-fnspec.h"
49 #include "ipa-modref-tree.h"
50 #include "ipa-modref.h"
53 /* All the tuples have their operand vector (if present) at the very bottom
54 of the structure. Therefore, the offset required to find the
55 operands vector the size of the structure minus the size of the 1
56 element tree array at the end (see gimple_ops). */
57 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
58 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
59 EXPORTED_CONST
size_t gimple_ops_offset_
[] = {
60 #include "gsstruct.def"
64 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
65 static const size_t gsstruct_code_size
[] = {
66 #include "gsstruct.def"
70 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
71 const char *const gimple_code_name
[] = {
76 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
77 EXPORTED_CONST
enum gimple_statement_structure_enum gss_for_code_
[] = {
84 uint64_t gimple_alloc_counts
[(int) gimple_alloc_kind_all
];
85 uint64_t gimple_alloc_sizes
[(int) gimple_alloc_kind_all
];
87 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
88 static const char * const gimple_alloc_kind_names
[] = {
95 /* Static gimple tuple members. */
96 const enum gimple_code
gassign::code_
;
97 const enum gimple_code
gcall::code_
;
98 const enum gimple_code
gcond::code_
;
101 /* Gimple tuple constructors.
102 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
103 be passed a NULL to start with an empty sequence. */
105 /* Set the code for statement G to CODE. */
108 gimple_set_code (gimple
*g
, enum gimple_code code
)
113 /* Return the number of bytes needed to hold a GIMPLE statement with
117 gimple_size (enum gimple_code code
, unsigned num_ops
)
119 size_t size
= gsstruct_code_size
[gss_for_code (code
)];
121 size
+= (sizeof (tree
) * (num_ops
- 1));
125 /* Initialize GIMPLE statement G with CODE and NUM_OPS. */
128 gimple_init (gimple
*g
, enum gimple_code code
, unsigned num_ops
)
130 gimple_set_code (g
, code
);
131 gimple_set_num_ops (g
, num_ops
);
133 /* Do not call gimple_set_modified here as it has other side
134 effects and this tuple is still not completely built. */
136 gimple_init_singleton (g
);
139 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
143 gimple_alloc (enum gimple_code code
, unsigned num_ops MEM_STAT_DECL
)
148 size
= gimple_size (code
, num_ops
);
149 if (GATHER_STATISTICS
)
151 enum gimple_alloc_kind kind
= gimple_alloc_kind (code
);
152 gimple_alloc_counts
[(int) kind
]++;
153 gimple_alloc_sizes
[(int) kind
] += size
;
156 stmt
= ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT
);
157 gimple_init (stmt
, code
, num_ops
);
161 /* Set SUBCODE to be the code of the expression computed by statement G. */
164 gimple_set_subcode (gimple
*g
, unsigned subcode
)
166 /* We only have 16 bits for the RHS code. Assert that we are not
168 gcc_assert (subcode
< (1 << 16));
169 g
->subcode
= subcode
;
174 /* Build a tuple with operands. CODE is the statement to build (which
175 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
176 for the new tuple. NUM_OPS is the number of operands to allocate. */
178 #define gimple_build_with_ops(c, s, n) \
179 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
182 gimple_build_with_ops_stat (enum gimple_code code
, unsigned subcode
,
183 unsigned num_ops MEM_STAT_DECL
)
185 gimple
*s
= gimple_alloc (code
, num_ops PASS_MEM_STAT
);
186 gimple_set_subcode (s
, subcode
);
192 /* Build a GIMPLE_RETURN statement returning RETVAL. */
195 gimple_build_return (tree retval
)
198 = as_a
<greturn
*> (gimple_build_with_ops (GIMPLE_RETURN
, ERROR_MARK
,
201 gimple_return_set_retval (s
, retval
);
205 /* Reset alias information on call S. */
208 gimple_call_reset_alias_info (gcall
*s
)
210 if (gimple_call_flags (s
) & ECF_CONST
)
211 memset (gimple_call_use_set (s
), 0, sizeof (struct pt_solution
));
213 pt_solution_reset (gimple_call_use_set (s
));
214 if (gimple_call_flags (s
) & (ECF_CONST
|ECF_PURE
|ECF_NOVOPS
))
215 memset (gimple_call_clobber_set (s
), 0, sizeof (struct pt_solution
));
217 pt_solution_reset (gimple_call_clobber_set (s
));
220 /* Helper for gimple_build_call, gimple_build_call_valist,
221 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
222 components of a GIMPLE_CALL statement to function FN with NARGS
225 static inline gcall
*
226 gimple_build_call_1 (tree fn
, unsigned nargs
)
229 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
231 if (TREE_CODE (fn
) == FUNCTION_DECL
)
232 fn
= build_fold_addr_expr (fn
);
233 gimple_set_op (s
, 1, fn
);
234 gimple_call_set_fntype (s
, TREE_TYPE (TREE_TYPE (fn
)));
235 gimple_call_reset_alias_info (s
);
240 /* Build a GIMPLE_CALL statement to function FN with the arguments
241 specified in vector ARGS. */
244 gimple_build_call_vec (tree fn
, const vec
<tree
> &args
)
247 unsigned nargs
= args
.length ();
248 gcall
*call
= gimple_build_call_1 (fn
, nargs
);
250 for (i
= 0; i
< nargs
; i
++)
251 gimple_call_set_arg (call
, i
, args
[i
]);
257 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
258 arguments. The ... are the arguments. */
261 gimple_build_call (tree fn
, unsigned nargs
, ...)
267 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
269 call
= gimple_build_call_1 (fn
, nargs
);
271 va_start (ap
, nargs
);
272 for (i
= 0; i
< nargs
; i
++)
273 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
280 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
281 arguments. AP contains the arguments. */
284 gimple_build_call_valist (tree fn
, unsigned nargs
, va_list ap
)
289 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
291 call
= gimple_build_call_1 (fn
, nargs
);
293 for (i
= 0; i
< nargs
; i
++)
294 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
300 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
301 Build the basic components of a GIMPLE_CALL statement to internal
302 function FN with NARGS arguments. */
304 static inline gcall
*
305 gimple_build_call_internal_1 (enum internal_fn fn
, unsigned nargs
)
308 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
310 s
->subcode
|= GF_CALL_INTERNAL
;
311 gimple_call_set_internal_fn (s
, fn
);
312 gimple_call_reset_alias_info (s
);
317 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
318 the number of arguments. The ... are the arguments. */
321 gimple_build_call_internal (enum internal_fn fn
, unsigned nargs
, ...)
327 call
= gimple_build_call_internal_1 (fn
, nargs
);
328 va_start (ap
, nargs
);
329 for (i
= 0; i
< nargs
; i
++)
330 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
337 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
338 specified in vector ARGS. */
341 gimple_build_call_internal_vec (enum internal_fn fn
, const vec
<tree
> &args
)
346 nargs
= args
.length ();
347 call
= gimple_build_call_internal_1 (fn
, nargs
);
348 for (i
= 0; i
< nargs
; i
++)
349 gimple_call_set_arg (call
, i
, args
[i
]);
355 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
356 assumed to be in GIMPLE form already. Minimal checking is done of
360 gimple_build_call_from_tree (tree t
, tree fnptrtype
)
365 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
367 nargs
= call_expr_nargs (t
);
369 tree fndecl
= NULL_TREE
;
370 if (CALL_EXPR_FN (t
) == NULL_TREE
)
371 call
= gimple_build_call_internal_1 (CALL_EXPR_IFN (t
), nargs
);
374 fndecl
= get_callee_fndecl (t
);
375 call
= gimple_build_call_1 (fndecl
? fndecl
: CALL_EXPR_FN (t
), nargs
);
378 for (i
= 0; i
< nargs
; i
++)
379 gimple_call_set_arg (call
, i
, CALL_EXPR_ARG (t
, i
));
381 gimple_set_block (call
, TREE_BLOCK (t
));
382 gimple_set_location (call
, EXPR_LOCATION (t
));
384 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
385 gimple_call_set_chain (call
, CALL_EXPR_STATIC_CHAIN (t
));
386 gimple_call_set_tail (call
, CALL_EXPR_TAILCALL (t
));
387 gimple_call_set_must_tail (call
, CALL_EXPR_MUST_TAIL_CALL (t
));
388 gimple_call_set_return_slot_opt (call
, CALL_EXPR_RETURN_SLOT_OPT (t
));
390 && fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
)
391 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl
)))
392 gimple_call_set_alloca_for_var (call
, CALL_ALLOCA_FOR_VAR_P (t
));
394 && (DECL_IS_OPERATOR_NEW_P (fndecl
)
395 || DECL_IS_OPERATOR_DELETE_P (fndecl
)))
396 gimple_call_set_from_new_or_delete (call
, CALL_FROM_NEW_OR_DELETE_P (t
));
398 gimple_call_set_from_thunk (call
, CALL_FROM_THUNK_P (t
));
399 gimple_call_set_va_arg_pack (call
, CALL_EXPR_VA_ARG_PACK (t
));
400 gimple_call_set_nothrow (call
, TREE_NOTHROW (t
));
401 gimple_call_set_by_descriptor (call
, CALL_EXPR_BY_DESCRIPTOR (t
));
402 copy_warning (call
, t
);
406 gimple_call_set_fntype (call
, TREE_TYPE (fnptrtype
));
408 /* Check if it's an indirect CALL and the type has the
409 nocf_check attribute. In that case propagate the information
410 to the gimple CALL insn. */
413 gcc_assert (POINTER_TYPE_P (fnptrtype
));
414 tree fntype
= TREE_TYPE (fnptrtype
);
416 if (lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (fntype
)))
417 gimple_call_set_nocf_check (call
, TRUE
);
425 /* Build a GIMPLE_ASSIGN statement.
427 LHS of the assignment.
428 RHS of the assignment which can be unary or binary. */
431 gimple_build_assign (tree lhs
, tree rhs MEM_STAT_DECL
)
433 enum tree_code subcode
;
436 extract_ops_from_tree (rhs
, &subcode
, &op1
, &op2
, &op3
);
437 return gimple_build_assign (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
441 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
444 static inline gassign
*
445 gimple_build_assign_1 (tree lhs
, enum tree_code subcode
, tree op1
,
446 tree op2
, tree op3 MEM_STAT_DECL
)
451 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
453 num_ops
= get_gimple_rhs_num_ops (subcode
) + 1;
455 p
= as_a
<gassign
*> (
456 gimple_build_with_ops_stat (GIMPLE_ASSIGN
, (unsigned)subcode
, num_ops
458 gimple_assign_set_lhs (p
, lhs
);
459 gimple_assign_set_rhs1 (p
, op1
);
462 gcc_assert (num_ops
> 2);
463 gimple_assign_set_rhs2 (p
, op2
);
468 gcc_assert (num_ops
> 3);
469 gimple_assign_set_rhs3 (p
, op3
);
475 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
479 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
480 tree op2
, tree op3 MEM_STAT_DECL
)
482 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
485 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
489 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
490 tree op2 MEM_STAT_DECL
)
492 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, NULL_TREE
496 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
499 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1 MEM_STAT_DECL
)
501 return gimple_build_assign_1 (lhs
, subcode
, op1
, NULL_TREE
, NULL_TREE
506 /* Build a GIMPLE_COND statement.
508 PRED is the condition used to compare LHS and the RHS.
509 T_LABEL is the label to jump to if the condition is true.
510 F_LABEL is the label to jump to otherwise. */
513 gimple_build_cond (enum tree_code pred_code
, tree lhs
, tree rhs
,
514 tree t_label
, tree f_label
)
518 gcc_assert (TREE_CODE_CLASS (pred_code
) == tcc_comparison
);
519 p
= as_a
<gcond
*> (gimple_build_with_ops (GIMPLE_COND
, pred_code
, 4));
520 gimple_cond_set_lhs (p
, lhs
);
521 gimple_cond_set_rhs (p
, rhs
);
522 gimple_cond_set_true_label (p
, t_label
);
523 gimple_cond_set_false_label (p
, f_label
);
527 /* Build a GIMPLE_COND statement from the conditional expression tree
528 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
531 gimple_build_cond_from_tree (tree cond
, tree t_label
, tree f_label
)
536 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
537 return gimple_build_cond (code
, lhs
, rhs
, t_label
, f_label
);
540 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
541 boolean expression tree COND. */
544 gimple_cond_set_condition_from_tree (gcond
*stmt
, tree cond
)
549 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
550 gimple_cond_set_condition (stmt
, code
, lhs
, rhs
);
553 /* Build a GIMPLE_LABEL statement for LABEL. */
556 gimple_build_label (tree label
)
559 = as_a
<glabel
*> (gimple_build_with_ops (GIMPLE_LABEL
, ERROR_MARK
, 1));
560 gimple_label_set_label (p
, label
);
564 /* Build a GIMPLE_GOTO statement to label DEST. */
567 gimple_build_goto (tree dest
)
570 = as_a
<ggoto
*> (gimple_build_with_ops (GIMPLE_GOTO
, ERROR_MARK
, 1));
571 gimple_goto_set_dest (p
, dest
);
576 /* Build a GIMPLE_NOP statement. */
579 gimple_build_nop (void)
581 return gimple_alloc (GIMPLE_NOP
, 0);
585 /* Build a GIMPLE_BIND statement.
586 VARS are the variables in BODY.
587 BLOCK is the containing block. */
590 gimple_build_bind (tree vars
, gimple_seq body
, tree block
)
592 gbind
*p
= as_a
<gbind
*> (gimple_alloc (GIMPLE_BIND
, 0));
593 gimple_bind_set_vars (p
, vars
);
595 gimple_bind_set_body (p
, body
);
597 gimple_bind_set_block (p
, block
);
601 /* Helper function to set the simple fields of a asm stmt.
603 STRING is a pointer to a string that is the asm blocks assembly code.
604 NINPUT is the number of register inputs.
605 NOUTPUT is the number of register outputs.
606 NCLOBBERS is the number of clobbered registers.
610 gimple_build_asm_1 (const char *string
, unsigned ninputs
, unsigned noutputs
,
611 unsigned nclobbers
, unsigned nlabels
)
614 int size
= strlen (string
);
617 gimple_build_with_ops (GIMPLE_ASM
, ERROR_MARK
,
618 ninputs
+ noutputs
+ nclobbers
+ nlabels
));
624 p
->string
= ggc_alloc_string (string
, size
);
626 if (GATHER_STATISTICS
)
627 gimple_alloc_sizes
[(int) gimple_alloc_kind (GIMPLE_ASM
)] += size
;
632 /* Build a GIMPLE_ASM statement.
634 STRING is the assembly code.
635 NINPUT is the number of register inputs.
636 NOUTPUT is the number of register outputs.
637 NCLOBBERS is the number of clobbered registers.
638 INPUTS is a vector of the input register parameters.
639 OUTPUTS is a vector of the output register parameters.
640 CLOBBERS is a vector of the clobbered register parameters.
641 LABELS is a vector of destination labels. */
644 gimple_build_asm_vec (const char *string
, vec
<tree
, va_gc
> *inputs
,
645 vec
<tree
, va_gc
> *outputs
, vec
<tree
, va_gc
> *clobbers
,
646 vec
<tree
, va_gc
> *labels
)
651 p
= gimple_build_asm_1 (string
,
652 vec_safe_length (inputs
),
653 vec_safe_length (outputs
),
654 vec_safe_length (clobbers
),
655 vec_safe_length (labels
));
657 for (i
= 0; i
< vec_safe_length (inputs
); i
++)
658 gimple_asm_set_input_op (p
, i
, (*inputs
)[i
]);
660 for (i
= 0; i
< vec_safe_length (outputs
); i
++)
661 gimple_asm_set_output_op (p
, i
, (*outputs
)[i
]);
663 for (i
= 0; i
< vec_safe_length (clobbers
); i
++)
664 gimple_asm_set_clobber_op (p
, i
, (*clobbers
)[i
]);
666 for (i
= 0; i
< vec_safe_length (labels
); i
++)
667 gimple_asm_set_label_op (p
, i
, (*labels
)[i
]);
672 /* Build a GIMPLE_CATCH statement.
674 TYPES are the catch types.
675 HANDLER is the exception handler. */
678 gimple_build_catch (tree types
, gimple_seq handler
)
680 gcatch
*p
= as_a
<gcatch
*> (gimple_alloc (GIMPLE_CATCH
, 0));
681 gimple_catch_set_types (p
, types
);
683 gimple_catch_set_handler (p
, handler
);
688 /* Build a GIMPLE_EH_FILTER statement.
690 TYPES are the filter's types.
691 FAILURE is the filter's failure action. */
694 gimple_build_eh_filter (tree types
, gimple_seq failure
)
696 geh_filter
*p
= as_a
<geh_filter
*> (gimple_alloc (GIMPLE_EH_FILTER
, 0));
697 gimple_eh_filter_set_types (p
, types
);
699 gimple_eh_filter_set_failure (p
, failure
);
704 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
707 gimple_build_eh_must_not_throw (tree decl
)
709 geh_mnt
*p
= as_a
<geh_mnt
*> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW
, 0));
711 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
712 gcc_assert (flags_from_decl_or_type (decl
) & ECF_NORETURN
);
713 gimple_eh_must_not_throw_set_fndecl (p
, decl
);
718 /* Build a GIMPLE_EH_ELSE statement. */
721 gimple_build_eh_else (gimple_seq n_body
, gimple_seq e_body
)
723 geh_else
*p
= as_a
<geh_else
*> (gimple_alloc (GIMPLE_EH_ELSE
, 0));
724 gimple_eh_else_set_n_body (p
, n_body
);
725 gimple_eh_else_set_e_body (p
, e_body
);
729 /* Build a GIMPLE_TRY statement.
731 EVAL is the expression to evaluate.
732 CLEANUP is the cleanup expression.
733 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
734 whether this is a try/catch or a try/finally respectively. */
737 gimple_build_try (gimple_seq eval
, gimple_seq cleanup
,
738 enum gimple_try_flags kind
)
742 gcc_assert (kind
== GIMPLE_TRY_CATCH
|| kind
== GIMPLE_TRY_FINALLY
);
743 p
= as_a
<gtry
*> (gimple_alloc (GIMPLE_TRY
, 0));
744 gimple_set_subcode (p
, kind
);
746 gimple_try_set_eval (p
, eval
);
748 gimple_try_set_cleanup (p
, cleanup
);
753 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
755 CLEANUP is the cleanup expression. */
758 gimple_build_wce (gimple_seq cleanup
)
760 gimple
*p
= gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR
, 0);
762 gimple_wce_set_cleanup (p
, cleanup
);
768 /* Build a GIMPLE_RESX statement. */
771 gimple_build_resx (int region
)
774 = as_a
<gresx
*> (gimple_build_with_ops (GIMPLE_RESX
, ERROR_MARK
, 0));
780 /* The helper for constructing a gimple switch statement.
781 INDEX is the switch's index.
782 NLABELS is the number of labels in the switch excluding the default.
783 DEFAULT_LABEL is the default label for the switch statement. */
786 gimple_build_switch_nlabels (unsigned nlabels
, tree index
, tree default_label
)
788 /* nlabels + 1 default label + 1 index. */
789 gcc_checking_assert (default_label
);
790 gswitch
*p
= as_a
<gswitch
*> (gimple_build_with_ops (GIMPLE_SWITCH
,
793 gimple_switch_set_index (p
, index
);
794 gimple_switch_set_default_label (p
, default_label
);
798 /* Build a GIMPLE_SWITCH statement.
800 INDEX is the switch's index.
801 DEFAULT_LABEL is the default label
802 ARGS is a vector of labels excluding the default. */
805 gimple_build_switch (tree index
, tree default_label
, const vec
<tree
> &args
)
807 unsigned i
, nlabels
= args
.length ();
809 gswitch
*p
= gimple_build_switch_nlabels (nlabels
, index
, default_label
);
811 /* Copy the labels from the vector to the switch statement. */
812 for (i
= 0; i
< nlabels
; i
++)
813 gimple_switch_set_label (p
, i
+ 1, args
[i
]);
818 /* Build a GIMPLE_EH_DISPATCH statement. */
821 gimple_build_eh_dispatch (int region
)
824 = as_a
<geh_dispatch
*> (
825 gimple_build_with_ops (GIMPLE_EH_DISPATCH
, ERROR_MARK
, 0));
830 /* Build a new GIMPLE_DEBUG_BIND statement.
832 VAR is bound to VALUE; block and location are taken from STMT. */
835 gimple_build_debug_bind (tree var
, tree value
, gimple
*stmt MEM_STAT_DECL
)
838 = as_a
<gdebug
*> (gimple_build_with_ops_stat (GIMPLE_DEBUG
,
839 (unsigned)GIMPLE_DEBUG_BIND
, 2
841 gimple_debug_bind_set_var (p
, var
);
842 gimple_debug_bind_set_value (p
, value
);
844 gimple_set_location (p
, gimple_location (stmt
));
850 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
852 VAR is bound to VALUE; block and location are taken from STMT. */
855 gimple_build_debug_source_bind (tree var
, tree value
,
856 gimple
*stmt MEM_STAT_DECL
)
860 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
861 (unsigned)GIMPLE_DEBUG_SOURCE_BIND
, 2
864 gimple_debug_source_bind_set_var (p
, var
);
865 gimple_debug_source_bind_set_value (p
, value
);
867 gimple_set_location (p
, gimple_location (stmt
));
873 /* Build a new GIMPLE_DEBUG_BEGIN_STMT statement in BLOCK at
877 gimple_build_debug_begin_stmt (tree block
, location_t location
882 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
883 (unsigned)GIMPLE_DEBUG_BEGIN_STMT
, 0
886 gimple_set_location (p
, location
);
887 gimple_set_block (p
, block
);
888 cfun
->debug_marker_count
++;
894 /* Build a new GIMPLE_DEBUG_INLINE_ENTRY statement in BLOCK at
895 LOCATION. The BLOCK links to the inlined function. */
898 gimple_build_debug_inline_entry (tree block
, location_t location
903 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
904 (unsigned)GIMPLE_DEBUG_INLINE_ENTRY
, 0
907 gimple_set_location (p
, location
);
908 gimple_set_block (p
, block
);
909 cfun
->debug_marker_count
++;
915 /* Build a GIMPLE_OMP_CRITICAL statement.
917 BODY is the sequence of statements for which only one thread can execute.
918 NAME is optional identifier for this critical block.
919 CLAUSES are clauses for this critical block. */
922 gimple_build_omp_critical (gimple_seq body
, tree name
, tree clauses
)
925 = as_a
<gomp_critical
*> (gimple_alloc (GIMPLE_OMP_CRITICAL
, 0));
926 gimple_omp_critical_set_name (p
, name
);
927 gimple_omp_critical_set_clauses (p
, clauses
);
929 gimple_omp_set_body (p
, body
);
934 /* Build a GIMPLE_OMP_FOR statement.
936 BODY is sequence of statements inside the for loop.
937 KIND is the `for' variant.
938 CLAUSES are any of the construct's clauses.
939 COLLAPSE is the collapse count.
940 PRE_BODY is the sequence of statements that are loop invariant. */
943 gimple_build_omp_for (gimple_seq body
, int kind
, tree clauses
, size_t collapse
,
946 gomp_for
*p
= as_a
<gomp_for
*> (gimple_alloc (GIMPLE_OMP_FOR
, 0));
948 gimple_omp_set_body (p
, body
);
949 gimple_omp_for_set_clauses (p
, clauses
);
950 gimple_omp_for_set_kind (p
, kind
);
951 p
->collapse
= collapse
;
952 p
->iter
= ggc_cleared_vec_alloc
<gimple_omp_for_iter
> (collapse
);
955 gimple_omp_for_set_pre_body (p
, pre_body
);
961 /* Build a GIMPLE_OMP_PARALLEL statement.
963 BODY is sequence of statements which are executed in parallel.
964 CLAUSES are the OMP parallel construct's clauses.
965 CHILD_FN is the function created for the parallel threads to execute.
966 DATA_ARG are the shared data argument(s). */
969 gimple_build_omp_parallel (gimple_seq body
, tree clauses
, tree child_fn
,
973 = as_a
<gomp_parallel
*> (gimple_alloc (GIMPLE_OMP_PARALLEL
, 0));
975 gimple_omp_set_body (p
, body
);
976 gimple_omp_parallel_set_clauses (p
, clauses
);
977 gimple_omp_parallel_set_child_fn (p
, child_fn
);
978 gimple_omp_parallel_set_data_arg (p
, data_arg
);
984 /* Build a GIMPLE_OMP_TASK statement.
986 BODY is sequence of statements which are executed by the explicit task.
987 CLAUSES are the OMP task construct's clauses.
988 CHILD_FN is the function created for the parallel threads to execute.
989 DATA_ARG are the shared data argument(s).
990 COPY_FN is the optional function for firstprivate initialization.
991 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
994 gimple_build_omp_task (gimple_seq body
, tree clauses
, tree child_fn
,
995 tree data_arg
, tree copy_fn
, tree arg_size
,
998 gomp_task
*p
= as_a
<gomp_task
*> (gimple_alloc (GIMPLE_OMP_TASK
, 0));
1000 gimple_omp_set_body (p
, body
);
1001 gimple_omp_task_set_clauses (p
, clauses
);
1002 gimple_omp_task_set_child_fn (p
, child_fn
);
1003 gimple_omp_task_set_data_arg (p
, data_arg
);
1004 gimple_omp_task_set_copy_fn (p
, copy_fn
);
1005 gimple_omp_task_set_arg_size (p
, arg_size
);
1006 gimple_omp_task_set_arg_align (p
, arg_align
);
1012 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
1014 BODY is the sequence of statements in the section. */
1017 gimple_build_omp_section (gimple_seq body
)
1019 gimple
*p
= gimple_alloc (GIMPLE_OMP_SECTION
, 0);
1021 gimple_omp_set_body (p
, body
);
1027 /* Build a GIMPLE_OMP_MASTER statement.
1029 BODY is the sequence of statements to be executed by just the master. */
1032 gimple_build_omp_master (gimple_seq body
)
1034 gimple
*p
= gimple_alloc (GIMPLE_OMP_MASTER
, 0);
1036 gimple_omp_set_body (p
, body
);
1041 /* Build a GIMPLE_OMP_MASKED statement.
1043 BODY is the sequence of statements to be executed by the selected thread(s). */
1046 gimple_build_omp_masked (gimple_seq body
, tree clauses
)
1048 gimple
*p
= gimple_alloc (GIMPLE_OMP_MASKED
, 0);
1049 gimple_omp_masked_set_clauses (p
, clauses
);
1051 gimple_omp_set_body (p
, body
);
1056 /* Build a GIMPLE_OMP_TASKGROUP statement.
1058 BODY is the sequence of statements to be executed by the taskgroup
1060 CLAUSES are any of the construct's clauses. */
1063 gimple_build_omp_taskgroup (gimple_seq body
, tree clauses
)
1065 gimple
*p
= gimple_alloc (GIMPLE_OMP_TASKGROUP
, 0);
1066 gimple_omp_taskgroup_set_clauses (p
, clauses
);
1068 gimple_omp_set_body (p
, body
);
1074 /* Build a GIMPLE_OMP_CONTINUE statement.
1076 CONTROL_DEF is the definition of the control variable.
1077 CONTROL_USE is the use of the control variable. */
1080 gimple_build_omp_continue (tree control_def
, tree control_use
)
1083 = as_a
<gomp_continue
*> (gimple_alloc (GIMPLE_OMP_CONTINUE
, 0));
1084 gimple_omp_continue_set_control_def (p
, control_def
);
1085 gimple_omp_continue_set_control_use (p
, control_use
);
1089 /* Build a GIMPLE_OMP_ORDERED statement.
1091 BODY is the sequence of statements inside a loop that will executed in
1093 CLAUSES are clauses for this statement. */
1096 gimple_build_omp_ordered (gimple_seq body
, tree clauses
)
1099 = as_a
<gomp_ordered
*> (gimple_alloc (GIMPLE_OMP_ORDERED
, 0));
1100 gimple_omp_ordered_set_clauses (p
, clauses
);
1102 gimple_omp_set_body (p
, body
);
1108 /* Build a GIMPLE_OMP_RETURN statement.
1109 WAIT_P is true if this is a non-waiting return. */
1112 gimple_build_omp_return (bool wait_p
)
1114 gimple
*p
= gimple_alloc (GIMPLE_OMP_RETURN
, 0);
1116 gimple_omp_return_set_nowait (p
);
1122 /* Build a GIMPLE_OMP_SCAN statement.
1124 BODY is the sequence of statements to be executed by the scan
1126 CLAUSES are any of the construct's clauses. */
1129 gimple_build_omp_scan (gimple_seq body
, tree clauses
)
1132 = as_a
<gomp_scan
*> (gimple_alloc (GIMPLE_OMP_SCAN
, 0));
1133 gimple_omp_scan_set_clauses (p
, clauses
);
1135 gimple_omp_set_body (p
, body
);
1141 /* Build a GIMPLE_OMP_SECTIONS statement.
1143 BODY is a sequence of section statements.
1144 CLAUSES are any of the OMP sections contsruct's clauses: private,
1145 firstprivate, lastprivate, reduction, and nowait. */
1148 gimple_build_omp_sections (gimple_seq body
, tree clauses
)
1151 = as_a
<gomp_sections
*> (gimple_alloc (GIMPLE_OMP_SECTIONS
, 0));
1153 gimple_omp_set_body (p
, body
);
1154 gimple_omp_sections_set_clauses (p
, clauses
);
1160 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1163 gimple_build_omp_sections_switch (void)
1165 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH
, 0);
1169 /* Build a GIMPLE_OMP_SINGLE statement.
1171 BODY is the sequence of statements that will be executed once.
1172 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1173 copyprivate, nowait. */
1176 gimple_build_omp_single (gimple_seq body
, tree clauses
)
1179 = as_a
<gomp_single
*> (gimple_alloc (GIMPLE_OMP_SINGLE
, 0));
1181 gimple_omp_set_body (p
, body
);
1182 gimple_omp_single_set_clauses (p
, clauses
);
1188 /* Build a GIMPLE_OMP_SCOPE statement.
1190 BODY is the sequence of statements that will be executed once.
1191 CLAUSES are any of the OMP scope construct's clauses: private, reduction,
1195 gimple_build_omp_scope (gimple_seq body
, tree clauses
)
1197 gimple
*p
= gimple_alloc (GIMPLE_OMP_SCOPE
, 0);
1198 gimple_omp_scope_set_clauses (p
, clauses
);
1200 gimple_omp_set_body (p
, body
);
1206 /* Build a GIMPLE_OMP_TARGET statement.
1208 BODY is the sequence of statements that will be executed.
1209 KIND is the kind of the region.
1210 CLAUSES are any of the construct's clauses. */
1213 gimple_build_omp_target (gimple_seq body
, int kind
, tree clauses
)
1216 = as_a
<gomp_target
*> (gimple_alloc (GIMPLE_OMP_TARGET
, 0));
1218 gimple_omp_set_body (p
, body
);
1219 gimple_omp_target_set_clauses (p
, clauses
);
1220 gimple_omp_target_set_kind (p
, kind
);
1226 /* Build a GIMPLE_OMP_TEAMS statement.
1228 BODY is the sequence of statements that will be executed.
1229 CLAUSES are any of the OMP teams construct's clauses. */
1232 gimple_build_omp_teams (gimple_seq body
, tree clauses
)
1234 gomp_teams
*p
= as_a
<gomp_teams
*> (gimple_alloc (GIMPLE_OMP_TEAMS
, 0));
1236 gimple_omp_set_body (p
, body
);
1237 gimple_omp_teams_set_clauses (p
, clauses
);
1243 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1246 gimple_build_omp_atomic_load (tree lhs
, tree rhs
, enum omp_memory_order mo
)
1249 = as_a
<gomp_atomic_load
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD
, 0));
1250 gimple_omp_atomic_load_set_lhs (p
, lhs
);
1251 gimple_omp_atomic_load_set_rhs (p
, rhs
);
1252 gimple_omp_atomic_set_memory_order (p
, mo
);
1256 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1258 VAL is the value we are storing. */
1261 gimple_build_omp_atomic_store (tree val
, enum omp_memory_order mo
)
1263 gomp_atomic_store
*p
1264 = as_a
<gomp_atomic_store
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE
, 0));
1265 gimple_omp_atomic_store_set_val (p
, val
);
1266 gimple_omp_atomic_set_memory_order (p
, mo
);
1270 /* Build a GIMPLE_TRANSACTION statement. */
1273 gimple_build_transaction (gimple_seq body
)
1276 = as_a
<gtransaction
*> (gimple_alloc (GIMPLE_TRANSACTION
, 0));
1277 gimple_transaction_set_body (p
, body
);
1278 gimple_transaction_set_label_norm (p
, 0);
1279 gimple_transaction_set_label_uninst (p
, 0);
1280 gimple_transaction_set_label_over (p
, 0);
1284 #if defined ENABLE_GIMPLE_CHECKING
1285 /* Complain of a gimple type mismatch and die. */
1288 gimple_check_failed (const gimple
*gs
, const char *file
, int line
,
1289 const char *function
, enum gimple_code code
,
1290 enum tree_code subcode
)
1292 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1293 gimple_code_name
[code
],
1294 get_tree_code_name (subcode
),
1295 gimple_code_name
[gimple_code (gs
)],
1297 ? get_tree_code_name ((enum tree_code
) gs
->subcode
)
1299 function
, trim_filename (file
), line
);
1301 #endif /* ENABLE_GIMPLE_CHECKING */
1304 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1305 *SEQ_P is NULL, a new sequence is allocated. */
1308 gimple_seq_add_stmt (gimple_seq
*seq_p
, gimple
*gs
)
1310 gimple_stmt_iterator si
;
1314 si
= gsi_last (*seq_p
);
1315 gsi_insert_after (&si
, gs
, GSI_NEW_STMT
);
1318 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1319 *SEQ_P is NULL, a new sequence is allocated. This function is
1320 similar to gimple_seq_add_stmt, but does not scan the operands.
1321 During gimplification, we need to manipulate statement sequences
1322 before the def/use vectors have been constructed. */
1325 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple
*gs
)
1327 gimple_stmt_iterator si
;
1332 si
= gsi_last (*seq_p
);
1333 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
1336 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1337 NULL, a new sequence is allocated. */
1340 gimple_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
1342 gimple_stmt_iterator si
;
1346 si
= gsi_last (*dst_p
);
1347 gsi_insert_seq_after (&si
, src
, GSI_NEW_STMT
);
1350 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1351 NULL, a new sequence is allocated. This function is
1352 similar to gimple_seq_add_seq, but does not scan the operands. */
1355 gimple_seq_add_seq_without_update (gimple_seq
*dst_p
, gimple_seq src
)
1357 gimple_stmt_iterator si
;
1361 si
= gsi_last (*dst_p
);
1362 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
1365 /* Determine whether to assign a location to the statement GS. */
1368 should_carry_location_p (gimple
*gs
)
1370 /* Don't emit a line note for a label. We particularly don't want to
1371 emit one for the break label, since it doesn't actually correspond
1372 to the beginning of the loop/switch. */
1373 if (gimple_code (gs
) == GIMPLE_LABEL
)
1379 /* Set the location for gimple statement GS to LOCATION. */
1382 annotate_one_with_location (gimple
*gs
, location_t location
)
1384 if (!gimple_has_location (gs
)
1385 && !gimple_do_not_emit_location_p (gs
)
1386 && should_carry_location_p (gs
))
1387 gimple_set_location (gs
, location
);
1390 /* Set LOCATION for all the statements after iterator GSI in sequence
1391 SEQ. If GSI is pointing to the end of the sequence, start with the
1392 first statement in SEQ. */
1395 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
1396 location_t location
)
1398 if (gsi_end_p (gsi
))
1399 gsi
= gsi_start (seq
);
1403 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
1404 annotate_one_with_location (gsi_stmt (gsi
), location
);
1407 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1410 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
1412 gimple_stmt_iterator i
;
1414 if (gimple_seq_empty_p (stmt_p
))
1417 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
1419 gimple
*gs
= gsi_stmt (i
);
1420 annotate_one_with_location (gs
, location
);
1424 /* Helper function of empty_body_p. Return true if STMT is an empty
1428 empty_stmt_p (gimple
*stmt
)
1430 if (gimple_code (stmt
) == GIMPLE_NOP
)
1432 if (gbind
*bind_stmt
= dyn_cast
<gbind
*> (stmt
))
1433 return empty_body_p (gimple_bind_body (bind_stmt
));
1438 /* Return true if BODY contains nothing but empty statements. */
1441 empty_body_p (gimple_seq body
)
1443 gimple_stmt_iterator i
;
1445 if (gimple_seq_empty_p (body
))
1447 for (i
= gsi_start (body
); !gsi_end_p (i
); gsi_next (&i
))
1448 if (!empty_stmt_p (gsi_stmt (i
))
1449 && !is_gimple_debug (gsi_stmt (i
)))
1456 /* Perform a deep copy of sequence SRC and return the result. */
1459 gimple_seq_copy (gimple_seq src
)
1461 gimple_stmt_iterator gsi
;
1462 gimple_seq new_seq
= NULL
;
1465 for (gsi
= gsi_start (src
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1467 stmt
= gimple_copy (gsi_stmt (gsi
));
1468 gimple_seq_add_stmt (&new_seq
, stmt
);
1476 /* Return true if calls C1 and C2 are known to go to the same function. */
1479 gimple_call_same_target_p (const gimple
*c1
, const gimple
*c2
)
1481 if (gimple_call_internal_p (c1
))
1482 return (gimple_call_internal_p (c2
)
1483 && gimple_call_internal_fn (c1
) == gimple_call_internal_fn (c2
)
1484 && (!gimple_call_internal_unique_p (as_a
<const gcall
*> (c1
))
1487 return (gimple_call_fn (c1
) == gimple_call_fn (c2
)
1488 || (gimple_call_fndecl (c1
)
1489 && gimple_call_fndecl (c1
) == gimple_call_fndecl (c2
)));
1492 /* Detect flags from a GIMPLE_CALL. This is just like
1493 call_expr_flags, but for gimple tuples. */
1496 gimple_call_flags (const gimple
*stmt
)
1500 if (gimple_call_internal_p (stmt
))
1501 flags
= internal_fn_flags (gimple_call_internal_fn (stmt
));
1504 tree decl
= gimple_call_fndecl (stmt
);
1506 flags
= flags_from_decl_or_type (decl
);
1507 flags
|= flags_from_decl_or_type (gimple_call_fntype (stmt
));
1510 if (stmt
->subcode
& GF_CALL_NOTHROW
)
1511 flags
|= ECF_NOTHROW
;
1513 if (stmt
->subcode
& GF_CALL_BY_DESCRIPTOR
)
1514 flags
|= ECF_BY_DESCRIPTOR
;
1519 /* Return the "fn spec" string for call STMT. */
1522 gimple_call_fnspec (const gcall
*stmt
)
1526 if (gimple_call_internal_p (stmt
))
1528 const_tree spec
= internal_fn_fnspec (gimple_call_internal_fn (stmt
));
1535 type
= gimple_call_fntype (stmt
);
1538 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
1540 return TREE_VALUE (TREE_VALUE (attr
));
1542 if (gimple_call_builtin_p (stmt
, BUILT_IN_NORMAL
))
1543 return builtin_fnspec (gimple_call_fndecl (stmt
));
1544 tree fndecl
= gimple_call_fndecl (stmt
);
1545 /* If the call is to a replaceable operator delete and results
1546 from a delete expression as opposed to a direct call to
1547 such operator, then we can treat it as free. */
1549 && DECL_IS_OPERATOR_DELETE_P (fndecl
)
1550 && DECL_IS_REPLACEABLE_OPERATOR (fndecl
)
1551 && gimple_call_from_new_or_delete (stmt
))
1553 /* Similarly operator new can be treated as malloc. */
1555 && DECL_IS_REPLACEABLE_OPERATOR_NEW_P (fndecl
)
1556 && gimple_call_from_new_or_delete (stmt
))
1561 /* Detects argument flags for argument number ARG on call STMT. */
1564 gimple_call_arg_flags (const gcall
*stmt
, unsigned arg
)
1566 attr_fnspec fnspec
= gimple_call_fnspec (stmt
);
1569 if (fnspec
.known_p ())
1571 if (!fnspec
.arg_specified_p (arg
))
1573 else if (!fnspec
.arg_used_p (arg
))
1577 if (fnspec
.arg_direct_p (arg
))
1578 flags
|= EAF_DIRECT
;
1579 if (fnspec
.arg_noescape_p (arg
))
1580 flags
|= EAF_NOESCAPE
| EAF_NODIRECTESCAPE
;
1581 if (fnspec
.arg_readonly_p (arg
))
1582 flags
|= EAF_NOCLOBBER
;
1585 tree callee
= gimple_call_fndecl (stmt
);
1588 cgraph_node
*node
= cgraph_node::get (callee
);
1589 modref_summary
*summary
= node
? get_modref_function_summary (node
)
1592 if (summary
&& summary
->arg_flags
.length () > arg
)
1594 int modref_flags
= summary
->arg_flags
[arg
];
1596 /* We have possibly optimized out load. Be conservative here. */
1597 if (!node
->binds_to_current_def_p ())
1599 if ((modref_flags
& EAF_UNUSED
) && !(flags
& EAF_UNUSED
))
1601 modref_flags
&= ~EAF_UNUSED
;
1602 modref_flags
|= EAF_NOESCAPE
;
1604 if ((modref_flags
& EAF_NOREAD
) && !(flags
& EAF_NOREAD
))
1605 modref_flags
&= ~EAF_NOREAD
;
1606 if ((modref_flags
& EAF_DIRECT
) && !(flags
& EAF_DIRECT
))
1607 modref_flags
&= ~EAF_DIRECT
;
1609 if (dbg_cnt (ipa_mod_ref_pta
))
1610 flags
|= modref_flags
;
1616 /* Detects argument flags for return slot on call STMT. */
1619 gimple_call_retslot_flags (const gcall
*stmt
)
1621 int flags
= EAF_DIRECT
| EAF_NOREAD
;
1623 tree callee
= gimple_call_fndecl (stmt
);
1626 cgraph_node
*node
= cgraph_node::get (callee
);
1627 modref_summary
*summary
= node
? get_modref_function_summary (node
)
1632 int modref_flags
= summary
->retslot_flags
;
1634 /* We have possibly optimized out load. Be conservative here. */
1635 if (!node
->binds_to_current_def_p ())
1637 if ((modref_flags
& EAF_UNUSED
) && !(flags
& EAF_UNUSED
))
1639 modref_flags
&= ~EAF_UNUSED
;
1640 modref_flags
|= EAF_NOESCAPE
;
1643 if (dbg_cnt (ipa_mod_ref_pta
))
1644 flags
|= modref_flags
;
1650 /* Detects argument flags for static chain on call STMT. */
1653 gimple_call_static_chain_flags (const gcall
*stmt
)
1657 tree callee
= gimple_call_fndecl (stmt
);
1660 cgraph_node
*node
= cgraph_node::get (callee
);
1661 modref_summary
*summary
= node
? get_modref_function_summary (node
)
1666 int modref_flags
= summary
->static_chain_flags
;
1668 /* We have possibly optimized out load. Be conservative here. */
1669 if (!node
->binds_to_current_def_p ())
1671 if ((modref_flags
& EAF_UNUSED
) && !(flags
& EAF_UNUSED
))
1673 modref_flags
&= ~EAF_UNUSED
;
1674 modref_flags
|= EAF_NOESCAPE
;
1676 if ((modref_flags
& EAF_NOREAD
) && !(flags
& EAF_NOREAD
))
1677 modref_flags
&= ~EAF_NOREAD
;
1678 if ((modref_flags
& EAF_DIRECT
) && !(flags
& EAF_DIRECT
))
1679 modref_flags
&= ~EAF_DIRECT
;
1681 if (dbg_cnt (ipa_mod_ref_pta
))
1682 flags
|= modref_flags
;
1688 /* Detects return flags for the call STMT. */
1691 gimple_call_return_flags (const gcall
*stmt
)
1693 if (gimple_call_flags (stmt
) & ECF_MALLOC
)
1696 attr_fnspec fnspec
= gimple_call_fnspec (stmt
);
1698 unsigned int arg_no
;
1699 if (fnspec
.returns_arg (&arg_no
))
1700 return ERF_RETURNS_ARG
| arg_no
;
1702 if (fnspec
.returns_noalias_p ())
1708 /* Return true if call STMT is known to return a non-zero result. */
1711 gimple_call_nonnull_result_p (gcall
*call
)
1713 tree fndecl
= gimple_call_fndecl (call
);
1716 if (flag_delete_null_pointer_checks
&& !flag_check_new
1717 && DECL_IS_OPERATOR_NEW_P (fndecl
)
1718 && !TREE_NOTHROW (fndecl
))
1721 /* References are always non-NULL. */
1722 if (flag_delete_null_pointer_checks
1723 && TREE_CODE (TREE_TYPE (fndecl
)) == REFERENCE_TYPE
)
1726 if (flag_delete_null_pointer_checks
1727 && lookup_attribute ("returns_nonnull",
1728 TYPE_ATTRIBUTES (gimple_call_fntype (call
))))
1730 return gimple_alloca_call_p (call
);
1734 /* If CALL returns a non-null result in an argument, return that arg. */
1737 gimple_call_nonnull_arg (gcall
*call
)
1739 tree fndecl
= gimple_call_fndecl (call
);
1743 unsigned rf
= gimple_call_return_flags (call
);
1744 if (rf
& ERF_RETURNS_ARG
)
1746 unsigned argnum
= rf
& ERF_RETURN_ARG_MASK
;
1747 if (argnum
< gimple_call_num_args (call
))
1749 tree arg
= gimple_call_arg (call
, argnum
);
1751 && infer_nonnull_range_by_attribute (call
, arg
))
1759 /* Return true if GS is a copy assignment. */
1762 gimple_assign_copy_p (gimple
*gs
)
1764 return (gimple_assign_single_p (gs
)
1765 && is_gimple_val (gimple_op (gs
, 1)));
1769 /* Return true if GS is a SSA_NAME copy assignment. */
1772 gimple_assign_ssa_name_copy_p (gimple
*gs
)
1774 return (gimple_assign_single_p (gs
)
1775 && TREE_CODE (gimple_assign_lhs (gs
)) == SSA_NAME
1776 && TREE_CODE (gimple_assign_rhs1 (gs
)) == SSA_NAME
);
1780 /* Return true if GS is an assignment with a unary RHS, but the
1781 operator has no effect on the assigned value. The logic is adapted
1782 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1783 instances in which STRIP_NOPS was previously applied to the RHS of
1786 NOTE: In the use cases that led to the creation of this function
1787 and of gimple_assign_single_p, it is typical to test for either
1788 condition and to proceed in the same manner. In each case, the
1789 assigned value is represented by the single RHS operand of the
1790 assignment. I suspect there may be cases where gimple_assign_copy_p,
1791 gimple_assign_single_p, or equivalent logic is used where a similar
1792 treatment of unary NOPs is appropriate. */
1795 gimple_assign_unary_nop_p (gimple
*gs
)
1797 return (is_gimple_assign (gs
)
1798 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs
))
1799 || gimple_assign_rhs_code (gs
) == NON_LVALUE_EXPR
)
1800 && gimple_assign_rhs1 (gs
) != error_mark_node
1801 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs
)))
1802 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs
)))));
1805 /* Set BB to be the basic block holding G. */
1808 gimple_set_bb (gimple
*stmt
, basic_block bb
)
1812 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1815 /* If the statement is a label, add the label to block-to-labels map
1816 so that we can speed up edge creation for GIMPLE_GOTOs. */
1822 t
= gimple_label_label (as_a
<glabel
*> (stmt
));
1823 uid
= LABEL_DECL_UID (t
);
1827 vec_safe_length (label_to_block_map_for_fn (cfun
));
1828 LABEL_DECL_UID (t
) = uid
= cfun
->cfg
->last_label_uid
++;
1829 if (old_len
<= (unsigned) uid
)
1830 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun
), uid
+ 1);
1833 (*label_to_block_map_for_fn (cfun
))[uid
] = bb
;
1838 /* Modify the RHS of the assignment pointed-to by GSI using the
1839 operands in the expression tree EXPR.
1841 NOTE: The statement pointed-to by GSI may be reallocated if it
1842 did not have enough operand slots.
1844 This function is useful to convert an existing tree expression into
1845 the flat representation used for the RHS of a GIMPLE assignment.
1846 It will reallocate memory as needed to expand or shrink the number
1847 of operand slots needed to represent EXPR.
1849 NOTE: If you find yourself building a tree and then calling this
1850 function, you are most certainly doing it the slow way. It is much
1851 better to build a new assignment or to use the function
1852 gimple_assign_set_rhs_with_ops, which does not require an
1853 expression tree to be built. */
1856 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*gsi
, tree expr
)
1858 enum tree_code subcode
;
1861 extract_ops_from_tree (expr
, &subcode
, &op1
, &op2
, &op3
);
1862 gimple_assign_set_rhs_with_ops (gsi
, subcode
, op1
, op2
, op3
);
1866 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1867 operands OP1, OP2 and OP3.
1869 NOTE: The statement pointed-to by GSI may be reallocated if it
1870 did not have enough operand slots. */
1873 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*gsi
, enum tree_code code
,
1874 tree op1
, tree op2
, tree op3
)
1876 unsigned new_rhs_ops
= get_gimple_rhs_num_ops (code
);
1877 gimple
*stmt
= gsi_stmt (*gsi
);
1878 gimple
*old_stmt
= stmt
;
1880 /* If the new CODE needs more operands, allocate a new statement. */
1881 if (gimple_num_ops (stmt
) < new_rhs_ops
+ 1)
1883 tree lhs
= gimple_assign_lhs (old_stmt
);
1884 stmt
= gimple_alloc (gimple_code (old_stmt
), new_rhs_ops
+ 1);
1885 memcpy (stmt
, old_stmt
, gimple_size (gimple_code (old_stmt
)));
1886 gimple_init_singleton (stmt
);
1888 /* The LHS needs to be reset as this also changes the SSA name
1890 gimple_assign_set_lhs (stmt
, lhs
);
1893 gimple_set_num_ops (stmt
, new_rhs_ops
+ 1);
1894 gimple_set_subcode (stmt
, code
);
1895 gimple_assign_set_rhs1 (stmt
, op1
);
1896 if (new_rhs_ops
> 1)
1897 gimple_assign_set_rhs2 (stmt
, op2
);
1898 if (new_rhs_ops
> 2)
1899 gimple_assign_set_rhs3 (stmt
, op3
);
1900 if (stmt
!= old_stmt
)
1901 gsi_replace (gsi
, stmt
, false);
1905 /* Return the LHS of a statement that performs an assignment,
1906 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1907 for a call to a function that returns no value, or for a
1908 statement other than an assignment or a call. */
1911 gimple_get_lhs (const gimple
*stmt
)
1913 enum gimple_code code
= gimple_code (stmt
);
1915 if (code
== GIMPLE_ASSIGN
)
1916 return gimple_assign_lhs (stmt
);
1917 else if (code
== GIMPLE_CALL
)
1918 return gimple_call_lhs (stmt
);
1919 else if (code
== GIMPLE_PHI
)
1920 return gimple_phi_result (stmt
);
1926 /* Set the LHS of a statement that performs an assignment,
1927 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1930 gimple_set_lhs (gimple
*stmt
, tree lhs
)
1932 enum gimple_code code
= gimple_code (stmt
);
1934 if (code
== GIMPLE_ASSIGN
)
1935 gimple_assign_set_lhs (stmt
, lhs
);
1936 else if (code
== GIMPLE_CALL
)
1937 gimple_call_set_lhs (stmt
, lhs
);
1943 /* Return a deep copy of statement STMT. All the operands from STMT
1944 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1945 and VUSE operand arrays are set to empty in the new copy. The new
1946 copy isn't part of any sequence. */
1949 gimple_copy (gimple
*stmt
)
1951 enum gimple_code code
= gimple_code (stmt
);
1952 unsigned num_ops
= gimple_num_ops (stmt
);
1953 gimple
*copy
= gimple_alloc (code
, num_ops
);
1956 /* Shallow copy all the fields from STMT. */
1957 memcpy (copy
, stmt
, gimple_size (code
));
1958 gimple_init_singleton (copy
);
1960 /* If STMT has sub-statements, deep-copy them as well. */
1961 if (gimple_has_substatements (stmt
))
1966 switch (gimple_code (stmt
))
1970 gbind
*bind_stmt
= as_a
<gbind
*> (stmt
);
1971 gbind
*bind_copy
= as_a
<gbind
*> (copy
);
1972 new_seq
= gimple_seq_copy (gimple_bind_body (bind_stmt
));
1973 gimple_bind_set_body (bind_copy
, new_seq
);
1974 gimple_bind_set_vars (bind_copy
,
1975 unshare_expr (gimple_bind_vars (bind_stmt
)));
1976 gimple_bind_set_block (bind_copy
, gimple_bind_block (bind_stmt
));
1982 gcatch
*catch_stmt
= as_a
<gcatch
*> (stmt
);
1983 gcatch
*catch_copy
= as_a
<gcatch
*> (copy
);
1984 new_seq
= gimple_seq_copy (gimple_catch_handler (catch_stmt
));
1985 gimple_catch_set_handler (catch_copy
, new_seq
);
1986 t
= unshare_expr (gimple_catch_types (catch_stmt
));
1987 gimple_catch_set_types (catch_copy
, t
);
1991 case GIMPLE_EH_FILTER
:
1993 geh_filter
*eh_filter_stmt
= as_a
<geh_filter
*> (stmt
);
1994 geh_filter
*eh_filter_copy
= as_a
<geh_filter
*> (copy
);
1996 = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt
));
1997 gimple_eh_filter_set_failure (eh_filter_copy
, new_seq
);
1998 t
= unshare_expr (gimple_eh_filter_types (eh_filter_stmt
));
1999 gimple_eh_filter_set_types (eh_filter_copy
, t
);
2003 case GIMPLE_EH_ELSE
:
2005 geh_else
*eh_else_stmt
= as_a
<geh_else
*> (stmt
);
2006 geh_else
*eh_else_copy
= as_a
<geh_else
*> (copy
);
2007 new_seq
= gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt
));
2008 gimple_eh_else_set_n_body (eh_else_copy
, new_seq
);
2009 new_seq
= gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt
));
2010 gimple_eh_else_set_e_body (eh_else_copy
, new_seq
);
2016 gtry
*try_stmt
= as_a
<gtry
*> (stmt
);
2017 gtry
*try_copy
= as_a
<gtry
*> (copy
);
2018 new_seq
= gimple_seq_copy (gimple_try_eval (try_stmt
));
2019 gimple_try_set_eval (try_copy
, new_seq
);
2020 new_seq
= gimple_seq_copy (gimple_try_cleanup (try_stmt
));
2021 gimple_try_set_cleanup (try_copy
, new_seq
);
2025 case GIMPLE_OMP_FOR
:
2026 new_seq
= gimple_seq_copy (gimple_omp_for_pre_body (stmt
));
2027 gimple_omp_for_set_pre_body (copy
, new_seq
);
2028 t
= unshare_expr (gimple_omp_for_clauses (stmt
));
2029 gimple_omp_for_set_clauses (copy
, t
);
2031 gomp_for
*omp_for_copy
= as_a
<gomp_for
*> (copy
);
2032 omp_for_copy
->iter
= ggc_vec_alloc
<gimple_omp_for_iter
>
2033 ( gimple_omp_for_collapse (stmt
));
2035 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
2037 gimple_omp_for_set_cond (copy
, i
,
2038 gimple_omp_for_cond (stmt
, i
));
2039 gimple_omp_for_set_index (copy
, i
,
2040 gimple_omp_for_index (stmt
, i
));
2041 t
= unshare_expr (gimple_omp_for_initial (stmt
, i
));
2042 gimple_omp_for_set_initial (copy
, i
, t
);
2043 t
= unshare_expr (gimple_omp_for_final (stmt
, i
));
2044 gimple_omp_for_set_final (copy
, i
, t
);
2045 t
= unshare_expr (gimple_omp_for_incr (stmt
, i
));
2046 gimple_omp_for_set_incr (copy
, i
, t
);
2050 case GIMPLE_OMP_PARALLEL
:
2052 gomp_parallel
*omp_par_stmt
= as_a
<gomp_parallel
*> (stmt
);
2053 gomp_parallel
*omp_par_copy
= as_a
<gomp_parallel
*> (copy
);
2054 t
= unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt
));
2055 gimple_omp_parallel_set_clauses (omp_par_copy
, t
);
2056 t
= unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt
));
2057 gimple_omp_parallel_set_child_fn (omp_par_copy
, t
);
2058 t
= unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt
));
2059 gimple_omp_parallel_set_data_arg (omp_par_copy
, t
);
2063 case GIMPLE_OMP_TASK
:
2064 t
= unshare_expr (gimple_omp_task_clauses (stmt
));
2065 gimple_omp_task_set_clauses (copy
, t
);
2066 t
= unshare_expr (gimple_omp_task_child_fn (stmt
));
2067 gimple_omp_task_set_child_fn (copy
, t
);
2068 t
= unshare_expr (gimple_omp_task_data_arg (stmt
));
2069 gimple_omp_task_set_data_arg (copy
, t
);
2070 t
= unshare_expr (gimple_omp_task_copy_fn (stmt
));
2071 gimple_omp_task_set_copy_fn (copy
, t
);
2072 t
= unshare_expr (gimple_omp_task_arg_size (stmt
));
2073 gimple_omp_task_set_arg_size (copy
, t
);
2074 t
= unshare_expr (gimple_omp_task_arg_align (stmt
));
2075 gimple_omp_task_set_arg_align (copy
, t
);
2078 case GIMPLE_OMP_CRITICAL
:
2079 t
= unshare_expr (gimple_omp_critical_name
2080 (as_a
<gomp_critical
*> (stmt
)));
2081 gimple_omp_critical_set_name (as_a
<gomp_critical
*> (copy
), t
);
2082 t
= unshare_expr (gimple_omp_critical_clauses
2083 (as_a
<gomp_critical
*> (stmt
)));
2084 gimple_omp_critical_set_clauses (as_a
<gomp_critical
*> (copy
), t
);
2087 case GIMPLE_OMP_ORDERED
:
2088 t
= unshare_expr (gimple_omp_ordered_clauses
2089 (as_a
<gomp_ordered
*> (stmt
)));
2090 gimple_omp_ordered_set_clauses (as_a
<gomp_ordered
*> (copy
), t
);
2093 case GIMPLE_OMP_SCAN
:
2094 t
= gimple_omp_scan_clauses (as_a
<gomp_scan
*> (stmt
));
2095 t
= unshare_expr (t
);
2096 gimple_omp_scan_set_clauses (as_a
<gomp_scan
*> (copy
), t
);
2099 case GIMPLE_OMP_TASKGROUP
:
2100 t
= unshare_expr (gimple_omp_taskgroup_clauses (stmt
));
2101 gimple_omp_taskgroup_set_clauses (copy
, t
);
2104 case GIMPLE_OMP_SECTIONS
:
2105 t
= unshare_expr (gimple_omp_sections_clauses (stmt
));
2106 gimple_omp_sections_set_clauses (copy
, t
);
2107 t
= unshare_expr (gimple_omp_sections_control (stmt
));
2108 gimple_omp_sections_set_control (copy
, t
);
2111 case GIMPLE_OMP_SINGLE
:
2113 gomp_single
*omp_single_copy
= as_a
<gomp_single
*> (copy
);
2114 t
= unshare_expr (gimple_omp_single_clauses (stmt
));
2115 gimple_omp_single_set_clauses (omp_single_copy
, t
);
2119 case GIMPLE_OMP_SCOPE
:
2120 t
= unshare_expr (gimple_omp_scope_clauses (stmt
));
2121 gimple_omp_scope_set_clauses (copy
, t
);
2124 case GIMPLE_OMP_TARGET
:
2126 gomp_target
*omp_target_stmt
= as_a
<gomp_target
*> (stmt
);
2127 gomp_target
*omp_target_copy
= as_a
<gomp_target
*> (copy
);
2128 t
= unshare_expr (gimple_omp_target_clauses (omp_target_stmt
));
2129 gimple_omp_target_set_clauses (omp_target_copy
, t
);
2130 t
= unshare_expr (gimple_omp_target_data_arg (omp_target_stmt
));
2131 gimple_omp_target_set_data_arg (omp_target_copy
, t
);
2135 case GIMPLE_OMP_TEAMS
:
2137 gomp_teams
*omp_teams_copy
= as_a
<gomp_teams
*> (copy
);
2138 t
= unshare_expr (gimple_omp_teams_clauses (stmt
));
2139 gimple_omp_teams_set_clauses (omp_teams_copy
, t
);
2143 case GIMPLE_OMP_SECTION
:
2144 case GIMPLE_OMP_MASTER
:
2146 new_seq
= gimple_seq_copy (gimple_omp_body (stmt
));
2147 gimple_omp_set_body (copy
, new_seq
);
2150 case GIMPLE_OMP_MASKED
:
2151 t
= unshare_expr (gimple_omp_masked_clauses (stmt
));
2152 gimple_omp_masked_set_clauses (copy
, t
);
2155 case GIMPLE_TRANSACTION
:
2156 new_seq
= gimple_seq_copy (gimple_transaction_body (
2157 as_a
<gtransaction
*> (stmt
)));
2158 gimple_transaction_set_body (as_a
<gtransaction
*> (copy
),
2162 case GIMPLE_WITH_CLEANUP_EXPR
:
2163 new_seq
= gimple_seq_copy (gimple_wce_cleanup (stmt
));
2164 gimple_wce_set_cleanup (copy
, new_seq
);
2172 /* Make copy of operands. */
2173 for (i
= 0; i
< num_ops
; i
++)
2174 gimple_set_op (copy
, i
, unshare_expr (gimple_op (stmt
, i
)));
2176 if (gimple_has_mem_ops (stmt
))
2178 gimple_set_vdef (copy
, gimple_vdef (stmt
));
2179 gimple_set_vuse (copy
, gimple_vuse (stmt
));
2182 /* Clear out SSA operand vectors on COPY. */
2183 if (gimple_has_ops (stmt
))
2185 gimple_set_use_ops (copy
, NULL
);
2187 /* SSA operands need to be updated. */
2188 gimple_set_modified (copy
, true);
2191 if (gimple_debug_nonbind_marker_p (stmt
))
2192 cfun
->debug_marker_count
++;
2197 /* Move OLD_STMT's vuse and vdef operands to NEW_STMT, on the assumption
2198 that OLD_STMT is about to be removed. */
2201 gimple_move_vops (gimple
*new_stmt
, gimple
*old_stmt
)
2203 tree vdef
= gimple_vdef (old_stmt
);
2204 gimple_set_vuse (new_stmt
, gimple_vuse (old_stmt
));
2205 gimple_set_vdef (new_stmt
, vdef
);
2206 if (vdef
&& TREE_CODE (vdef
) == SSA_NAME
)
2207 SSA_NAME_DEF_STMT (vdef
) = new_stmt
;
2210 /* Return true if statement S has side-effects. We consider a
2211 statement to have side effects if:
2213 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
2214 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
2217 gimple_has_side_effects (const gimple
*s
)
2219 if (is_gimple_debug (s
))
2222 /* We don't have to scan the arguments to check for
2223 volatile arguments, though, at present, we still
2224 do a scan to check for TREE_SIDE_EFFECTS. */
2225 if (gimple_has_volatile_ops (s
))
2228 if (gimple_code (s
) == GIMPLE_ASM
2229 && gimple_asm_volatile_p (as_a
<const gasm
*> (s
)))
2232 if (is_gimple_call (s
))
2234 int flags
= gimple_call_flags (s
);
2236 /* An infinite loop is considered a side effect. */
2237 if (!(flags
& (ECF_CONST
| ECF_PURE
))
2238 || (flags
& ECF_LOOPING_CONST_OR_PURE
))
2247 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
2248 Return true if S can trap. When INCLUDE_MEM is true, check whether
2249 the memory operations could trap. When INCLUDE_STORES is true and
2250 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
2253 gimple_could_trap_p_1 (const gimple
*s
, bool include_mem
, bool include_stores
)
2255 tree t
, div
= NULL_TREE
;
2260 unsigned i
, start
= (is_gimple_assign (s
) && !include_stores
) ? 1 : 0;
2262 for (i
= start
; i
< gimple_num_ops (s
); i
++)
2263 if (tree_could_trap_p (gimple_op (s
, i
)))
2267 switch (gimple_code (s
))
2270 return gimple_asm_volatile_p (as_a
<const gasm
*> (s
));
2273 if (gimple_call_internal_p (s
))
2275 t
= gimple_call_fndecl (s
);
2276 /* Assume that indirect and calls to weak functions may trap. */
2277 if (!t
|| !DECL_P (t
) || DECL_WEAK (t
))
2282 op
= gimple_assign_rhs_code (s
);
2284 /* For COND_EXPR only the condition may trap. */
2285 if (op
== COND_EXPR
)
2286 return tree_could_trap_p (gimple_assign_rhs1 (s
));
2288 /* For comparisons we need to check rhs operand types instead of lhs type
2289 (which is BOOLEAN_TYPE). */
2290 if (TREE_CODE_CLASS (op
) == tcc_comparison
)
2291 t
= TREE_TYPE (gimple_assign_rhs1 (s
));
2293 t
= TREE_TYPE (gimple_assign_lhs (s
));
2295 if (get_gimple_rhs_class (op
) == GIMPLE_BINARY_RHS
)
2296 div
= gimple_assign_rhs2 (s
);
2298 return (operation_could_trap_p (op
, FLOAT_TYPE_P (t
),
2299 (INTEGRAL_TYPE_P (t
)
2300 && TYPE_OVERFLOW_TRAPS (t
)),
2304 t
= TREE_TYPE (gimple_cond_lhs (s
));
2305 return operation_could_trap_p (gimple_cond_code (s
),
2306 FLOAT_TYPE_P (t
), false, NULL_TREE
);
2315 /* Return true if statement S can trap. */
2318 gimple_could_trap_p (const gimple
*s
)
2320 return gimple_could_trap_p_1 (s
, true, true);
2323 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
2326 gimple_assign_rhs_could_trap_p (gimple
*s
)
2328 gcc_assert (is_gimple_assign (s
));
2329 return gimple_could_trap_p_1 (s
, true, false);
2333 /* Print debugging information for gimple stmts generated. */
2336 dump_gimple_statistics (void)
2339 uint64_t total_tuples
= 0, total_bytes
= 0;
2341 if (! GATHER_STATISTICS
)
2343 fprintf (stderr
, "No GIMPLE statistics\n");
2347 fprintf (stderr
, "\nGIMPLE statements\n");
2348 fprintf (stderr
, "Kind Stmts Bytes\n");
2349 fprintf (stderr
, "---------------------------------------\n");
2350 for (i
= 0; i
< (int) gimple_alloc_kind_all
; ++i
)
2352 fprintf (stderr
, "%-20s %7" PRIu64
"%c %10" PRIu64
"%c\n",
2353 gimple_alloc_kind_names
[i
],
2354 SIZE_AMOUNT (gimple_alloc_counts
[i
]),
2355 SIZE_AMOUNT (gimple_alloc_sizes
[i
]));
2356 total_tuples
+= gimple_alloc_counts
[i
];
2357 total_bytes
+= gimple_alloc_sizes
[i
];
2359 fprintf (stderr
, "---------------------------------------\n");
2360 fprintf (stderr
, "%-20s %7" PRIu64
"%c %10" PRIu64
"%c\n", "Total",
2361 SIZE_AMOUNT (total_tuples
), SIZE_AMOUNT (total_bytes
));
2362 fprintf (stderr
, "---------------------------------------\n");
2366 /* Return the number of operands needed on the RHS of a GIMPLE
2367 assignment for an expression with tree code CODE. */
2370 get_gimple_rhs_num_ops (enum tree_code code
)
2372 switch (get_gimple_rhs_class (code
))
2374 case GIMPLE_UNARY_RHS
:
2375 case GIMPLE_SINGLE_RHS
:
2377 case GIMPLE_BINARY_RHS
:
2379 case GIMPLE_TERNARY_RHS
:
2386 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2388 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2389 : ((TYPE) == tcc_binary \
2390 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2391 : ((TYPE) == tcc_constant \
2392 || (TYPE) == tcc_declaration \
2393 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2394 : ((SYM) == TRUTH_AND_EXPR \
2395 || (SYM) == TRUTH_OR_EXPR \
2396 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2397 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2398 : ((SYM) == COND_EXPR \
2399 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2400 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2401 || (SYM) == DOT_PROD_EXPR \
2402 || (SYM) == SAD_EXPR \
2403 || (SYM) == REALIGN_LOAD_EXPR \
2404 || (SYM) == VEC_COND_EXPR \
2405 || (SYM) == VEC_PERM_EXPR \
2406 || (SYM) == BIT_INSERT_EXPR) ? GIMPLE_TERNARY_RHS \
2407 : ((SYM) == CONSTRUCTOR \
2408 || (SYM) == OBJ_TYPE_REF \
2409 || (SYM) == ASSERT_EXPR \
2410 || (SYM) == ADDR_EXPR \
2411 || (SYM) == WITH_SIZE_EXPR \
2412 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2413 : GIMPLE_INVALID_RHS),
2414 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2416 const unsigned char gimple_rhs_class_table
[] = {
2417 #include "all-tree.def"
2421 #undef END_OF_BASE_TREE_CODES
2423 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2424 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2425 we failed to create one. */
2428 canonicalize_cond_expr_cond (tree t
)
2430 /* Strip conversions around boolean operations. */
2431 if (CONVERT_EXPR_P (t
)
2432 && (truth_value_p (TREE_CODE (TREE_OPERAND (t
, 0)))
2433 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
2435 t
= TREE_OPERAND (t
, 0);
2437 /* For !x use x == 0. */
2438 if (TREE_CODE (t
) == TRUTH_NOT_EXPR
)
2440 tree top0
= TREE_OPERAND (t
, 0);
2441 t
= build2 (EQ_EXPR
, TREE_TYPE (t
),
2442 top0
, build_int_cst (TREE_TYPE (top0
), 0));
2444 /* For cmp ? 1 : 0 use cmp. */
2445 else if (TREE_CODE (t
) == COND_EXPR
2446 && COMPARISON_CLASS_P (TREE_OPERAND (t
, 0))
2447 && integer_onep (TREE_OPERAND (t
, 1))
2448 && integer_zerop (TREE_OPERAND (t
, 2)))
2450 tree top0
= TREE_OPERAND (t
, 0);
2451 t
= build2 (TREE_CODE (top0
), TREE_TYPE (t
),
2452 TREE_OPERAND (top0
, 0), TREE_OPERAND (top0
, 1));
2454 /* For x ^ y use x != y. */
2455 else if (TREE_CODE (t
) == BIT_XOR_EXPR
)
2456 t
= build2 (NE_EXPR
, TREE_TYPE (t
),
2457 TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1));
2459 if (is_gimple_condexpr (t
))
2465 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2466 the positions marked by the set ARGS_TO_SKIP. */
2469 gimple_call_copy_skip_args (gcall
*stmt
, bitmap args_to_skip
)
2472 int nargs
= gimple_call_num_args (stmt
);
2473 auto_vec
<tree
> vargs (nargs
);
2476 for (i
= 0; i
< nargs
; i
++)
2477 if (!bitmap_bit_p (args_to_skip
, i
))
2478 vargs
.quick_push (gimple_call_arg (stmt
, i
));
2480 if (gimple_call_internal_p (stmt
))
2481 new_stmt
= gimple_build_call_internal_vec (gimple_call_internal_fn (stmt
),
2484 new_stmt
= gimple_build_call_vec (gimple_call_fn (stmt
), vargs
);
2486 if (gimple_call_lhs (stmt
))
2487 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2489 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2490 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
2492 if (gimple_has_location (stmt
))
2493 gimple_set_location (new_stmt
, gimple_location (stmt
));
2494 gimple_call_copy_flags (new_stmt
, stmt
);
2495 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2497 gimple_set_modified (new_stmt
, true);
2504 /* Return true if the field decls F1 and F2 are at the same offset.
2506 This is intended to be used on GIMPLE types only. */
2509 gimple_compare_field_offset (tree f1
, tree f2
)
2511 if (DECL_OFFSET_ALIGN (f1
) == DECL_OFFSET_ALIGN (f2
))
2513 tree offset1
= DECL_FIELD_OFFSET (f1
);
2514 tree offset2
= DECL_FIELD_OFFSET (f2
);
2515 return ((offset1
== offset2
2516 /* Once gimplification is done, self-referential offsets are
2517 instantiated as operand #2 of the COMPONENT_REF built for
2518 each access and reset. Therefore, they are not relevant
2519 anymore and fields are interchangeable provided that they
2520 represent the same access. */
2521 || (TREE_CODE (offset1
) == PLACEHOLDER_EXPR
2522 && TREE_CODE (offset2
) == PLACEHOLDER_EXPR
2523 && (DECL_SIZE (f1
) == DECL_SIZE (f2
)
2524 || (TREE_CODE (DECL_SIZE (f1
)) == PLACEHOLDER_EXPR
2525 && TREE_CODE (DECL_SIZE (f2
)) == PLACEHOLDER_EXPR
)
2526 || operand_equal_p (DECL_SIZE (f1
), DECL_SIZE (f2
), 0))
2527 && DECL_ALIGN (f1
) == DECL_ALIGN (f2
))
2528 || operand_equal_p (offset1
, offset2
, 0))
2529 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1
),
2530 DECL_FIELD_BIT_OFFSET (f2
)));
2533 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2534 should be, so handle differing ones specially by decomposing
2535 the offset into a byte and bit offset manually. */
2536 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1
))
2537 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2
)))
2539 unsigned HOST_WIDE_INT byte_offset1
, byte_offset2
;
2540 unsigned HOST_WIDE_INT bit_offset1
, bit_offset2
;
2541 bit_offset1
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1
));
2542 byte_offset1
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1
))
2543 + bit_offset1
/ BITS_PER_UNIT
);
2544 bit_offset2
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2
));
2545 byte_offset2
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2
))
2546 + bit_offset2
/ BITS_PER_UNIT
);
2547 if (byte_offset1
!= byte_offset2
)
2549 return bit_offset1
% BITS_PER_UNIT
== bit_offset2
% BITS_PER_UNIT
;
2556 /* Return a type the same as TYPE except unsigned or
2557 signed according to UNSIGNEDP. */
2560 gimple_signed_or_unsigned_type (bool unsignedp
, tree type
)
2565 type1
= TYPE_MAIN_VARIANT (type
);
2566 if (type1
== signed_char_type_node
2567 || type1
== char_type_node
2568 || type1
== unsigned_char_type_node
)
2569 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2570 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2571 return unsignedp
? unsigned_type_node
: integer_type_node
;
2572 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2573 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2574 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2575 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2576 if (type1
== long_long_integer_type_node
2577 || type1
== long_long_unsigned_type_node
)
2579 ? long_long_unsigned_type_node
2580 : long_long_integer_type_node
;
2582 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2583 if (int_n_enabled_p
[i
]
2584 && (type1
== int_n_trees
[i
].unsigned_type
2585 || type1
== int_n_trees
[i
].signed_type
))
2587 ? int_n_trees
[i
].unsigned_type
2588 : int_n_trees
[i
].signed_type
;
2590 #if HOST_BITS_PER_WIDE_INT >= 64
2591 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2592 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2594 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2595 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2596 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2597 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2598 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2599 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2600 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2601 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2603 #define GIMPLE_FIXED_TYPES(NAME) \
2604 if (type1 == short_ ## NAME ## _type_node \
2605 || type1 == unsigned_short_ ## NAME ## _type_node) \
2606 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2607 : short_ ## NAME ## _type_node; \
2608 if (type1 == NAME ## _type_node \
2609 || type1 == unsigned_ ## NAME ## _type_node) \
2610 return unsignedp ? unsigned_ ## NAME ## _type_node \
2611 : NAME ## _type_node; \
2612 if (type1 == long_ ## NAME ## _type_node \
2613 || type1 == unsigned_long_ ## NAME ## _type_node) \
2614 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2615 : long_ ## NAME ## _type_node; \
2616 if (type1 == long_long_ ## NAME ## _type_node \
2617 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2618 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2619 : long_long_ ## NAME ## _type_node;
2621 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2622 if (type1 == NAME ## _type_node \
2623 || type1 == u ## NAME ## _type_node) \
2624 return unsignedp ? u ## NAME ## _type_node \
2625 : NAME ## _type_node;
2627 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2628 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2629 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2630 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2631 : sat_ ## short_ ## NAME ## _type_node; \
2632 if (type1 == sat_ ## NAME ## _type_node \
2633 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2634 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2635 : sat_ ## NAME ## _type_node; \
2636 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2637 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2638 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2639 : sat_ ## long_ ## NAME ## _type_node; \
2640 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2641 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2642 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2643 : sat_ ## long_long_ ## NAME ## _type_node;
2645 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2646 if (type1 == sat_ ## NAME ## _type_node \
2647 || type1 == sat_ ## u ## NAME ## _type_node) \
2648 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2649 : sat_ ## NAME ## _type_node;
2651 GIMPLE_FIXED_TYPES (fract
);
2652 GIMPLE_FIXED_TYPES_SAT (fract
);
2653 GIMPLE_FIXED_TYPES (accum
);
2654 GIMPLE_FIXED_TYPES_SAT (accum
);
2656 GIMPLE_FIXED_MODE_TYPES (qq
);
2657 GIMPLE_FIXED_MODE_TYPES (hq
);
2658 GIMPLE_FIXED_MODE_TYPES (sq
);
2659 GIMPLE_FIXED_MODE_TYPES (dq
);
2660 GIMPLE_FIXED_MODE_TYPES (tq
);
2661 GIMPLE_FIXED_MODE_TYPES_SAT (qq
);
2662 GIMPLE_FIXED_MODE_TYPES_SAT (hq
);
2663 GIMPLE_FIXED_MODE_TYPES_SAT (sq
);
2664 GIMPLE_FIXED_MODE_TYPES_SAT (dq
);
2665 GIMPLE_FIXED_MODE_TYPES_SAT (tq
);
2666 GIMPLE_FIXED_MODE_TYPES (ha
);
2667 GIMPLE_FIXED_MODE_TYPES (sa
);
2668 GIMPLE_FIXED_MODE_TYPES (da
);
2669 GIMPLE_FIXED_MODE_TYPES (ta
);
2670 GIMPLE_FIXED_MODE_TYPES_SAT (ha
);
2671 GIMPLE_FIXED_MODE_TYPES_SAT (sa
);
2672 GIMPLE_FIXED_MODE_TYPES_SAT (da
);
2673 GIMPLE_FIXED_MODE_TYPES_SAT (ta
);
2675 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2676 the precision; they have precision set to match their range, but
2677 may use a wider mode to match an ABI. If we change modes, we may
2678 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2679 the precision as well, so as to yield correct results for
2680 bit-field types. C++ does not have these separate bit-field
2681 types, and producing a signed or unsigned variant of an
2682 ENUMERAL_TYPE may cause other problems as well. */
2683 if (!INTEGRAL_TYPE_P (type
)
2684 || TYPE_UNSIGNED (type
) == unsignedp
)
2687 #define TYPE_OK(node) \
2688 (TYPE_MODE (type) == TYPE_MODE (node) \
2689 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2690 if (TYPE_OK (signed_char_type_node
))
2691 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2692 if (TYPE_OK (integer_type_node
))
2693 return unsignedp
? unsigned_type_node
: integer_type_node
;
2694 if (TYPE_OK (short_integer_type_node
))
2695 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2696 if (TYPE_OK (long_integer_type_node
))
2697 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2698 if (TYPE_OK (long_long_integer_type_node
))
2700 ? long_long_unsigned_type_node
2701 : long_long_integer_type_node
);
2703 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2704 if (int_n_enabled_p
[i
]
2705 && TYPE_MODE (type
) == int_n_data
[i
].m
2706 && TYPE_PRECISION (type
) == int_n_data
[i
].bitsize
)
2708 ? int_n_trees
[i
].unsigned_type
2709 : int_n_trees
[i
].signed_type
;
2711 #if HOST_BITS_PER_WIDE_INT >= 64
2712 if (TYPE_OK (intTI_type_node
))
2713 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2715 if (TYPE_OK (intDI_type_node
))
2716 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2717 if (TYPE_OK (intSI_type_node
))
2718 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2719 if (TYPE_OK (intHI_type_node
))
2720 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2721 if (TYPE_OK (intQI_type_node
))
2722 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2724 #undef GIMPLE_FIXED_TYPES
2725 #undef GIMPLE_FIXED_MODE_TYPES
2726 #undef GIMPLE_FIXED_TYPES_SAT
2727 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2730 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2734 /* Return an unsigned type the same as TYPE in other respects. */
2737 gimple_unsigned_type (tree type
)
2739 return gimple_signed_or_unsigned_type (true, type
);
2743 /* Return a signed type the same as TYPE in other respects. */
2746 gimple_signed_type (tree type
)
2748 return gimple_signed_or_unsigned_type (false, type
);
2752 /* Return the typed-based alias set for T, which may be an expression
2753 or a type. Return -1 if we don't do anything special. */
2756 gimple_get_alias_set (tree t
)
2758 /* That's all the expressions we handle specially. */
2762 /* For convenience, follow the C standard when dealing with
2763 character types. Any object may be accessed via an lvalue that
2764 has character type. */
2765 if (t
== char_type_node
2766 || t
== signed_char_type_node
2767 || t
== unsigned_char_type_node
)
2770 /* Allow aliasing between signed and unsigned variants of the same
2771 type. We treat the signed variant as canonical. */
2772 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2774 tree t1
= gimple_signed_type (t
);
2776 /* t1 == t can happen for boolean nodes which are always unsigned. */
2778 return get_alias_set (t1
);
2781 /* Allow aliasing between enumeral types and the underlying
2782 integer type. This is required for C since those are
2783 compatible types. */
2784 else if (TREE_CODE (t
) == ENUMERAL_TYPE
)
2786 tree t1
= lang_hooks
.types
.type_for_size (tree_to_uhwi (TYPE_SIZE (t
)),
2787 false /* short-cut above */);
2788 return get_alias_set (t1
);
2795 /* Helper for gimple_ior_addresses_taken_1. */
2798 gimple_ior_addresses_taken_1 (gimple
*, tree addr
, tree
, void *data
)
2800 bitmap addresses_taken
= (bitmap
)data
;
2801 addr
= get_base_address (addr
);
2805 bitmap_set_bit (addresses_taken
, DECL_UID (addr
));
2811 /* Set the bit for the uid of all decls that have their address taken
2812 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2813 were any in this stmt. */
2816 gimple_ior_addresses_taken (bitmap addresses_taken
, gimple
*stmt
)
2818 return walk_stmt_load_store_addr_ops (stmt
, addresses_taken
, NULL
, NULL
,
2819 gimple_ior_addresses_taken_1
);
2823 /* Return true when STMTs arguments and return value match those of FNDECL,
2824 a decl of a builtin function. */
2827 gimple_builtin_call_types_compatible_p (const gimple
*stmt
, tree fndecl
)
2829 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
);
2831 tree ret
= gimple_call_lhs (stmt
);
2833 && !useless_type_conversion_p (TREE_TYPE (ret
),
2834 TREE_TYPE (TREE_TYPE (fndecl
))))
2837 tree targs
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2838 unsigned nargs
= gimple_call_num_args (stmt
);
2839 for (unsigned i
= 0; i
< nargs
; ++i
)
2841 /* Variadic args follow. */
2844 tree arg
= gimple_call_arg (stmt
, i
);
2845 tree type
= TREE_VALUE (targs
);
2846 if (!useless_type_conversion_p (type
, TREE_TYPE (arg
))
2847 /* char/short integral arguments are promoted to int
2848 by several frontends if targetm.calls.promote_prototypes
2849 is true. Allow such promotion too. */
2850 && !(INTEGRAL_TYPE_P (type
)
2851 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)
2852 && targetm
.calls
.promote_prototypes (TREE_TYPE (fndecl
))
2853 && useless_type_conversion_p (integer_type_node
,
2856 targs
= TREE_CHAIN (targs
);
2858 if (targs
&& !VOID_TYPE_P (TREE_VALUE (targs
)))
2863 /* Return true when STMT is operator a replaceable delete call. */
2866 gimple_call_operator_delete_p (const gcall
*stmt
)
2870 if ((fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
)
2871 return DECL_IS_OPERATOR_DELETE_P (fndecl
);
2875 /* Return true when STMT is builtins call. */
2878 gimple_call_builtin_p (const gimple
*stmt
)
2881 if (is_gimple_call (stmt
)
2882 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2883 && DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
)
2884 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2888 /* Return true when STMT is builtins call to CLASS. */
2891 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_class klass
)
2894 if (is_gimple_call (stmt
)
2895 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2896 && DECL_BUILT_IN_CLASS (fndecl
) == klass
)
2897 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2901 /* Return true when STMT is builtins call to CODE of CLASS. */
2904 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_function code
)
2907 if (is_gimple_call (stmt
)
2908 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2909 && fndecl_built_in_p (fndecl
, code
))
2910 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2914 /* If CALL is a call to a combined_fn (i.e. an internal function or
2915 a normal built-in function), return its code, otherwise return
2919 gimple_call_combined_fn (const gimple
*stmt
)
2921 if (const gcall
*call
= dyn_cast
<const gcall
*> (stmt
))
2923 if (gimple_call_internal_p (call
))
2924 return as_combined_fn (gimple_call_internal_fn (call
));
2926 tree fndecl
= gimple_call_fndecl (stmt
);
2928 && fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
)
2929 && gimple_builtin_call_types_compatible_p (stmt
, fndecl
))
2930 return as_combined_fn (DECL_FUNCTION_CODE (fndecl
));
2935 /* Return true if STMT clobbers memory. STMT is required to be a
2939 gimple_asm_clobbers_memory_p (const gasm
*stmt
)
2943 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
2945 tree op
= gimple_asm_clobber_op (stmt
, i
);
2946 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op
)), "memory") == 0)
2950 /* Non-empty basic ASM implicitly clobbers memory. */
2951 if (gimple_asm_input_p (stmt
) && strlen (gimple_asm_string (stmt
)) != 0)
2957 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2960 dump_decl_set (FILE *file
, bitmap set
)
2967 fprintf (file
, "{ ");
2969 EXECUTE_IF_SET_IN_BITMAP (set
, 0, i
, bi
)
2971 fprintf (file
, "D.%u", i
);
2972 fprintf (file
, " ");
2975 fprintf (file
, "}");
2978 fprintf (file
, "NIL");
2981 /* Return true when CALL is a call stmt that definitely doesn't
2982 free any memory or makes it unavailable otherwise. */
2984 nonfreeing_call_p (gimple
*call
)
2986 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2987 && gimple_call_flags (call
) & ECF_LEAF
)
2988 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call
)))
2990 /* Just in case these become ECF_LEAF in the future. */
2992 case BUILT_IN_TM_FREE
:
2993 case BUILT_IN_REALLOC
:
2994 case BUILT_IN_STACK_RESTORE
:
2999 else if (gimple_call_internal_p (call
))
3000 switch (gimple_call_internal_fn (call
))
3002 case IFN_ABNORMAL_DISPATCHER
:
3005 return tree_to_uhwi (gimple_call_arg (call
, 0)) == ASAN_MARK_UNPOISON
;
3007 if (gimple_call_flags (call
) & ECF_LEAF
)
3012 tree fndecl
= gimple_call_fndecl (call
);
3015 struct cgraph_node
*n
= cgraph_node::get (fndecl
);
3018 enum availability availability
;
3019 n
= n
->function_symbol (&availability
);
3020 if (!n
|| availability
<= AVAIL_INTERPOSABLE
)
3022 return n
->nonfreeing_fn
;
3025 /* Return true when CALL is a call stmt that definitely need not
3026 be considered to be a memory barrier. */
3028 nonbarrier_call_p (gimple
*call
)
3030 if (gimple_call_flags (call
) & (ECF_PURE
| ECF_CONST
))
3032 /* Should extend this to have a nonbarrier_fn flag, just as above in
3033 the nonfreeing case. */
3037 /* Callback for walk_stmt_load_store_ops.
3039 Return TRUE if OP will dereference the tree stored in DATA, FALSE
3042 This routine only makes a superficial check for a dereference. Thus
3043 it must only be used if it is safe to return a false negative. */
3045 check_loadstore (gimple
*, tree op
, tree
, void *data
)
3047 if (TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
3049 /* Some address spaces may legitimately dereference zero. */
3050 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (op
));
3051 if (targetm
.addr_space
.zero_address_valid (as
))
3054 return operand_equal_p (TREE_OPERAND (op
, 0), (tree
)data
, 0);
3060 /* Return true if OP can be inferred to be non-NULL after STMT executes,
3061 either by using a pointer dereference or attributes. */
3063 infer_nonnull_range (gimple
*stmt
, tree op
)
3065 return (infer_nonnull_range_by_dereference (stmt
, op
)
3066 || infer_nonnull_range_by_attribute (stmt
, op
));
3069 /* Return true if OP can be inferred to be non-NULL after STMT
3070 executes by using a pointer dereference. */
3072 infer_nonnull_range_by_dereference (gimple
*stmt
, tree op
)
3074 /* We can only assume that a pointer dereference will yield
3075 non-NULL if -fdelete-null-pointer-checks is enabled. */
3076 if (!flag_delete_null_pointer_checks
3077 || !POINTER_TYPE_P (TREE_TYPE (op
))
3078 || gimple_code (stmt
) == GIMPLE_ASM
3079 || gimple_clobber_p (stmt
))
3082 if (walk_stmt_load_store_ops (stmt
, (void *)op
,
3083 check_loadstore
, check_loadstore
))
3089 /* Return true if OP can be inferred to be a non-NULL after STMT
3090 executes by using attributes. */
3092 infer_nonnull_range_by_attribute (gimple
*stmt
, tree op
)
3094 /* We can only assume that a pointer dereference will yield
3095 non-NULL if -fdelete-null-pointer-checks is enabled. */
3096 if (!flag_delete_null_pointer_checks
3097 || !POINTER_TYPE_P (TREE_TYPE (op
))
3098 || gimple_code (stmt
) == GIMPLE_ASM
)
3101 if (is_gimple_call (stmt
) && !gimple_call_internal_p (stmt
))
3103 tree fntype
= gimple_call_fntype (stmt
);
3104 tree attrs
= TYPE_ATTRIBUTES (fntype
);
3105 for (; attrs
; attrs
= TREE_CHAIN (attrs
))
3107 attrs
= lookup_attribute ("nonnull", attrs
);
3109 /* If "nonnull" wasn't specified, we know nothing about
3111 if (attrs
== NULL_TREE
)
3114 /* If "nonnull" applies to all the arguments, then ARG
3115 is non-null if it's in the argument list. */
3116 if (TREE_VALUE (attrs
) == NULL_TREE
)
3118 for (unsigned int i
= 0; i
< gimple_call_num_args (stmt
); i
++)
3120 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt
, i
)))
3121 && operand_equal_p (op
, gimple_call_arg (stmt
, i
), 0))
3127 /* Now see if op appears in the nonnull list. */
3128 for (tree t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
3130 unsigned int idx
= TREE_INT_CST_LOW (TREE_VALUE (t
)) - 1;
3131 if (idx
< gimple_call_num_args (stmt
))
3133 tree arg
= gimple_call_arg (stmt
, idx
);
3134 if (operand_equal_p (op
, arg
, 0))
3141 /* If this function is marked as returning non-null, then we can
3142 infer OP is non-null if it is used in the return statement. */
3143 if (greturn
*return_stmt
= dyn_cast
<greturn
*> (stmt
))
3144 if (gimple_return_retval (return_stmt
)
3145 && operand_equal_p (gimple_return_retval (return_stmt
), op
, 0)
3146 && lookup_attribute ("returns_nonnull",
3147 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
))))
3153 /* Compare two case labels. Because the front end should already have
3154 made sure that case ranges do not overlap, it is enough to only compare
3155 the CASE_LOW values of each case label. */
3158 compare_case_labels (const void *p1
, const void *p2
)
3160 const_tree
const case1
= *(const_tree
const*)p1
;
3161 const_tree
const case2
= *(const_tree
const*)p2
;
3163 /* The 'default' case label always goes first. */
3164 if (!CASE_LOW (case1
))
3166 else if (!CASE_LOW (case2
))
3169 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
3172 /* Sort the case labels in LABEL_VEC in place in ascending order. */
3175 sort_case_labels (vec
<tree
> &label_vec
)
3177 label_vec
.qsort (compare_case_labels
);
3180 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
3182 LABELS is a vector that contains all case labels to look at.
3184 INDEX_TYPE is the type of the switch index expression. Case labels
3185 in LABELS are discarded if their values are not in the value range
3186 covered by INDEX_TYPE. The remaining case label values are folded
3189 If a default case exists in LABELS, it is removed from LABELS and
3190 returned in DEFAULT_CASEP. If no default case exists, but the
3191 case labels already cover the whole range of INDEX_TYPE, a default
3192 case is returned pointing to one of the existing case labels.
3193 Otherwise DEFAULT_CASEP is set to NULL_TREE.
3195 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
3196 apply and no action is taken regardless of whether a default case is
3200 preprocess_case_label_vec_for_gimple (vec
<tree
> &labels
,
3202 tree
*default_casep
)
3204 tree min_value
, max_value
;
3205 tree default_case
= NULL_TREE
;
3209 min_value
= TYPE_MIN_VALUE (index_type
);
3210 max_value
= TYPE_MAX_VALUE (index_type
);
3211 while (i
< labels
.length ())
3213 tree elt
= labels
[i
];
3214 tree low
= CASE_LOW (elt
);
3215 tree high
= CASE_HIGH (elt
);
3216 bool remove_element
= FALSE
;
3220 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
3221 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
3223 /* This is a non-default case label, i.e. it has a value.
3225 See if the case label is reachable within the range of
3226 the index type. Remove out-of-range case values. Turn
3227 case ranges into a canonical form (high > low strictly)
3228 and convert the case label values to the index type.
3230 NB: The type of gimple_switch_index() may be the promoted
3231 type, but the case labels retain the original type. */
3235 /* This is a case range. Discard empty ranges.
3236 If the bounds or the range are equal, turn this
3237 into a simple (one-value) case. */
3238 int cmp
= tree_int_cst_compare (high
, low
);
3240 remove_element
= TRUE
;
3247 /* If the simple case value is unreachable, ignore it. */
3248 if ((TREE_CODE (min_value
) == INTEGER_CST
3249 && tree_int_cst_compare (low
, min_value
) < 0)
3250 || (TREE_CODE (max_value
) == INTEGER_CST
3251 && tree_int_cst_compare (low
, max_value
) > 0))
3252 remove_element
= TRUE
;
3254 low
= fold_convert (index_type
, low
);
3258 /* If the entire case range is unreachable, ignore it. */
3259 if ((TREE_CODE (min_value
) == INTEGER_CST
3260 && tree_int_cst_compare (high
, min_value
) < 0)
3261 || (TREE_CODE (max_value
) == INTEGER_CST
3262 && tree_int_cst_compare (low
, max_value
) > 0))
3263 remove_element
= TRUE
;
3266 /* If the lower bound is less than the index type's
3267 minimum value, truncate the range bounds. */
3268 if (TREE_CODE (min_value
) == INTEGER_CST
3269 && tree_int_cst_compare (low
, min_value
) < 0)
3271 low
= fold_convert (index_type
, low
);
3273 /* If the upper bound is greater than the index type's
3274 maximum value, truncate the range bounds. */
3275 if (TREE_CODE (max_value
) == INTEGER_CST
3276 && tree_int_cst_compare (high
, max_value
) > 0)
3278 high
= fold_convert (index_type
, high
);
3280 /* We may have folded a case range to a one-value case. */
3281 if (tree_int_cst_equal (low
, high
))
3286 CASE_LOW (elt
) = low
;
3287 CASE_HIGH (elt
) = high
;
3291 gcc_assert (!default_case
);
3293 /* The default case must be passed separately to the
3294 gimple_build_switch routine. But if DEFAULT_CASEP
3295 is NULL, we do not remove the default case (it would
3296 be completely lost). */
3298 remove_element
= TRUE
;
3302 labels
.ordered_remove (i
);
3308 if (!labels
.is_empty ())
3309 sort_case_labels (labels
);
3311 if (default_casep
&& !default_case
)
3313 /* If the switch has no default label, add one, so that we jump
3314 around the switch body. If the labels already cover the whole
3315 range of the switch index_type, add the default label pointing
3316 to one of the existing labels. */
3318 && TYPE_MIN_VALUE (index_type
)
3319 && TYPE_MAX_VALUE (index_type
)
3320 && tree_int_cst_equal (CASE_LOW (labels
[0]),
3321 TYPE_MIN_VALUE (index_type
)))
3323 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
3325 high
= CASE_LOW (labels
[len
- 1]);
3326 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
3328 tree widest_label
= labels
[0];
3329 for (i
= 1; i
< len
; i
++)
3331 high
= CASE_LOW (labels
[i
]);
3332 low
= CASE_HIGH (labels
[i
- 1]);
3334 low
= CASE_LOW (labels
[i
- 1]);
3336 if (CASE_HIGH (labels
[i
]) != NULL_TREE
3337 && (CASE_HIGH (widest_label
) == NULL_TREE
3339 (wi::to_wide (CASE_HIGH (labels
[i
]))
3340 - wi::to_wide (CASE_LOW (labels
[i
])),
3341 wi::to_wide (CASE_HIGH (widest_label
))
3342 - wi::to_wide (CASE_LOW (widest_label
))))))
3343 widest_label
= labels
[i
];
3345 if (wi::to_wide (low
) + 1 != wi::to_wide (high
))
3350 /* Designate the label with the widest range to be the
3352 tree label
= CASE_LABEL (widest_label
);
3353 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
3361 *default_casep
= default_case
;
3364 /* Set the location of all statements in SEQ to LOC. */
3367 gimple_seq_set_location (gimple_seq seq
, location_t loc
)
3369 for (gimple_stmt_iterator i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
3370 gimple_set_location (gsi_stmt (i
), loc
);
3373 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
3376 gimple_seq_discard (gimple_seq seq
)
3378 gimple_stmt_iterator gsi
;
3380 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); )
3382 gimple
*stmt
= gsi_stmt (gsi
);
3383 gsi_remove (&gsi
, true);
3384 release_defs (stmt
);
3389 /* See if STMT now calls function that takes no parameters and if so, drop
3390 call arguments. This is used when devirtualization machinery redirects
3391 to __builtin_unreachable or __cxa_pure_virtual. */
3394 maybe_remove_unused_call_args (struct function
*fn
, gimple
*stmt
)
3396 tree decl
= gimple_call_fndecl (stmt
);
3397 if (TYPE_ARG_TYPES (TREE_TYPE (decl
))
3398 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
))) == void_type_node
3399 && gimple_call_num_args (stmt
))
3401 gimple_set_num_ops (stmt
, 3);
3402 update_stmt_fn (fn
, stmt
);
3406 /* Return false if STMT will likely expand to real function call. */
3409 gimple_inexpensive_call_p (gcall
*stmt
)
3411 if (gimple_call_internal_p (stmt
))
3413 tree decl
= gimple_call_fndecl (stmt
);
3414 if (decl
&& is_inexpensive_builtin (decl
))
3419 /* Return a non-artificial location for STMT. If STMT does not have
3420 location information, get the location from EXPR. */
3423 gimple_or_expr_nonartificial_location (gimple
*stmt
, tree expr
)
3425 location_t loc
= gimple_nonartificial_location (stmt
);
3426 if (loc
== UNKNOWN_LOCATION
&& EXPR_HAS_LOCATION (expr
))
3427 loc
= tree_nonartificial_location (expr
);
3428 return expansion_point_location_if_in_system_header (loc
);
3434 namespace selftest
{
3436 /* Selftests for core gimple structures. */
3438 /* Verify that STMT is pretty-printed as EXPECTED.
3439 Helper function for selftests. */
3442 verify_gimple_pp (const char *expected
, gimple
*stmt
)
3445 pp_gimple_stmt_1 (&pp
, stmt
, 0 /* spc */, TDF_NONE
/* flags */);
3446 ASSERT_STREQ (expected
, pp_formatted_text (&pp
));
3449 /* Build a GIMPLE_ASSIGN equivalent to
3451 and verify various properties of it. */
3454 test_assign_single ()
3456 tree type
= integer_type_node
;
3457 tree lhs
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3458 get_identifier ("tmp"),
3460 tree rhs
= build_int_cst (type
, 5);
3461 gassign
*stmt
= gimple_build_assign (lhs
, rhs
);
3462 verify_gimple_pp ("tmp = 5;", stmt
);
3464 ASSERT_TRUE (is_gimple_assign (stmt
));
3465 ASSERT_EQ (lhs
, gimple_assign_lhs (stmt
));
3466 ASSERT_EQ (lhs
, gimple_get_lhs (stmt
));
3467 ASSERT_EQ (rhs
, gimple_assign_rhs1 (stmt
));
3468 ASSERT_EQ (NULL
, gimple_assign_rhs2 (stmt
));
3469 ASSERT_EQ (NULL
, gimple_assign_rhs3 (stmt
));
3470 ASSERT_TRUE (gimple_assign_single_p (stmt
));
3471 ASSERT_EQ (INTEGER_CST
, gimple_assign_rhs_code (stmt
));
3474 /* Build a GIMPLE_ASSIGN equivalent to
3476 and verify various properties of it. */
3479 test_assign_binop ()
3481 tree type
= integer_type_node
;
3482 tree lhs
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3483 get_identifier ("tmp"),
3485 tree a
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3486 get_identifier ("a"),
3488 tree b
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3489 get_identifier ("b"),
3491 gassign
*stmt
= gimple_build_assign (lhs
, MULT_EXPR
, a
, b
);
3492 verify_gimple_pp ("tmp = a * b;", stmt
);
3494 ASSERT_TRUE (is_gimple_assign (stmt
));
3495 ASSERT_EQ (lhs
, gimple_assign_lhs (stmt
));
3496 ASSERT_EQ (lhs
, gimple_get_lhs (stmt
));
3497 ASSERT_EQ (a
, gimple_assign_rhs1 (stmt
));
3498 ASSERT_EQ (b
, gimple_assign_rhs2 (stmt
));
3499 ASSERT_EQ (NULL
, gimple_assign_rhs3 (stmt
));
3500 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3501 ASSERT_EQ (MULT_EXPR
, gimple_assign_rhs_code (stmt
));
3504 /* Build a GIMPLE_NOP and verify various properties of it. */
3509 gimple
*stmt
= gimple_build_nop ();
3510 verify_gimple_pp ("GIMPLE_NOP", stmt
);
3511 ASSERT_EQ (GIMPLE_NOP
, gimple_code (stmt
));
3512 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3513 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3516 /* Build a GIMPLE_RETURN equivalent to
3518 and verify various properties of it. */
3523 tree type
= integer_type_node
;
3524 tree val
= build_int_cst (type
, 7);
3525 greturn
*stmt
= gimple_build_return (val
);
3526 verify_gimple_pp ("return 7;", stmt
);
3528 ASSERT_EQ (GIMPLE_RETURN
, gimple_code (stmt
));
3529 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3530 ASSERT_EQ (val
, gimple_return_retval (stmt
));
3531 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3534 /* Build a GIMPLE_RETURN equivalent to
3536 and verify various properties of it. */
3539 test_return_without_value ()
3541 greturn
*stmt
= gimple_build_return (NULL
);
3542 verify_gimple_pp ("return;", stmt
);
3544 ASSERT_EQ (GIMPLE_RETURN
, gimple_code (stmt
));
3545 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3546 ASSERT_EQ (NULL
, gimple_return_retval (stmt
));
3547 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3550 /* Run all of the selftests within this file. */
3555 test_assign_single ();
3556 test_assign_binop ();
3558 test_return_stmt ();
3559 test_return_without_value ();
3562 } // namespace selftest
3565 #endif /* CHECKING_P */