1 /* Gimple IR support functions.
3 Copyright (C) 2007-2020 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"
50 /* All the tuples have their operand vector (if present) at the very bottom
51 of the structure. Therefore, the offset required to find the
52 operands vector the size of the structure minus the size of the 1
53 element tree array at the end (see gimple_ops). */
54 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
55 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
56 EXPORTED_CONST
size_t gimple_ops_offset_
[] = {
57 #include "gsstruct.def"
61 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
62 static const size_t gsstruct_code_size
[] = {
63 #include "gsstruct.def"
67 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
68 const char *const gimple_code_name
[] = {
73 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
74 EXPORTED_CONST
enum gimple_statement_structure_enum gss_for_code_
[] = {
81 uint64_t gimple_alloc_counts
[(int) gimple_alloc_kind_all
];
82 uint64_t gimple_alloc_sizes
[(int) gimple_alloc_kind_all
];
84 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
85 static const char * const gimple_alloc_kind_names
[] = {
92 /* Static gimple tuple members. */
93 const enum gimple_code
gassign::code_
;
94 const enum gimple_code
gcall::code_
;
95 const enum gimple_code
gcond::code_
;
98 /* Gimple tuple constructors.
99 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
100 be passed a NULL to start with an empty sequence. */
102 /* Set the code for statement G to CODE. */
105 gimple_set_code (gimple
*g
, enum gimple_code code
)
110 /* Return the number of bytes needed to hold a GIMPLE statement with
114 gimple_size (enum gimple_code code
, unsigned num_ops
)
116 size_t size
= gsstruct_code_size
[gss_for_code (code
)];
118 size
+= (sizeof (tree
) * (num_ops
- 1));
122 /* Initialize GIMPLE statement G with CODE and NUM_OPS. */
125 gimple_init (gimple
*g
, enum gimple_code code
, unsigned num_ops
)
127 gimple_set_code (g
, code
);
128 gimple_set_num_ops (g
, num_ops
);
130 /* Do not call gimple_set_modified here as it has other side
131 effects and this tuple is still not completely built. */
133 gimple_init_singleton (g
);
136 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
140 gimple_alloc (enum gimple_code code
, unsigned num_ops MEM_STAT_DECL
)
145 size
= gimple_size (code
, num_ops
);
146 if (GATHER_STATISTICS
)
148 enum gimple_alloc_kind kind
= gimple_alloc_kind (code
);
149 gimple_alloc_counts
[(int) kind
]++;
150 gimple_alloc_sizes
[(int) kind
] += size
;
153 stmt
= ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT
);
154 gimple_init (stmt
, code
, num_ops
);
158 /* Set SUBCODE to be the code of the expression computed by statement G. */
161 gimple_set_subcode (gimple
*g
, unsigned subcode
)
163 /* We only have 16 bits for the RHS code. Assert that we are not
165 gcc_assert (subcode
< (1 << 16));
166 g
->subcode
= subcode
;
171 /* Build a tuple with operands. CODE is the statement to build (which
172 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
173 for the new tuple. NUM_OPS is the number of operands to allocate. */
175 #define gimple_build_with_ops(c, s, n) \
176 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
179 gimple_build_with_ops_stat (enum gimple_code code
, unsigned subcode
,
180 unsigned num_ops MEM_STAT_DECL
)
182 gimple
*s
= gimple_alloc (code
, num_ops PASS_MEM_STAT
);
183 gimple_set_subcode (s
, subcode
);
189 /* Build a GIMPLE_RETURN statement returning RETVAL. */
192 gimple_build_return (tree retval
)
195 = as_a
<greturn
*> (gimple_build_with_ops (GIMPLE_RETURN
, ERROR_MARK
,
198 gimple_return_set_retval (s
, retval
);
202 /* Reset alias information on call S. */
205 gimple_call_reset_alias_info (gcall
*s
)
207 if (gimple_call_flags (s
) & ECF_CONST
)
208 memset (gimple_call_use_set (s
), 0, sizeof (struct pt_solution
));
210 pt_solution_reset (gimple_call_use_set (s
));
211 if (gimple_call_flags (s
) & (ECF_CONST
|ECF_PURE
|ECF_NOVOPS
))
212 memset (gimple_call_clobber_set (s
), 0, sizeof (struct pt_solution
));
214 pt_solution_reset (gimple_call_clobber_set (s
));
217 /* Helper for gimple_build_call, gimple_build_call_valist,
218 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
219 components of a GIMPLE_CALL statement to function FN with NARGS
222 static inline gcall
*
223 gimple_build_call_1 (tree fn
, unsigned nargs
)
226 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
228 if (TREE_CODE (fn
) == FUNCTION_DECL
)
229 fn
= build_fold_addr_expr (fn
);
230 gimple_set_op (s
, 1, fn
);
231 gimple_call_set_fntype (s
, TREE_TYPE (TREE_TYPE (fn
)));
232 gimple_call_reset_alias_info (s
);
237 /* Build a GIMPLE_CALL statement to function FN with the arguments
238 specified in vector ARGS. */
241 gimple_build_call_vec (tree fn
, vec
<tree
> args
)
244 unsigned nargs
= args
.length ();
245 gcall
*call
= gimple_build_call_1 (fn
, nargs
);
247 for (i
= 0; i
< nargs
; i
++)
248 gimple_call_set_arg (call
, i
, args
[i
]);
254 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
255 arguments. The ... are the arguments. */
258 gimple_build_call (tree fn
, unsigned nargs
, ...)
264 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
266 call
= gimple_build_call_1 (fn
, nargs
);
268 va_start (ap
, nargs
);
269 for (i
= 0; i
< nargs
; i
++)
270 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
277 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
278 arguments. AP contains the arguments. */
281 gimple_build_call_valist (tree fn
, unsigned nargs
, va_list ap
)
286 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
288 call
= gimple_build_call_1 (fn
, nargs
);
290 for (i
= 0; i
< nargs
; i
++)
291 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
297 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
298 Build the basic components of a GIMPLE_CALL statement to internal
299 function FN with NARGS arguments. */
301 static inline gcall
*
302 gimple_build_call_internal_1 (enum internal_fn fn
, unsigned nargs
)
305 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
307 s
->subcode
|= GF_CALL_INTERNAL
;
308 gimple_call_set_internal_fn (s
, fn
);
309 gimple_call_reset_alias_info (s
);
314 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
315 the number of arguments. The ... are the arguments. */
318 gimple_build_call_internal (enum internal_fn fn
, unsigned nargs
, ...)
324 call
= gimple_build_call_internal_1 (fn
, nargs
);
325 va_start (ap
, nargs
);
326 for (i
= 0; i
< nargs
; i
++)
327 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
334 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
335 specified in vector ARGS. */
338 gimple_build_call_internal_vec (enum internal_fn fn
, vec
<tree
> args
)
343 nargs
= args
.length ();
344 call
= gimple_build_call_internal_1 (fn
, nargs
);
345 for (i
= 0; i
< nargs
; i
++)
346 gimple_call_set_arg (call
, i
, args
[i
]);
352 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
353 assumed to be in GIMPLE form already. Minimal checking is done of
357 gimple_build_call_from_tree (tree t
, tree fnptrtype
)
362 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
364 nargs
= call_expr_nargs (t
);
366 tree fndecl
= NULL_TREE
;
367 if (CALL_EXPR_FN (t
) == NULL_TREE
)
368 call
= gimple_build_call_internal_1 (CALL_EXPR_IFN (t
), nargs
);
371 fndecl
= get_callee_fndecl (t
);
372 call
= gimple_build_call_1 (fndecl
? fndecl
: CALL_EXPR_FN (t
), nargs
);
375 for (i
= 0; i
< nargs
; i
++)
376 gimple_call_set_arg (call
, i
, CALL_EXPR_ARG (t
, i
));
378 gimple_set_block (call
, TREE_BLOCK (t
));
379 gimple_set_location (call
, EXPR_LOCATION (t
));
381 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
382 gimple_call_set_chain (call
, CALL_EXPR_STATIC_CHAIN (t
));
383 gimple_call_set_tail (call
, CALL_EXPR_TAILCALL (t
));
384 gimple_call_set_must_tail (call
, CALL_EXPR_MUST_TAIL_CALL (t
));
385 gimple_call_set_return_slot_opt (call
, CALL_EXPR_RETURN_SLOT_OPT (t
));
387 && fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
)
388 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl
)))
389 gimple_call_set_alloca_for_var (call
, CALL_ALLOCA_FOR_VAR_P (t
));
391 gimple_call_set_from_thunk (call
, CALL_FROM_THUNK_P (t
));
392 gimple_call_set_va_arg_pack (call
, CALL_EXPR_VA_ARG_PACK (t
));
393 gimple_call_set_nothrow (call
, TREE_NOTHROW (t
));
394 gimple_call_set_by_descriptor (call
, CALL_EXPR_BY_DESCRIPTOR (t
));
395 gimple_set_no_warning (call
, TREE_NO_WARNING (t
));
399 gimple_call_set_fntype (call
, TREE_TYPE (fnptrtype
));
401 /* Check if it's an indirect CALL and the type has the
402 nocf_check attribute. In that case propagate the information
403 to the gimple CALL insn. */
406 gcc_assert (POINTER_TYPE_P (fnptrtype
));
407 tree fntype
= TREE_TYPE (fnptrtype
);
409 if (lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (fntype
)))
410 gimple_call_set_nocf_check (call
, TRUE
);
418 /* Build a GIMPLE_ASSIGN statement.
420 LHS of the assignment.
421 RHS of the assignment which can be unary or binary. */
424 gimple_build_assign (tree lhs
, tree rhs MEM_STAT_DECL
)
426 enum tree_code subcode
;
429 extract_ops_from_tree (rhs
, &subcode
, &op1
, &op2
, &op3
);
430 return gimple_build_assign (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
434 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
437 static inline gassign
*
438 gimple_build_assign_1 (tree lhs
, enum tree_code subcode
, tree op1
,
439 tree op2
, tree op3 MEM_STAT_DECL
)
444 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
446 num_ops
= get_gimple_rhs_num_ops (subcode
) + 1;
448 p
= as_a
<gassign
*> (
449 gimple_build_with_ops_stat (GIMPLE_ASSIGN
, (unsigned)subcode
, num_ops
451 gimple_assign_set_lhs (p
, lhs
);
452 gimple_assign_set_rhs1 (p
, op1
);
455 gcc_assert (num_ops
> 2);
456 gimple_assign_set_rhs2 (p
, op2
);
461 gcc_assert (num_ops
> 3);
462 gimple_assign_set_rhs3 (p
, op3
);
468 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
472 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
473 tree op2
, tree op3 MEM_STAT_DECL
)
475 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
478 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
482 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
483 tree op2 MEM_STAT_DECL
)
485 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, NULL_TREE
489 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
492 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1 MEM_STAT_DECL
)
494 return gimple_build_assign_1 (lhs
, subcode
, op1
, NULL_TREE
, NULL_TREE
499 /* Build a GIMPLE_COND statement.
501 PRED is the condition used to compare LHS and the RHS.
502 T_LABEL is the label to jump to if the condition is true.
503 F_LABEL is the label to jump to otherwise. */
506 gimple_build_cond (enum tree_code pred_code
, tree lhs
, tree rhs
,
507 tree t_label
, tree f_label
)
511 gcc_assert (TREE_CODE_CLASS (pred_code
) == tcc_comparison
);
512 p
= as_a
<gcond
*> (gimple_build_with_ops (GIMPLE_COND
, pred_code
, 4));
513 gimple_cond_set_lhs (p
, lhs
);
514 gimple_cond_set_rhs (p
, rhs
);
515 gimple_cond_set_true_label (p
, t_label
);
516 gimple_cond_set_false_label (p
, f_label
);
520 /* Build a GIMPLE_COND statement from the conditional expression tree
521 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
524 gimple_build_cond_from_tree (tree cond
, tree t_label
, tree f_label
)
529 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
530 return gimple_build_cond (code
, lhs
, rhs
, t_label
, f_label
);
533 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
534 boolean expression tree COND. */
537 gimple_cond_set_condition_from_tree (gcond
*stmt
, tree cond
)
542 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
543 gimple_cond_set_condition (stmt
, code
, lhs
, rhs
);
546 /* Build a GIMPLE_LABEL statement for LABEL. */
549 gimple_build_label (tree label
)
552 = as_a
<glabel
*> (gimple_build_with_ops (GIMPLE_LABEL
, ERROR_MARK
, 1));
553 gimple_label_set_label (p
, label
);
557 /* Build a GIMPLE_GOTO statement to label DEST. */
560 gimple_build_goto (tree dest
)
563 = as_a
<ggoto
*> (gimple_build_with_ops (GIMPLE_GOTO
, ERROR_MARK
, 1));
564 gimple_goto_set_dest (p
, dest
);
569 /* Build a GIMPLE_NOP statement. */
572 gimple_build_nop (void)
574 return gimple_alloc (GIMPLE_NOP
, 0);
578 /* Build a GIMPLE_BIND statement.
579 VARS are the variables in BODY.
580 BLOCK is the containing block. */
583 gimple_build_bind (tree vars
, gimple_seq body
, tree block
)
585 gbind
*p
= as_a
<gbind
*> (gimple_alloc (GIMPLE_BIND
, 0));
586 gimple_bind_set_vars (p
, vars
);
588 gimple_bind_set_body (p
, body
);
590 gimple_bind_set_block (p
, block
);
594 /* Helper function to set the simple fields of a asm stmt.
596 STRING is a pointer to a string that is the asm blocks assembly code.
597 NINPUT is the number of register inputs.
598 NOUTPUT is the number of register outputs.
599 NCLOBBERS is the number of clobbered registers.
603 gimple_build_asm_1 (const char *string
, unsigned ninputs
, unsigned noutputs
,
604 unsigned nclobbers
, unsigned nlabels
)
607 int size
= strlen (string
);
609 /* ASMs with labels cannot have outputs. This should have been
610 enforced by the front end. */
611 gcc_assert (nlabels
== 0 || noutputs
== 0);
614 gimple_build_with_ops (GIMPLE_ASM
, ERROR_MARK
,
615 ninputs
+ noutputs
+ nclobbers
+ nlabels
));
621 p
->string
= ggc_alloc_string (string
, size
);
623 if (GATHER_STATISTICS
)
624 gimple_alloc_sizes
[(int) gimple_alloc_kind (GIMPLE_ASM
)] += size
;
629 /* Build a GIMPLE_ASM statement.
631 STRING is the assembly code.
632 NINPUT is the number of register inputs.
633 NOUTPUT is the number of register outputs.
634 NCLOBBERS is the number of clobbered registers.
635 INPUTS is a vector of the input register parameters.
636 OUTPUTS is a vector of the output register parameters.
637 CLOBBERS is a vector of the clobbered register parameters.
638 LABELS is a vector of destination labels. */
641 gimple_build_asm_vec (const char *string
, vec
<tree
, va_gc
> *inputs
,
642 vec
<tree
, va_gc
> *outputs
, vec
<tree
, va_gc
> *clobbers
,
643 vec
<tree
, va_gc
> *labels
)
648 p
= gimple_build_asm_1 (string
,
649 vec_safe_length (inputs
),
650 vec_safe_length (outputs
),
651 vec_safe_length (clobbers
),
652 vec_safe_length (labels
));
654 for (i
= 0; i
< vec_safe_length (inputs
); i
++)
655 gimple_asm_set_input_op (p
, i
, (*inputs
)[i
]);
657 for (i
= 0; i
< vec_safe_length (outputs
); i
++)
658 gimple_asm_set_output_op (p
, i
, (*outputs
)[i
]);
660 for (i
= 0; i
< vec_safe_length (clobbers
); i
++)
661 gimple_asm_set_clobber_op (p
, i
, (*clobbers
)[i
]);
663 for (i
= 0; i
< vec_safe_length (labels
); i
++)
664 gimple_asm_set_label_op (p
, i
, (*labels
)[i
]);
669 /* Build a GIMPLE_CATCH statement.
671 TYPES are the catch types.
672 HANDLER is the exception handler. */
675 gimple_build_catch (tree types
, gimple_seq handler
)
677 gcatch
*p
= as_a
<gcatch
*> (gimple_alloc (GIMPLE_CATCH
, 0));
678 gimple_catch_set_types (p
, types
);
680 gimple_catch_set_handler (p
, handler
);
685 /* Build a GIMPLE_EH_FILTER statement.
687 TYPES are the filter's types.
688 FAILURE is the filter's failure action. */
691 gimple_build_eh_filter (tree types
, gimple_seq failure
)
693 geh_filter
*p
= as_a
<geh_filter
*> (gimple_alloc (GIMPLE_EH_FILTER
, 0));
694 gimple_eh_filter_set_types (p
, types
);
696 gimple_eh_filter_set_failure (p
, failure
);
701 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
704 gimple_build_eh_must_not_throw (tree decl
)
706 geh_mnt
*p
= as_a
<geh_mnt
*> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW
, 0));
708 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
709 gcc_assert (flags_from_decl_or_type (decl
) & ECF_NORETURN
);
710 gimple_eh_must_not_throw_set_fndecl (p
, decl
);
715 /* Build a GIMPLE_EH_ELSE statement. */
718 gimple_build_eh_else (gimple_seq n_body
, gimple_seq e_body
)
720 geh_else
*p
= as_a
<geh_else
*> (gimple_alloc (GIMPLE_EH_ELSE
, 0));
721 gimple_eh_else_set_n_body (p
, n_body
);
722 gimple_eh_else_set_e_body (p
, e_body
);
726 /* Build a GIMPLE_TRY statement.
728 EVAL is the expression to evaluate.
729 CLEANUP is the cleanup expression.
730 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
731 whether this is a try/catch or a try/finally respectively. */
734 gimple_build_try (gimple_seq eval
, gimple_seq cleanup
,
735 enum gimple_try_flags kind
)
739 gcc_assert (kind
== GIMPLE_TRY_CATCH
|| kind
== GIMPLE_TRY_FINALLY
);
740 p
= as_a
<gtry
*> (gimple_alloc (GIMPLE_TRY
, 0));
741 gimple_set_subcode (p
, kind
);
743 gimple_try_set_eval (p
, eval
);
745 gimple_try_set_cleanup (p
, cleanup
);
750 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
752 CLEANUP is the cleanup expression. */
755 gimple_build_wce (gimple_seq cleanup
)
757 gimple
*p
= gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR
, 0);
759 gimple_wce_set_cleanup (p
, cleanup
);
765 /* Build a GIMPLE_RESX statement. */
768 gimple_build_resx (int region
)
771 = as_a
<gresx
*> (gimple_build_with_ops (GIMPLE_RESX
, ERROR_MARK
, 0));
777 /* The helper for constructing a gimple switch statement.
778 INDEX is the switch's index.
779 NLABELS is the number of labels in the switch excluding the default.
780 DEFAULT_LABEL is the default label for the switch statement. */
783 gimple_build_switch_nlabels (unsigned nlabels
, tree index
, tree default_label
)
785 /* nlabels + 1 default label + 1 index. */
786 gcc_checking_assert (default_label
);
787 gswitch
*p
= as_a
<gswitch
*> (gimple_build_with_ops (GIMPLE_SWITCH
,
790 gimple_switch_set_index (p
, index
);
791 gimple_switch_set_default_label (p
, default_label
);
795 /* Build a GIMPLE_SWITCH statement.
797 INDEX is the switch's index.
798 DEFAULT_LABEL is the default label
799 ARGS is a vector of labels excluding the default. */
802 gimple_build_switch (tree index
, tree default_label
, vec
<tree
> args
)
804 unsigned i
, nlabels
= args
.length ();
806 gswitch
*p
= gimple_build_switch_nlabels (nlabels
, index
, default_label
);
808 /* Copy the labels from the vector to the switch statement. */
809 for (i
= 0; i
< nlabels
; i
++)
810 gimple_switch_set_label (p
, i
+ 1, args
[i
]);
815 /* Build a GIMPLE_EH_DISPATCH statement. */
818 gimple_build_eh_dispatch (int region
)
821 = as_a
<geh_dispatch
*> (
822 gimple_build_with_ops (GIMPLE_EH_DISPATCH
, ERROR_MARK
, 0));
827 /* Build a new GIMPLE_DEBUG_BIND statement.
829 VAR is bound to VALUE; block and location are taken from STMT. */
832 gimple_build_debug_bind (tree var
, tree value
, gimple
*stmt MEM_STAT_DECL
)
835 = as_a
<gdebug
*> (gimple_build_with_ops_stat (GIMPLE_DEBUG
,
836 (unsigned)GIMPLE_DEBUG_BIND
, 2
838 gimple_debug_bind_set_var (p
, var
);
839 gimple_debug_bind_set_value (p
, value
);
841 gimple_set_location (p
, gimple_location (stmt
));
847 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
849 VAR is bound to VALUE; block and location are taken from STMT. */
852 gimple_build_debug_source_bind (tree var
, tree value
,
853 gimple
*stmt MEM_STAT_DECL
)
857 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
858 (unsigned)GIMPLE_DEBUG_SOURCE_BIND
, 2
861 gimple_debug_source_bind_set_var (p
, var
);
862 gimple_debug_source_bind_set_value (p
, value
);
864 gimple_set_location (p
, gimple_location (stmt
));
870 /* Build a new GIMPLE_DEBUG_BEGIN_STMT statement in BLOCK at
874 gimple_build_debug_begin_stmt (tree block
, location_t location
879 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
880 (unsigned)GIMPLE_DEBUG_BEGIN_STMT
, 0
883 gimple_set_location (p
, location
);
884 gimple_set_block (p
, block
);
885 cfun
->debug_marker_count
++;
891 /* Build a new GIMPLE_DEBUG_INLINE_ENTRY statement in BLOCK at
892 LOCATION. The BLOCK links to the inlined function. */
895 gimple_build_debug_inline_entry (tree block
, location_t location
900 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
901 (unsigned)GIMPLE_DEBUG_INLINE_ENTRY
, 0
904 gimple_set_location (p
, location
);
905 gimple_set_block (p
, block
);
906 cfun
->debug_marker_count
++;
912 /* Build a GIMPLE_OMP_CRITICAL statement.
914 BODY is the sequence of statements for which only one thread can execute.
915 NAME is optional identifier for this critical block.
916 CLAUSES are clauses for this critical block. */
919 gimple_build_omp_critical (gimple_seq body
, tree name
, tree clauses
)
922 = as_a
<gomp_critical
*> (gimple_alloc (GIMPLE_OMP_CRITICAL
, 0));
923 gimple_omp_critical_set_name (p
, name
);
924 gimple_omp_critical_set_clauses (p
, clauses
);
926 gimple_omp_set_body (p
, body
);
931 /* Build a GIMPLE_OMP_FOR statement.
933 BODY is sequence of statements inside the for loop.
934 KIND is the `for' variant.
935 CLAUSES are any of the construct's clauses.
936 COLLAPSE is the collapse count.
937 PRE_BODY is the sequence of statements that are loop invariant. */
940 gimple_build_omp_for (gimple_seq body
, int kind
, tree clauses
, size_t collapse
,
943 gomp_for
*p
= as_a
<gomp_for
*> (gimple_alloc (GIMPLE_OMP_FOR
, 0));
945 gimple_omp_set_body (p
, body
);
946 gimple_omp_for_set_clauses (p
, clauses
);
947 gimple_omp_for_set_kind (p
, kind
);
948 p
->collapse
= collapse
;
949 p
->iter
= ggc_cleared_vec_alloc
<gimple_omp_for_iter
> (collapse
);
952 gimple_omp_for_set_pre_body (p
, pre_body
);
958 /* Build a GIMPLE_OMP_PARALLEL statement.
960 BODY is sequence of statements which are executed in parallel.
961 CLAUSES are the OMP parallel construct's clauses.
962 CHILD_FN is the function created for the parallel threads to execute.
963 DATA_ARG are the shared data argument(s). */
966 gimple_build_omp_parallel (gimple_seq body
, tree clauses
, tree child_fn
,
970 = as_a
<gomp_parallel
*> (gimple_alloc (GIMPLE_OMP_PARALLEL
, 0));
972 gimple_omp_set_body (p
, body
);
973 gimple_omp_parallel_set_clauses (p
, clauses
);
974 gimple_omp_parallel_set_child_fn (p
, child_fn
);
975 gimple_omp_parallel_set_data_arg (p
, data_arg
);
981 /* Build a GIMPLE_OMP_TASK statement.
983 BODY is sequence of statements which are executed by the explicit task.
984 CLAUSES are the OMP task construct's clauses.
985 CHILD_FN is the function created for the parallel threads to execute.
986 DATA_ARG are the shared data argument(s).
987 COPY_FN is the optional function for firstprivate initialization.
988 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
991 gimple_build_omp_task (gimple_seq body
, tree clauses
, tree child_fn
,
992 tree data_arg
, tree copy_fn
, tree arg_size
,
995 gomp_task
*p
= as_a
<gomp_task
*> (gimple_alloc (GIMPLE_OMP_TASK
, 0));
997 gimple_omp_set_body (p
, body
);
998 gimple_omp_task_set_clauses (p
, clauses
);
999 gimple_omp_task_set_child_fn (p
, child_fn
);
1000 gimple_omp_task_set_data_arg (p
, data_arg
);
1001 gimple_omp_task_set_copy_fn (p
, copy_fn
);
1002 gimple_omp_task_set_arg_size (p
, arg_size
);
1003 gimple_omp_task_set_arg_align (p
, arg_align
);
1009 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
1011 BODY is the sequence of statements in the section. */
1014 gimple_build_omp_section (gimple_seq body
)
1016 gimple
*p
= gimple_alloc (GIMPLE_OMP_SECTION
, 0);
1018 gimple_omp_set_body (p
, body
);
1024 /* Build a GIMPLE_OMP_MASTER statement.
1026 BODY is the sequence of statements to be executed by just the master. */
1029 gimple_build_omp_master (gimple_seq body
)
1031 gimple
*p
= gimple_alloc (GIMPLE_OMP_MASTER
, 0);
1033 gimple_omp_set_body (p
, body
);
1038 /* Build a GIMPLE_OMP_TASKGROUP statement.
1040 BODY is the sequence of statements to be executed by the taskgroup
1042 CLAUSES are any of the construct's clauses. */
1045 gimple_build_omp_taskgroup (gimple_seq body
, tree clauses
)
1047 gimple
*p
= gimple_alloc (GIMPLE_OMP_TASKGROUP
, 0);
1048 gimple_omp_taskgroup_set_clauses (p
, clauses
);
1050 gimple_omp_set_body (p
, body
);
1056 /* Build a GIMPLE_OMP_CONTINUE statement.
1058 CONTROL_DEF is the definition of the control variable.
1059 CONTROL_USE is the use of the control variable. */
1062 gimple_build_omp_continue (tree control_def
, tree control_use
)
1065 = as_a
<gomp_continue
*> (gimple_alloc (GIMPLE_OMP_CONTINUE
, 0));
1066 gimple_omp_continue_set_control_def (p
, control_def
);
1067 gimple_omp_continue_set_control_use (p
, control_use
);
1071 /* Build a GIMPLE_OMP_ORDERED statement.
1073 BODY is the sequence of statements inside a loop that will executed in
1075 CLAUSES are clauses for this statement. */
1078 gimple_build_omp_ordered (gimple_seq body
, tree clauses
)
1081 = as_a
<gomp_ordered
*> (gimple_alloc (GIMPLE_OMP_ORDERED
, 0));
1082 gimple_omp_ordered_set_clauses (p
, clauses
);
1084 gimple_omp_set_body (p
, body
);
1090 /* Build a GIMPLE_OMP_RETURN statement.
1091 WAIT_P is true if this is a non-waiting return. */
1094 gimple_build_omp_return (bool wait_p
)
1096 gimple
*p
= gimple_alloc (GIMPLE_OMP_RETURN
, 0);
1098 gimple_omp_return_set_nowait (p
);
1104 /* Build a GIMPLE_OMP_SCAN statement.
1106 BODY is the sequence of statements to be executed by the scan
1108 CLAUSES are any of the construct's clauses. */
1111 gimple_build_omp_scan (gimple_seq body
, tree clauses
)
1114 = as_a
<gomp_scan
*> (gimple_alloc (GIMPLE_OMP_SCAN
, 0));
1115 gimple_omp_scan_set_clauses (p
, clauses
);
1117 gimple_omp_set_body (p
, body
);
1123 /* Build a GIMPLE_OMP_SECTIONS statement.
1125 BODY is a sequence of section statements.
1126 CLAUSES are any of the OMP sections contsruct's clauses: private,
1127 firstprivate, lastprivate, reduction, and nowait. */
1130 gimple_build_omp_sections (gimple_seq body
, tree clauses
)
1133 = as_a
<gomp_sections
*> (gimple_alloc (GIMPLE_OMP_SECTIONS
, 0));
1135 gimple_omp_set_body (p
, body
);
1136 gimple_omp_sections_set_clauses (p
, clauses
);
1142 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1145 gimple_build_omp_sections_switch (void)
1147 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH
, 0);
1151 /* Build a GIMPLE_OMP_SINGLE statement.
1153 BODY is the sequence of statements that will be executed once.
1154 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1155 copyprivate, nowait. */
1158 gimple_build_omp_single (gimple_seq body
, tree clauses
)
1161 = as_a
<gomp_single
*> (gimple_alloc (GIMPLE_OMP_SINGLE
, 0));
1163 gimple_omp_set_body (p
, body
);
1164 gimple_omp_single_set_clauses (p
, clauses
);
1170 /* Build a GIMPLE_OMP_TARGET statement.
1172 BODY is the sequence of statements that will be executed.
1173 KIND is the kind of the region.
1174 CLAUSES are any of the construct's clauses. */
1177 gimple_build_omp_target (gimple_seq body
, int kind
, tree clauses
)
1180 = as_a
<gomp_target
*> (gimple_alloc (GIMPLE_OMP_TARGET
, 0));
1182 gimple_omp_set_body (p
, body
);
1183 gimple_omp_target_set_clauses (p
, clauses
);
1184 gimple_omp_target_set_kind (p
, kind
);
1190 /* Build a GIMPLE_OMP_TEAMS statement.
1192 BODY is the sequence of statements that will be executed.
1193 CLAUSES are any of the OMP teams construct's clauses. */
1196 gimple_build_omp_teams (gimple_seq body
, tree clauses
)
1198 gomp_teams
*p
= as_a
<gomp_teams
*> (gimple_alloc (GIMPLE_OMP_TEAMS
, 0));
1200 gimple_omp_set_body (p
, body
);
1201 gimple_omp_teams_set_clauses (p
, clauses
);
1207 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1210 gimple_build_omp_atomic_load (tree lhs
, tree rhs
, enum omp_memory_order mo
)
1213 = as_a
<gomp_atomic_load
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD
, 0));
1214 gimple_omp_atomic_load_set_lhs (p
, lhs
);
1215 gimple_omp_atomic_load_set_rhs (p
, rhs
);
1216 gimple_omp_atomic_set_memory_order (p
, mo
);
1220 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1222 VAL is the value we are storing. */
1225 gimple_build_omp_atomic_store (tree val
, enum omp_memory_order mo
)
1227 gomp_atomic_store
*p
1228 = as_a
<gomp_atomic_store
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE
, 0));
1229 gimple_omp_atomic_store_set_val (p
, val
);
1230 gimple_omp_atomic_set_memory_order (p
, mo
);
1234 /* Build a GIMPLE_TRANSACTION statement. */
1237 gimple_build_transaction (gimple_seq body
)
1240 = as_a
<gtransaction
*> (gimple_alloc (GIMPLE_TRANSACTION
, 0));
1241 gimple_transaction_set_body (p
, body
);
1242 gimple_transaction_set_label_norm (p
, 0);
1243 gimple_transaction_set_label_uninst (p
, 0);
1244 gimple_transaction_set_label_over (p
, 0);
1248 #if defined ENABLE_GIMPLE_CHECKING
1249 /* Complain of a gimple type mismatch and die. */
1252 gimple_check_failed (const gimple
*gs
, const char *file
, int line
,
1253 const char *function
, enum gimple_code code
,
1254 enum tree_code subcode
)
1256 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1257 gimple_code_name
[code
],
1258 get_tree_code_name (subcode
),
1259 gimple_code_name
[gimple_code (gs
)],
1261 ? get_tree_code_name ((enum tree_code
) gs
->subcode
)
1263 function
, trim_filename (file
), line
);
1265 #endif /* ENABLE_GIMPLE_CHECKING */
1268 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1269 *SEQ_P is NULL, a new sequence is allocated. */
1272 gimple_seq_add_stmt (gimple_seq
*seq_p
, gimple
*gs
)
1274 gimple_stmt_iterator si
;
1278 si
= gsi_last (*seq_p
);
1279 gsi_insert_after (&si
, gs
, GSI_NEW_STMT
);
1282 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1283 *SEQ_P is NULL, a new sequence is allocated. This function is
1284 similar to gimple_seq_add_stmt, but does not scan the operands.
1285 During gimplification, we need to manipulate statement sequences
1286 before the def/use vectors have been constructed. */
1289 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple
*gs
)
1291 gimple_stmt_iterator si
;
1296 si
= gsi_last (*seq_p
);
1297 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
1300 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1301 NULL, a new sequence is allocated. */
1304 gimple_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
1306 gimple_stmt_iterator si
;
1310 si
= gsi_last (*dst_p
);
1311 gsi_insert_seq_after (&si
, src
, GSI_NEW_STMT
);
1314 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1315 NULL, a new sequence is allocated. This function is
1316 similar to gimple_seq_add_seq, but does not scan the operands. */
1319 gimple_seq_add_seq_without_update (gimple_seq
*dst_p
, gimple_seq src
)
1321 gimple_stmt_iterator si
;
1325 si
= gsi_last (*dst_p
);
1326 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
1329 /* Determine whether to assign a location to the statement GS. */
1332 should_carry_location_p (gimple
*gs
)
1334 /* Don't emit a line note for a label. We particularly don't want to
1335 emit one for the break label, since it doesn't actually correspond
1336 to the beginning of the loop/switch. */
1337 if (gimple_code (gs
) == GIMPLE_LABEL
)
1343 /* Set the location for gimple statement GS to LOCATION. */
1346 annotate_one_with_location (gimple
*gs
, location_t location
)
1348 if (!gimple_has_location (gs
)
1349 && !gimple_do_not_emit_location_p (gs
)
1350 && should_carry_location_p (gs
))
1351 gimple_set_location (gs
, location
);
1354 /* Set LOCATION for all the statements after iterator GSI in sequence
1355 SEQ. If GSI is pointing to the end of the sequence, start with the
1356 first statement in SEQ. */
1359 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
1360 location_t location
)
1362 if (gsi_end_p (gsi
))
1363 gsi
= gsi_start (seq
);
1367 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
1368 annotate_one_with_location (gsi_stmt (gsi
), location
);
1371 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1374 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
1376 gimple_stmt_iterator i
;
1378 if (gimple_seq_empty_p (stmt_p
))
1381 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
1383 gimple
*gs
= gsi_stmt (i
);
1384 annotate_one_with_location (gs
, location
);
1388 /* Helper function of empty_body_p. Return true if STMT is an empty
1392 empty_stmt_p (gimple
*stmt
)
1394 if (gimple_code (stmt
) == GIMPLE_NOP
)
1396 if (gbind
*bind_stmt
= dyn_cast
<gbind
*> (stmt
))
1397 return empty_body_p (gimple_bind_body (bind_stmt
));
1402 /* Return true if BODY contains nothing but empty statements. */
1405 empty_body_p (gimple_seq body
)
1407 gimple_stmt_iterator i
;
1409 if (gimple_seq_empty_p (body
))
1411 for (i
= gsi_start (body
); !gsi_end_p (i
); gsi_next (&i
))
1412 if (!empty_stmt_p (gsi_stmt (i
))
1413 && !is_gimple_debug (gsi_stmt (i
)))
1420 /* Perform a deep copy of sequence SRC and return the result. */
1423 gimple_seq_copy (gimple_seq src
)
1425 gimple_stmt_iterator gsi
;
1426 gimple_seq new_seq
= NULL
;
1429 for (gsi
= gsi_start (src
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1431 stmt
= gimple_copy (gsi_stmt (gsi
));
1432 gimple_seq_add_stmt (&new_seq
, stmt
);
1440 /* Return true if calls C1 and C2 are known to go to the same function. */
1443 gimple_call_same_target_p (const gimple
*c1
, const gimple
*c2
)
1445 if (gimple_call_internal_p (c1
))
1446 return (gimple_call_internal_p (c2
)
1447 && gimple_call_internal_fn (c1
) == gimple_call_internal_fn (c2
)
1448 && (!gimple_call_internal_unique_p (as_a
<const gcall
*> (c1
))
1451 return (gimple_call_fn (c1
) == gimple_call_fn (c2
)
1452 || (gimple_call_fndecl (c1
)
1453 && gimple_call_fndecl (c1
) == gimple_call_fndecl (c2
)));
1456 /* Detect flags from a GIMPLE_CALL. This is just like
1457 call_expr_flags, but for gimple tuples. */
1460 gimple_call_flags (const gimple
*stmt
)
1464 if (gimple_call_internal_p (stmt
))
1465 flags
= internal_fn_flags (gimple_call_internal_fn (stmt
));
1468 tree decl
= gimple_call_fndecl (stmt
);
1470 flags
= flags_from_decl_or_type (decl
);
1471 flags
|= flags_from_decl_or_type (gimple_call_fntype (stmt
));
1474 if (stmt
->subcode
& GF_CALL_NOTHROW
)
1475 flags
|= ECF_NOTHROW
;
1477 if (stmt
->subcode
& GF_CALL_BY_DESCRIPTOR
)
1478 flags
|= ECF_BY_DESCRIPTOR
;
1483 /* Return the "fn spec" string for call STMT. */
1486 gimple_call_fnspec (const gcall
*stmt
)
1490 if (gimple_call_internal_p (stmt
))
1491 return internal_fn_fnspec (gimple_call_internal_fn (stmt
));
1493 type
= gimple_call_fntype (stmt
);
1497 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
1501 return TREE_VALUE (TREE_VALUE (attr
));
1504 /* Detects argument flags for argument number ARG on call STMT. */
1507 gimple_call_arg_flags (const gcall
*stmt
, unsigned arg
)
1509 const_tree attr
= gimple_call_fnspec (stmt
);
1511 if (!attr
|| 1 + arg
>= (unsigned) TREE_STRING_LENGTH (attr
))
1514 switch (TREE_STRING_POINTER (attr
)[1 + arg
])
1521 return EAF_DIRECT
| EAF_NOCLOBBER
| EAF_NOESCAPE
;
1524 return EAF_NOCLOBBER
| EAF_NOESCAPE
;
1527 return EAF_DIRECT
| EAF_NOESCAPE
;
1530 return EAF_NOESCAPE
;
1538 /* Detects return flags for the call STMT. */
1541 gimple_call_return_flags (const gcall
*stmt
)
1545 if (gimple_call_flags (stmt
) & ECF_MALLOC
)
1548 attr
= gimple_call_fnspec (stmt
);
1549 if (!attr
|| TREE_STRING_LENGTH (attr
) < 1)
1552 switch (TREE_STRING_POINTER (attr
)[0])
1558 return ERF_RETURNS_ARG
| (TREE_STRING_POINTER (attr
)[0] - '1');
1570 /* Return true if call STMT is known to return a non-zero result. */
1573 gimple_call_nonnull_result_p (gcall
*call
)
1575 tree fndecl
= gimple_call_fndecl (call
);
1578 if (flag_delete_null_pointer_checks
&& !flag_check_new
1579 && DECL_IS_OPERATOR_NEW_P (fndecl
)
1580 && !TREE_NOTHROW (fndecl
))
1583 /* References are always non-NULL. */
1584 if (flag_delete_null_pointer_checks
1585 && TREE_CODE (TREE_TYPE (fndecl
)) == REFERENCE_TYPE
)
1588 if (flag_delete_null_pointer_checks
1589 && lookup_attribute ("returns_nonnull",
1590 TYPE_ATTRIBUTES (gimple_call_fntype (call
))))
1592 return gimple_alloca_call_p (call
);
1596 /* If CALL returns a non-null result in an argument, return that arg. */
1599 gimple_call_nonnull_arg (gcall
*call
)
1601 tree fndecl
= gimple_call_fndecl (call
);
1605 unsigned rf
= gimple_call_return_flags (call
);
1606 if (rf
& ERF_RETURNS_ARG
)
1608 unsigned argnum
= rf
& ERF_RETURN_ARG_MASK
;
1609 if (argnum
< gimple_call_num_args (call
))
1611 tree arg
= gimple_call_arg (call
, argnum
);
1613 && infer_nonnull_range_by_attribute (call
, arg
))
1621 /* Return true if GS is a copy assignment. */
1624 gimple_assign_copy_p (gimple
*gs
)
1626 return (gimple_assign_single_p (gs
)
1627 && is_gimple_val (gimple_op (gs
, 1)));
1631 /* Return true if GS is a SSA_NAME copy assignment. */
1634 gimple_assign_ssa_name_copy_p (gimple
*gs
)
1636 return (gimple_assign_single_p (gs
)
1637 && TREE_CODE (gimple_assign_lhs (gs
)) == SSA_NAME
1638 && TREE_CODE (gimple_assign_rhs1 (gs
)) == SSA_NAME
);
1642 /* Return true if GS is an assignment with a unary RHS, but the
1643 operator has no effect on the assigned value. The logic is adapted
1644 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1645 instances in which STRIP_NOPS was previously applied to the RHS of
1648 NOTE: In the use cases that led to the creation of this function
1649 and of gimple_assign_single_p, it is typical to test for either
1650 condition and to proceed in the same manner. In each case, the
1651 assigned value is represented by the single RHS operand of the
1652 assignment. I suspect there may be cases where gimple_assign_copy_p,
1653 gimple_assign_single_p, or equivalent logic is used where a similar
1654 treatment of unary NOPs is appropriate. */
1657 gimple_assign_unary_nop_p (gimple
*gs
)
1659 return (is_gimple_assign (gs
)
1660 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs
))
1661 || gimple_assign_rhs_code (gs
) == NON_LVALUE_EXPR
)
1662 && gimple_assign_rhs1 (gs
) != error_mark_node
1663 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs
)))
1664 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs
)))));
1667 /* Set BB to be the basic block holding G. */
1670 gimple_set_bb (gimple
*stmt
, basic_block bb
)
1674 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1677 /* If the statement is a label, add the label to block-to-labels map
1678 so that we can speed up edge creation for GIMPLE_GOTOs. */
1684 t
= gimple_label_label (as_a
<glabel
*> (stmt
));
1685 uid
= LABEL_DECL_UID (t
);
1689 vec_safe_length (label_to_block_map_for_fn (cfun
));
1690 LABEL_DECL_UID (t
) = uid
= cfun
->cfg
->last_label_uid
++;
1691 if (old_len
<= (unsigned) uid
)
1693 unsigned new_len
= 3 * uid
/ 2 + 1;
1695 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun
),
1700 (*label_to_block_map_for_fn (cfun
))[uid
] = bb
;
1705 /* Modify the RHS of the assignment pointed-to by GSI using the
1706 operands in the expression tree EXPR.
1708 NOTE: The statement pointed-to by GSI may be reallocated if it
1709 did not have enough operand slots.
1711 This function is useful to convert an existing tree expression into
1712 the flat representation used for the RHS of a GIMPLE assignment.
1713 It will reallocate memory as needed to expand or shrink the number
1714 of operand slots needed to represent EXPR.
1716 NOTE: If you find yourself building a tree and then calling this
1717 function, you are most certainly doing it the slow way. It is much
1718 better to build a new assignment or to use the function
1719 gimple_assign_set_rhs_with_ops, which does not require an
1720 expression tree to be built. */
1723 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*gsi
, tree expr
)
1725 enum tree_code subcode
;
1728 extract_ops_from_tree (expr
, &subcode
, &op1
, &op2
, &op3
);
1729 gimple_assign_set_rhs_with_ops (gsi
, subcode
, op1
, op2
, op3
);
1733 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1734 operands OP1, OP2 and OP3.
1736 NOTE: The statement pointed-to by GSI may be reallocated if it
1737 did not have enough operand slots. */
1740 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*gsi
, enum tree_code code
,
1741 tree op1
, tree op2
, tree op3
)
1743 unsigned new_rhs_ops
= get_gimple_rhs_num_ops (code
);
1744 gimple
*stmt
= gsi_stmt (*gsi
);
1745 gimple
*old_stmt
= stmt
;
1747 /* If the new CODE needs more operands, allocate a new statement. */
1748 if (gimple_num_ops (stmt
) < new_rhs_ops
+ 1)
1750 tree lhs
= gimple_assign_lhs (old_stmt
);
1751 stmt
= gimple_alloc (gimple_code (old_stmt
), new_rhs_ops
+ 1);
1752 memcpy (stmt
, old_stmt
, gimple_size (gimple_code (old_stmt
)));
1753 gimple_init_singleton (stmt
);
1755 /* The LHS needs to be reset as this also changes the SSA name
1757 gimple_assign_set_lhs (stmt
, lhs
);
1760 gimple_set_num_ops (stmt
, new_rhs_ops
+ 1);
1761 gimple_set_subcode (stmt
, code
);
1762 gimple_assign_set_rhs1 (stmt
, op1
);
1763 if (new_rhs_ops
> 1)
1764 gimple_assign_set_rhs2 (stmt
, op2
);
1765 if (new_rhs_ops
> 2)
1766 gimple_assign_set_rhs3 (stmt
, op3
);
1767 if (stmt
!= old_stmt
)
1768 gsi_replace (gsi
, stmt
, false);
1772 /* Return the LHS of a statement that performs an assignment,
1773 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1774 for a call to a function that returns no value, or for a
1775 statement other than an assignment or a call. */
1778 gimple_get_lhs (const gimple
*stmt
)
1780 enum gimple_code code
= gimple_code (stmt
);
1782 if (code
== GIMPLE_ASSIGN
)
1783 return gimple_assign_lhs (stmt
);
1784 else if (code
== GIMPLE_CALL
)
1785 return gimple_call_lhs (stmt
);
1786 else if (code
== GIMPLE_PHI
)
1787 return gimple_phi_result (stmt
);
1793 /* Set the LHS of a statement that performs an assignment,
1794 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1797 gimple_set_lhs (gimple
*stmt
, tree lhs
)
1799 enum gimple_code code
= gimple_code (stmt
);
1801 if (code
== GIMPLE_ASSIGN
)
1802 gimple_assign_set_lhs (stmt
, lhs
);
1803 else if (code
== GIMPLE_CALL
)
1804 gimple_call_set_lhs (stmt
, lhs
);
1810 /* Return a deep copy of statement STMT. All the operands from STMT
1811 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1812 and VUSE operand arrays are set to empty in the new copy. The new
1813 copy isn't part of any sequence. */
1816 gimple_copy (gimple
*stmt
)
1818 enum gimple_code code
= gimple_code (stmt
);
1819 unsigned num_ops
= gimple_num_ops (stmt
);
1820 gimple
*copy
= gimple_alloc (code
, num_ops
);
1823 /* Shallow copy all the fields from STMT. */
1824 memcpy (copy
, stmt
, gimple_size (code
));
1825 gimple_init_singleton (copy
);
1827 /* If STMT has sub-statements, deep-copy them as well. */
1828 if (gimple_has_substatements (stmt
))
1833 switch (gimple_code (stmt
))
1837 gbind
*bind_stmt
= as_a
<gbind
*> (stmt
);
1838 gbind
*bind_copy
= as_a
<gbind
*> (copy
);
1839 new_seq
= gimple_seq_copy (gimple_bind_body (bind_stmt
));
1840 gimple_bind_set_body (bind_copy
, new_seq
);
1841 gimple_bind_set_vars (bind_copy
,
1842 unshare_expr (gimple_bind_vars (bind_stmt
)));
1843 gimple_bind_set_block (bind_copy
, gimple_bind_block (bind_stmt
));
1849 gcatch
*catch_stmt
= as_a
<gcatch
*> (stmt
);
1850 gcatch
*catch_copy
= as_a
<gcatch
*> (copy
);
1851 new_seq
= gimple_seq_copy (gimple_catch_handler (catch_stmt
));
1852 gimple_catch_set_handler (catch_copy
, new_seq
);
1853 t
= unshare_expr (gimple_catch_types (catch_stmt
));
1854 gimple_catch_set_types (catch_copy
, t
);
1858 case GIMPLE_EH_FILTER
:
1860 geh_filter
*eh_filter_stmt
= as_a
<geh_filter
*> (stmt
);
1861 geh_filter
*eh_filter_copy
= as_a
<geh_filter
*> (copy
);
1863 = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt
));
1864 gimple_eh_filter_set_failure (eh_filter_copy
, new_seq
);
1865 t
= unshare_expr (gimple_eh_filter_types (eh_filter_stmt
));
1866 gimple_eh_filter_set_types (eh_filter_copy
, t
);
1870 case GIMPLE_EH_ELSE
:
1872 geh_else
*eh_else_stmt
= as_a
<geh_else
*> (stmt
);
1873 geh_else
*eh_else_copy
= as_a
<geh_else
*> (copy
);
1874 new_seq
= gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt
));
1875 gimple_eh_else_set_n_body (eh_else_copy
, new_seq
);
1876 new_seq
= gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt
));
1877 gimple_eh_else_set_e_body (eh_else_copy
, new_seq
);
1883 gtry
*try_stmt
= as_a
<gtry
*> (stmt
);
1884 gtry
*try_copy
= as_a
<gtry
*> (copy
);
1885 new_seq
= gimple_seq_copy (gimple_try_eval (try_stmt
));
1886 gimple_try_set_eval (try_copy
, new_seq
);
1887 new_seq
= gimple_seq_copy (gimple_try_cleanup (try_stmt
));
1888 gimple_try_set_cleanup (try_copy
, new_seq
);
1892 case GIMPLE_OMP_FOR
:
1893 new_seq
= gimple_seq_copy (gimple_omp_for_pre_body (stmt
));
1894 gimple_omp_for_set_pre_body (copy
, new_seq
);
1895 t
= unshare_expr (gimple_omp_for_clauses (stmt
));
1896 gimple_omp_for_set_clauses (copy
, t
);
1898 gomp_for
*omp_for_copy
= as_a
<gomp_for
*> (copy
);
1899 omp_for_copy
->iter
= ggc_vec_alloc
<gimple_omp_for_iter
>
1900 ( gimple_omp_for_collapse (stmt
));
1902 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1904 gimple_omp_for_set_cond (copy
, i
,
1905 gimple_omp_for_cond (stmt
, i
));
1906 gimple_omp_for_set_index (copy
, i
,
1907 gimple_omp_for_index (stmt
, i
));
1908 t
= unshare_expr (gimple_omp_for_initial (stmt
, i
));
1909 gimple_omp_for_set_initial (copy
, i
, t
);
1910 t
= unshare_expr (gimple_omp_for_final (stmt
, i
));
1911 gimple_omp_for_set_final (copy
, i
, t
);
1912 t
= unshare_expr (gimple_omp_for_incr (stmt
, i
));
1913 gimple_omp_for_set_incr (copy
, i
, t
);
1917 case GIMPLE_OMP_PARALLEL
:
1919 gomp_parallel
*omp_par_stmt
= as_a
<gomp_parallel
*> (stmt
);
1920 gomp_parallel
*omp_par_copy
= as_a
<gomp_parallel
*> (copy
);
1921 t
= unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt
));
1922 gimple_omp_parallel_set_clauses (omp_par_copy
, t
);
1923 t
= unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt
));
1924 gimple_omp_parallel_set_child_fn (omp_par_copy
, t
);
1925 t
= unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt
));
1926 gimple_omp_parallel_set_data_arg (omp_par_copy
, t
);
1930 case GIMPLE_OMP_TASK
:
1931 t
= unshare_expr (gimple_omp_task_clauses (stmt
));
1932 gimple_omp_task_set_clauses (copy
, t
);
1933 t
= unshare_expr (gimple_omp_task_child_fn (stmt
));
1934 gimple_omp_task_set_child_fn (copy
, t
);
1935 t
= unshare_expr (gimple_omp_task_data_arg (stmt
));
1936 gimple_omp_task_set_data_arg (copy
, t
);
1937 t
= unshare_expr (gimple_omp_task_copy_fn (stmt
));
1938 gimple_omp_task_set_copy_fn (copy
, t
);
1939 t
= unshare_expr (gimple_omp_task_arg_size (stmt
));
1940 gimple_omp_task_set_arg_size (copy
, t
);
1941 t
= unshare_expr (gimple_omp_task_arg_align (stmt
));
1942 gimple_omp_task_set_arg_align (copy
, t
);
1945 case GIMPLE_OMP_CRITICAL
:
1946 t
= unshare_expr (gimple_omp_critical_name
1947 (as_a
<gomp_critical
*> (stmt
)));
1948 gimple_omp_critical_set_name (as_a
<gomp_critical
*> (copy
), t
);
1949 t
= unshare_expr (gimple_omp_critical_clauses
1950 (as_a
<gomp_critical
*> (stmt
)));
1951 gimple_omp_critical_set_clauses (as_a
<gomp_critical
*> (copy
), t
);
1954 case GIMPLE_OMP_ORDERED
:
1955 t
= unshare_expr (gimple_omp_ordered_clauses
1956 (as_a
<gomp_ordered
*> (stmt
)));
1957 gimple_omp_ordered_set_clauses (as_a
<gomp_ordered
*> (copy
), t
);
1960 case GIMPLE_OMP_SCAN
:
1961 t
= gimple_omp_scan_clauses (as_a
<gomp_scan
*> (stmt
));
1962 t
= unshare_expr (t
);
1963 gimple_omp_scan_set_clauses (as_a
<gomp_scan
*> (copy
), t
);
1966 case GIMPLE_OMP_TASKGROUP
:
1967 t
= unshare_expr (gimple_omp_taskgroup_clauses (stmt
));
1968 gimple_omp_taskgroup_set_clauses (copy
, t
);
1971 case GIMPLE_OMP_SECTIONS
:
1972 t
= unshare_expr (gimple_omp_sections_clauses (stmt
));
1973 gimple_omp_sections_set_clauses (copy
, t
);
1974 t
= unshare_expr (gimple_omp_sections_control (stmt
));
1975 gimple_omp_sections_set_control (copy
, t
);
1978 case GIMPLE_OMP_SINGLE
:
1980 gomp_single
*omp_single_copy
= as_a
<gomp_single
*> (copy
);
1981 t
= unshare_expr (gimple_omp_single_clauses (stmt
));
1982 gimple_omp_single_set_clauses (omp_single_copy
, t
);
1986 case GIMPLE_OMP_TARGET
:
1988 gomp_target
*omp_target_stmt
= as_a
<gomp_target
*> (stmt
);
1989 gomp_target
*omp_target_copy
= as_a
<gomp_target
*> (copy
);
1990 t
= unshare_expr (gimple_omp_target_clauses (omp_target_stmt
));
1991 gimple_omp_target_set_clauses (omp_target_copy
, t
);
1992 t
= unshare_expr (gimple_omp_target_data_arg (omp_target_stmt
));
1993 gimple_omp_target_set_data_arg (omp_target_copy
, t
);
1997 case GIMPLE_OMP_TEAMS
:
1999 gomp_teams
*omp_teams_copy
= as_a
<gomp_teams
*> (copy
);
2000 t
= unshare_expr (gimple_omp_teams_clauses (stmt
));
2001 gimple_omp_teams_set_clauses (omp_teams_copy
, t
);
2005 case GIMPLE_OMP_SECTION
:
2006 case GIMPLE_OMP_MASTER
:
2008 new_seq
= gimple_seq_copy (gimple_omp_body (stmt
));
2009 gimple_omp_set_body (copy
, new_seq
);
2012 case GIMPLE_TRANSACTION
:
2013 new_seq
= gimple_seq_copy (gimple_transaction_body (
2014 as_a
<gtransaction
*> (stmt
)));
2015 gimple_transaction_set_body (as_a
<gtransaction
*> (copy
),
2019 case GIMPLE_WITH_CLEANUP_EXPR
:
2020 new_seq
= gimple_seq_copy (gimple_wce_cleanup (stmt
));
2021 gimple_wce_set_cleanup (copy
, new_seq
);
2029 /* Make copy of operands. */
2030 for (i
= 0; i
< num_ops
; i
++)
2031 gimple_set_op (copy
, i
, unshare_expr (gimple_op (stmt
, i
)));
2033 if (gimple_has_mem_ops (stmt
))
2035 gimple_set_vdef (copy
, gimple_vdef (stmt
));
2036 gimple_set_vuse (copy
, gimple_vuse (stmt
));
2039 /* Clear out SSA operand vectors on COPY. */
2040 if (gimple_has_ops (stmt
))
2042 gimple_set_use_ops (copy
, NULL
);
2044 /* SSA operands need to be updated. */
2045 gimple_set_modified (copy
, true);
2048 if (gimple_debug_nonbind_marker_p (stmt
))
2049 cfun
->debug_marker_count
++;
2054 /* Move OLD_STMT's vuse and vdef operands to NEW_STMT, on the assumption
2055 that OLD_STMT is about to be removed. */
2058 gimple_move_vops (gimple
*new_stmt
, gimple
*old_stmt
)
2060 tree vdef
= gimple_vdef (old_stmt
);
2061 gimple_set_vuse (new_stmt
, gimple_vuse (old_stmt
));
2062 gimple_set_vdef (new_stmt
, vdef
);
2063 if (vdef
&& TREE_CODE (vdef
) == SSA_NAME
)
2064 SSA_NAME_DEF_STMT (vdef
) = new_stmt
;
2067 /* Return true if statement S has side-effects. We consider a
2068 statement to have side effects if:
2070 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
2071 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
2074 gimple_has_side_effects (const gimple
*s
)
2076 if (is_gimple_debug (s
))
2079 /* We don't have to scan the arguments to check for
2080 volatile arguments, though, at present, we still
2081 do a scan to check for TREE_SIDE_EFFECTS. */
2082 if (gimple_has_volatile_ops (s
))
2085 if (gimple_code (s
) == GIMPLE_ASM
2086 && gimple_asm_volatile_p (as_a
<const gasm
*> (s
)))
2089 if (is_gimple_call (s
))
2091 int flags
= gimple_call_flags (s
);
2093 /* An infinite loop is considered a side effect. */
2094 if (!(flags
& (ECF_CONST
| ECF_PURE
))
2095 || (flags
& ECF_LOOPING_CONST_OR_PURE
))
2104 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
2105 Return true if S can trap. When INCLUDE_MEM is true, check whether
2106 the memory operations could trap. When INCLUDE_STORES is true and
2107 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
2110 gimple_could_trap_p_1 (gimple
*s
, bool include_mem
, bool include_stores
)
2112 tree t
, div
= NULL_TREE
;
2117 unsigned i
, start
= (is_gimple_assign (s
) && !include_stores
) ? 1 : 0;
2119 for (i
= start
; i
< gimple_num_ops (s
); i
++)
2120 if (tree_could_trap_p (gimple_op (s
, i
)))
2124 switch (gimple_code (s
))
2127 return gimple_asm_volatile_p (as_a
<gasm
*> (s
));
2130 t
= gimple_call_fndecl (s
);
2131 /* Assume that calls to weak functions may trap. */
2132 if (!t
|| !DECL_P (t
) || DECL_WEAK (t
))
2137 op
= gimple_assign_rhs_code (s
);
2139 /* For COND_EXPR and VEC_COND_EXPR only the condition may trap. */
2140 if (op
== COND_EXPR
|| op
== VEC_COND_EXPR
)
2141 return tree_could_trap_p (gimple_assign_rhs1 (s
));
2143 /* For comparisons we need to check rhs operand types instead of rhs type
2144 (which is BOOLEAN_TYPE). */
2145 if (TREE_CODE_CLASS (op
) == tcc_comparison
)
2146 t
= TREE_TYPE (gimple_assign_rhs1 (s
));
2148 t
= gimple_expr_type (s
);
2150 if (get_gimple_rhs_class (op
) == GIMPLE_BINARY_RHS
)
2151 div
= gimple_assign_rhs2 (s
);
2153 return (operation_could_trap_p (op
, FLOAT_TYPE_P (t
),
2154 (INTEGRAL_TYPE_P (t
)
2155 && TYPE_OVERFLOW_TRAPS (t
)),
2159 t
= TREE_TYPE (gimple_cond_lhs (s
));
2160 return operation_could_trap_p (gimple_cond_code (s
),
2161 FLOAT_TYPE_P (t
), false, NULL_TREE
);
2170 /* Return true if statement S can trap. */
2173 gimple_could_trap_p (gimple
*s
)
2175 return gimple_could_trap_p_1 (s
, true, true);
2178 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
2181 gimple_assign_rhs_could_trap_p (gimple
*s
)
2183 gcc_assert (is_gimple_assign (s
));
2184 return gimple_could_trap_p_1 (s
, true, false);
2188 /* Print debugging information for gimple stmts generated. */
2191 dump_gimple_statistics (void)
2194 uint64_t total_tuples
= 0, total_bytes
= 0;
2196 if (! GATHER_STATISTICS
)
2198 fprintf (stderr
, "No GIMPLE statistics\n");
2202 fprintf (stderr
, "\nGIMPLE statements\n");
2203 fprintf (stderr
, "Kind Stmts Bytes\n");
2204 fprintf (stderr
, "---------------------------------------\n");
2205 for (i
= 0; i
< (int) gimple_alloc_kind_all
; ++i
)
2207 fprintf (stderr
, "%-20s %7" PRIu64
"%c %10" PRIu64
"%c\n",
2208 gimple_alloc_kind_names
[i
],
2209 SIZE_AMOUNT (gimple_alloc_counts
[i
]),
2210 SIZE_AMOUNT (gimple_alloc_sizes
[i
]));
2211 total_tuples
+= gimple_alloc_counts
[i
];
2212 total_bytes
+= gimple_alloc_sizes
[i
];
2214 fprintf (stderr
, "---------------------------------------\n");
2215 fprintf (stderr
, "%-20s %7" PRIu64
"%c %10" PRIu64
"%c\n", "Total",
2216 SIZE_AMOUNT (total_tuples
), SIZE_AMOUNT (total_bytes
));
2217 fprintf (stderr
, "---------------------------------------\n");
2221 /* Return the number of operands needed on the RHS of a GIMPLE
2222 assignment for an expression with tree code CODE. */
2225 get_gimple_rhs_num_ops (enum tree_code code
)
2227 switch (get_gimple_rhs_class (code
))
2229 case GIMPLE_UNARY_RHS
:
2230 case GIMPLE_SINGLE_RHS
:
2232 case GIMPLE_BINARY_RHS
:
2234 case GIMPLE_TERNARY_RHS
:
2241 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2243 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2244 : ((TYPE) == tcc_binary \
2245 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2246 : ((TYPE) == tcc_constant \
2247 || (TYPE) == tcc_declaration \
2248 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2249 : ((SYM) == TRUTH_AND_EXPR \
2250 || (SYM) == TRUTH_OR_EXPR \
2251 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2252 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2253 : ((SYM) == COND_EXPR \
2254 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2255 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2256 || (SYM) == DOT_PROD_EXPR \
2257 || (SYM) == SAD_EXPR \
2258 || (SYM) == REALIGN_LOAD_EXPR \
2259 || (SYM) == VEC_COND_EXPR \
2260 || (SYM) == VEC_PERM_EXPR \
2261 || (SYM) == BIT_INSERT_EXPR) ? GIMPLE_TERNARY_RHS \
2262 : ((SYM) == CONSTRUCTOR \
2263 || (SYM) == OBJ_TYPE_REF \
2264 || (SYM) == ASSERT_EXPR \
2265 || (SYM) == ADDR_EXPR \
2266 || (SYM) == WITH_SIZE_EXPR \
2267 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2268 : GIMPLE_INVALID_RHS),
2269 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2271 const unsigned char gimple_rhs_class_table
[] = {
2272 #include "all-tree.def"
2276 #undef END_OF_BASE_TREE_CODES
2278 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2279 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2280 we failed to create one. */
2283 canonicalize_cond_expr_cond (tree t
)
2285 /* Strip conversions around boolean operations. */
2286 if (CONVERT_EXPR_P (t
)
2287 && (truth_value_p (TREE_CODE (TREE_OPERAND (t
, 0)))
2288 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
2290 t
= TREE_OPERAND (t
, 0);
2292 /* For !x use x == 0. */
2293 if (TREE_CODE (t
) == TRUTH_NOT_EXPR
)
2295 tree top0
= TREE_OPERAND (t
, 0);
2296 t
= build2 (EQ_EXPR
, TREE_TYPE (t
),
2297 top0
, build_int_cst (TREE_TYPE (top0
), 0));
2299 /* For cmp ? 1 : 0 use cmp. */
2300 else if (TREE_CODE (t
) == COND_EXPR
2301 && COMPARISON_CLASS_P (TREE_OPERAND (t
, 0))
2302 && integer_onep (TREE_OPERAND (t
, 1))
2303 && integer_zerop (TREE_OPERAND (t
, 2)))
2305 tree top0
= TREE_OPERAND (t
, 0);
2306 t
= build2 (TREE_CODE (top0
), TREE_TYPE (t
),
2307 TREE_OPERAND (top0
, 0), TREE_OPERAND (top0
, 1));
2309 /* For x ^ y use x != y. */
2310 else if (TREE_CODE (t
) == BIT_XOR_EXPR
)
2311 t
= build2 (NE_EXPR
, TREE_TYPE (t
),
2312 TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1));
2314 if (is_gimple_condexpr (t
))
2320 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2321 the positions marked by the set ARGS_TO_SKIP. */
2324 gimple_call_copy_skip_args (gcall
*stmt
, bitmap args_to_skip
)
2327 int nargs
= gimple_call_num_args (stmt
);
2328 auto_vec
<tree
> vargs (nargs
);
2331 for (i
= 0; i
< nargs
; i
++)
2332 if (!bitmap_bit_p (args_to_skip
, i
))
2333 vargs
.quick_push (gimple_call_arg (stmt
, i
));
2335 if (gimple_call_internal_p (stmt
))
2336 new_stmt
= gimple_build_call_internal_vec (gimple_call_internal_fn (stmt
),
2339 new_stmt
= gimple_build_call_vec (gimple_call_fn (stmt
), vargs
);
2341 if (gimple_call_lhs (stmt
))
2342 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2344 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2345 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
2347 if (gimple_has_location (stmt
))
2348 gimple_set_location (new_stmt
, gimple_location (stmt
));
2349 gimple_call_copy_flags (new_stmt
, stmt
);
2350 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2352 gimple_set_modified (new_stmt
, true);
2359 /* Return true if the field decls F1 and F2 are at the same offset.
2361 This is intended to be used on GIMPLE types only. */
2364 gimple_compare_field_offset (tree f1
, tree f2
)
2366 if (DECL_OFFSET_ALIGN (f1
) == DECL_OFFSET_ALIGN (f2
))
2368 tree offset1
= DECL_FIELD_OFFSET (f1
);
2369 tree offset2
= DECL_FIELD_OFFSET (f2
);
2370 return ((offset1
== offset2
2371 /* Once gimplification is done, self-referential offsets are
2372 instantiated as operand #2 of the COMPONENT_REF built for
2373 each access and reset. Therefore, they are not relevant
2374 anymore and fields are interchangeable provided that they
2375 represent the same access. */
2376 || (TREE_CODE (offset1
) == PLACEHOLDER_EXPR
2377 && TREE_CODE (offset2
) == PLACEHOLDER_EXPR
2378 && (DECL_SIZE (f1
) == DECL_SIZE (f2
)
2379 || (TREE_CODE (DECL_SIZE (f1
)) == PLACEHOLDER_EXPR
2380 && TREE_CODE (DECL_SIZE (f2
)) == PLACEHOLDER_EXPR
)
2381 || operand_equal_p (DECL_SIZE (f1
), DECL_SIZE (f2
), 0))
2382 && DECL_ALIGN (f1
) == DECL_ALIGN (f2
))
2383 || operand_equal_p (offset1
, offset2
, 0))
2384 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1
),
2385 DECL_FIELD_BIT_OFFSET (f2
)));
2388 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2389 should be, so handle differing ones specially by decomposing
2390 the offset into a byte and bit offset manually. */
2391 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1
))
2392 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2
)))
2394 unsigned HOST_WIDE_INT byte_offset1
, byte_offset2
;
2395 unsigned HOST_WIDE_INT bit_offset1
, bit_offset2
;
2396 bit_offset1
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1
));
2397 byte_offset1
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1
))
2398 + bit_offset1
/ BITS_PER_UNIT
);
2399 bit_offset2
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2
));
2400 byte_offset2
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2
))
2401 + bit_offset2
/ BITS_PER_UNIT
);
2402 if (byte_offset1
!= byte_offset2
)
2404 return bit_offset1
% BITS_PER_UNIT
== bit_offset2
% BITS_PER_UNIT
;
2411 /* Return a type the same as TYPE except unsigned or
2412 signed according to UNSIGNEDP. */
2415 gimple_signed_or_unsigned_type (bool unsignedp
, tree type
)
2420 type1
= TYPE_MAIN_VARIANT (type
);
2421 if (type1
== signed_char_type_node
2422 || type1
== char_type_node
2423 || type1
== unsigned_char_type_node
)
2424 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2425 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2426 return unsignedp
? unsigned_type_node
: integer_type_node
;
2427 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2428 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2429 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2430 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2431 if (type1
== long_long_integer_type_node
2432 || type1
== long_long_unsigned_type_node
)
2434 ? long_long_unsigned_type_node
2435 : long_long_integer_type_node
;
2437 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2438 if (int_n_enabled_p
[i
]
2439 && (type1
== int_n_trees
[i
].unsigned_type
2440 || type1
== int_n_trees
[i
].signed_type
))
2442 ? int_n_trees
[i
].unsigned_type
2443 : int_n_trees
[i
].signed_type
;
2445 #if HOST_BITS_PER_WIDE_INT >= 64
2446 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2447 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2449 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2450 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2451 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2452 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2453 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2454 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2455 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2456 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2458 #define GIMPLE_FIXED_TYPES(NAME) \
2459 if (type1 == short_ ## NAME ## _type_node \
2460 || type1 == unsigned_short_ ## NAME ## _type_node) \
2461 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2462 : short_ ## NAME ## _type_node; \
2463 if (type1 == NAME ## _type_node \
2464 || type1 == unsigned_ ## NAME ## _type_node) \
2465 return unsignedp ? unsigned_ ## NAME ## _type_node \
2466 : NAME ## _type_node; \
2467 if (type1 == long_ ## NAME ## _type_node \
2468 || type1 == unsigned_long_ ## NAME ## _type_node) \
2469 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2470 : long_ ## NAME ## _type_node; \
2471 if (type1 == long_long_ ## NAME ## _type_node \
2472 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2473 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2474 : long_long_ ## NAME ## _type_node;
2476 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2477 if (type1 == NAME ## _type_node \
2478 || type1 == u ## NAME ## _type_node) \
2479 return unsignedp ? u ## NAME ## _type_node \
2480 : NAME ## _type_node;
2482 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2483 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2484 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2485 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2486 : sat_ ## short_ ## NAME ## _type_node; \
2487 if (type1 == sat_ ## NAME ## _type_node \
2488 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2489 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2490 : sat_ ## NAME ## _type_node; \
2491 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2492 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2493 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2494 : sat_ ## long_ ## NAME ## _type_node; \
2495 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2496 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2497 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2498 : sat_ ## long_long_ ## NAME ## _type_node;
2500 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2501 if (type1 == sat_ ## NAME ## _type_node \
2502 || type1 == sat_ ## u ## NAME ## _type_node) \
2503 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2504 : sat_ ## NAME ## _type_node;
2506 GIMPLE_FIXED_TYPES (fract
);
2507 GIMPLE_FIXED_TYPES_SAT (fract
);
2508 GIMPLE_FIXED_TYPES (accum
);
2509 GIMPLE_FIXED_TYPES_SAT (accum
);
2511 GIMPLE_FIXED_MODE_TYPES (qq
);
2512 GIMPLE_FIXED_MODE_TYPES (hq
);
2513 GIMPLE_FIXED_MODE_TYPES (sq
);
2514 GIMPLE_FIXED_MODE_TYPES (dq
);
2515 GIMPLE_FIXED_MODE_TYPES (tq
);
2516 GIMPLE_FIXED_MODE_TYPES_SAT (qq
);
2517 GIMPLE_FIXED_MODE_TYPES_SAT (hq
);
2518 GIMPLE_FIXED_MODE_TYPES_SAT (sq
);
2519 GIMPLE_FIXED_MODE_TYPES_SAT (dq
);
2520 GIMPLE_FIXED_MODE_TYPES_SAT (tq
);
2521 GIMPLE_FIXED_MODE_TYPES (ha
);
2522 GIMPLE_FIXED_MODE_TYPES (sa
);
2523 GIMPLE_FIXED_MODE_TYPES (da
);
2524 GIMPLE_FIXED_MODE_TYPES (ta
);
2525 GIMPLE_FIXED_MODE_TYPES_SAT (ha
);
2526 GIMPLE_FIXED_MODE_TYPES_SAT (sa
);
2527 GIMPLE_FIXED_MODE_TYPES_SAT (da
);
2528 GIMPLE_FIXED_MODE_TYPES_SAT (ta
);
2530 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2531 the precision; they have precision set to match their range, but
2532 may use a wider mode to match an ABI. If we change modes, we may
2533 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2534 the precision as well, so as to yield correct results for
2535 bit-field types. C++ does not have these separate bit-field
2536 types, and producing a signed or unsigned variant of an
2537 ENUMERAL_TYPE may cause other problems as well. */
2538 if (!INTEGRAL_TYPE_P (type
)
2539 || TYPE_UNSIGNED (type
) == unsignedp
)
2542 #define TYPE_OK(node) \
2543 (TYPE_MODE (type) == TYPE_MODE (node) \
2544 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2545 if (TYPE_OK (signed_char_type_node
))
2546 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2547 if (TYPE_OK (integer_type_node
))
2548 return unsignedp
? unsigned_type_node
: integer_type_node
;
2549 if (TYPE_OK (short_integer_type_node
))
2550 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2551 if (TYPE_OK (long_integer_type_node
))
2552 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2553 if (TYPE_OK (long_long_integer_type_node
))
2555 ? long_long_unsigned_type_node
2556 : long_long_integer_type_node
);
2558 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2559 if (int_n_enabled_p
[i
]
2560 && TYPE_MODE (type
) == int_n_data
[i
].m
2561 && TYPE_PRECISION (type
) == int_n_data
[i
].bitsize
)
2563 ? int_n_trees
[i
].unsigned_type
2564 : int_n_trees
[i
].signed_type
;
2566 #if HOST_BITS_PER_WIDE_INT >= 64
2567 if (TYPE_OK (intTI_type_node
))
2568 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2570 if (TYPE_OK (intDI_type_node
))
2571 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2572 if (TYPE_OK (intSI_type_node
))
2573 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2574 if (TYPE_OK (intHI_type_node
))
2575 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2576 if (TYPE_OK (intQI_type_node
))
2577 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2579 #undef GIMPLE_FIXED_TYPES
2580 #undef GIMPLE_FIXED_MODE_TYPES
2581 #undef GIMPLE_FIXED_TYPES_SAT
2582 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2585 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2589 /* Return an unsigned type the same as TYPE in other respects. */
2592 gimple_unsigned_type (tree type
)
2594 return gimple_signed_or_unsigned_type (true, type
);
2598 /* Return a signed type the same as TYPE in other respects. */
2601 gimple_signed_type (tree type
)
2603 return gimple_signed_or_unsigned_type (false, type
);
2607 /* Return the typed-based alias set for T, which may be an expression
2608 or a type. Return -1 if we don't do anything special. */
2611 gimple_get_alias_set (tree t
)
2613 /* That's all the expressions we handle specially. */
2617 /* For convenience, follow the C standard when dealing with
2618 character types. Any object may be accessed via an lvalue that
2619 has character type. */
2620 if (t
== char_type_node
2621 || t
== signed_char_type_node
2622 || t
== unsigned_char_type_node
)
2625 /* Allow aliasing between signed and unsigned variants of the same
2626 type. We treat the signed variant as canonical. */
2627 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2629 tree t1
= gimple_signed_type (t
);
2631 /* t1 == t can happen for boolean nodes which are always unsigned. */
2633 return get_alias_set (t1
);
2636 /* Allow aliasing between enumeral types and the underlying
2637 integer type. This is required for C since those are
2638 compatible types. */
2639 else if (TREE_CODE (t
) == ENUMERAL_TYPE
)
2641 tree t1
= lang_hooks
.types
.type_for_size (tree_to_uhwi (TYPE_SIZE (t
)),
2642 false /* short-cut above */);
2643 return get_alias_set (t1
);
2650 /* Helper for gimple_ior_addresses_taken_1. */
2653 gimple_ior_addresses_taken_1 (gimple
*, tree addr
, tree
, void *data
)
2655 bitmap addresses_taken
= (bitmap
)data
;
2656 addr
= get_base_address (addr
);
2660 bitmap_set_bit (addresses_taken
, DECL_UID (addr
));
2666 /* Set the bit for the uid of all decls that have their address taken
2667 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2668 were any in this stmt. */
2671 gimple_ior_addresses_taken (bitmap addresses_taken
, gimple
*stmt
)
2673 return walk_stmt_load_store_addr_ops (stmt
, addresses_taken
, NULL
, NULL
,
2674 gimple_ior_addresses_taken_1
);
2678 /* Return true when STMTs arguments and return value match those of FNDECL,
2679 a decl of a builtin function. */
2682 gimple_builtin_call_types_compatible_p (const gimple
*stmt
, tree fndecl
)
2684 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
);
2686 tree ret
= gimple_call_lhs (stmt
);
2688 && !useless_type_conversion_p (TREE_TYPE (ret
),
2689 TREE_TYPE (TREE_TYPE (fndecl
))))
2692 tree targs
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2693 unsigned nargs
= gimple_call_num_args (stmt
);
2694 for (unsigned i
= 0; i
< nargs
; ++i
)
2696 /* Variadic args follow. */
2699 tree arg
= gimple_call_arg (stmt
, i
);
2700 tree type
= TREE_VALUE (targs
);
2701 if (!useless_type_conversion_p (type
, TREE_TYPE (arg
))
2702 /* char/short integral arguments are promoted to int
2703 by several frontends if targetm.calls.promote_prototypes
2704 is true. Allow such promotion too. */
2705 && !(INTEGRAL_TYPE_P (type
)
2706 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)
2707 && targetm
.calls
.promote_prototypes (TREE_TYPE (fndecl
))
2708 && useless_type_conversion_p (integer_type_node
,
2711 targs
= TREE_CHAIN (targs
);
2713 if (targs
&& !VOID_TYPE_P (TREE_VALUE (targs
)))
2718 /* Return true when STMT is operator a replaceable delete call. */
2721 gimple_call_replaceable_operator_delete_p (const gcall
*stmt
)
2725 if ((fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
)
2726 return DECL_IS_REPLACEABLE_OPERATOR_DELETE_P (fndecl
);
2730 /* Return true when STMT is builtins call. */
2733 gimple_call_builtin_p (const gimple
*stmt
)
2736 if (is_gimple_call (stmt
)
2737 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2738 && DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
)
2739 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2743 /* Return true when STMT is builtins call to CLASS. */
2746 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_class klass
)
2749 if (is_gimple_call (stmt
)
2750 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2751 && DECL_BUILT_IN_CLASS (fndecl
) == klass
)
2752 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2756 /* Return true when STMT is builtins call to CODE of CLASS. */
2759 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_function code
)
2762 if (is_gimple_call (stmt
)
2763 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2764 && fndecl_built_in_p (fndecl
, code
))
2765 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2769 /* If CALL is a call to a combined_fn (i.e. an internal function or
2770 a normal built-in function), return its code, otherwise return
2774 gimple_call_combined_fn (const gimple
*stmt
)
2776 if (const gcall
*call
= dyn_cast
<const gcall
*> (stmt
))
2778 if (gimple_call_internal_p (call
))
2779 return as_combined_fn (gimple_call_internal_fn (call
));
2781 tree fndecl
= gimple_call_fndecl (stmt
);
2783 && fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
)
2784 && gimple_builtin_call_types_compatible_p (stmt
, fndecl
))
2785 return as_combined_fn (DECL_FUNCTION_CODE (fndecl
));
2790 /* Return true if STMT clobbers memory. STMT is required to be a
2794 gimple_asm_clobbers_memory_p (const gasm
*stmt
)
2798 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
2800 tree op
= gimple_asm_clobber_op (stmt
, i
);
2801 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op
)), "memory") == 0)
2805 /* Non-empty basic ASM implicitly clobbers memory. */
2806 if (gimple_asm_input_p (stmt
) && strlen (gimple_asm_string (stmt
)) != 0)
2812 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2815 dump_decl_set (FILE *file
, bitmap set
)
2822 fprintf (file
, "{ ");
2824 EXECUTE_IF_SET_IN_BITMAP (set
, 0, i
, bi
)
2826 fprintf (file
, "D.%u", i
);
2827 fprintf (file
, " ");
2830 fprintf (file
, "}");
2833 fprintf (file
, "NIL");
2836 /* Return true when CALL is a call stmt that definitely doesn't
2837 free any memory or makes it unavailable otherwise. */
2839 nonfreeing_call_p (gimple
*call
)
2841 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2842 && gimple_call_flags (call
) & ECF_LEAF
)
2843 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call
)))
2845 /* Just in case these become ECF_LEAF in the future. */
2847 case BUILT_IN_TM_FREE
:
2848 case BUILT_IN_REALLOC
:
2849 case BUILT_IN_STACK_RESTORE
:
2854 else if (gimple_call_internal_p (call
))
2855 switch (gimple_call_internal_fn (call
))
2857 case IFN_ABNORMAL_DISPATCHER
:
2860 return tree_to_uhwi (gimple_call_arg (call
, 0)) == ASAN_MARK_UNPOISON
;
2862 if (gimple_call_flags (call
) & ECF_LEAF
)
2867 tree fndecl
= gimple_call_fndecl (call
);
2870 struct cgraph_node
*n
= cgraph_node::get (fndecl
);
2873 enum availability availability
;
2874 n
= n
->function_symbol (&availability
);
2875 if (!n
|| availability
<= AVAIL_INTERPOSABLE
)
2877 return n
->nonfreeing_fn
;
2880 /* Return true when CALL is a call stmt that definitely need not
2881 be considered to be a memory barrier. */
2883 nonbarrier_call_p (gimple
*call
)
2885 if (gimple_call_flags (call
) & (ECF_PURE
| ECF_CONST
))
2887 /* Should extend this to have a nonbarrier_fn flag, just as above in
2888 the nonfreeing case. */
2892 /* Callback for walk_stmt_load_store_ops.
2894 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2897 This routine only makes a superficial check for a dereference. Thus
2898 it must only be used if it is safe to return a false negative. */
2900 check_loadstore (gimple
*, tree op
, tree
, void *data
)
2902 if (TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
2904 /* Some address spaces may legitimately dereference zero. */
2905 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (op
));
2906 if (targetm
.addr_space
.zero_address_valid (as
))
2909 return operand_equal_p (TREE_OPERAND (op
, 0), (tree
)data
, 0);
2915 /* Return true if OP can be inferred to be non-NULL after STMT executes,
2916 either by using a pointer dereference or attributes. */
2918 infer_nonnull_range (gimple
*stmt
, tree op
)
2920 return infer_nonnull_range_by_dereference (stmt
, op
)
2921 || infer_nonnull_range_by_attribute (stmt
, op
);
2924 /* Return true if OP can be inferred to be non-NULL after STMT
2925 executes by using a pointer dereference. */
2927 infer_nonnull_range_by_dereference (gimple
*stmt
, tree op
)
2929 /* We can only assume that a pointer dereference will yield
2930 non-NULL if -fdelete-null-pointer-checks is enabled. */
2931 if (!flag_delete_null_pointer_checks
2932 || !POINTER_TYPE_P (TREE_TYPE (op
))
2933 || gimple_code (stmt
) == GIMPLE_ASM
)
2936 if (walk_stmt_load_store_ops (stmt
, (void *)op
,
2937 check_loadstore
, check_loadstore
))
2943 /* Return true if OP can be inferred to be a non-NULL after STMT
2944 executes by using attributes. */
2946 infer_nonnull_range_by_attribute (gimple
*stmt
, tree op
)
2948 /* We can only assume that a pointer dereference will yield
2949 non-NULL if -fdelete-null-pointer-checks is enabled. */
2950 if (!flag_delete_null_pointer_checks
2951 || !POINTER_TYPE_P (TREE_TYPE (op
))
2952 || gimple_code (stmt
) == GIMPLE_ASM
)
2955 if (is_gimple_call (stmt
) && !gimple_call_internal_p (stmt
))
2957 tree fntype
= gimple_call_fntype (stmt
);
2958 tree attrs
= TYPE_ATTRIBUTES (fntype
);
2959 for (; attrs
; attrs
= TREE_CHAIN (attrs
))
2961 attrs
= lookup_attribute ("nonnull", attrs
);
2963 /* If "nonnull" wasn't specified, we know nothing about
2965 if (attrs
== NULL_TREE
)
2968 /* If "nonnull" applies to all the arguments, then ARG
2969 is non-null if it's in the argument list. */
2970 if (TREE_VALUE (attrs
) == NULL_TREE
)
2972 for (unsigned int i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2974 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt
, i
)))
2975 && operand_equal_p (op
, gimple_call_arg (stmt
, i
), 0))
2981 /* Now see if op appears in the nonnull list. */
2982 for (tree t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
2984 unsigned int idx
= TREE_INT_CST_LOW (TREE_VALUE (t
)) - 1;
2985 if (idx
< gimple_call_num_args (stmt
))
2987 tree arg
= gimple_call_arg (stmt
, idx
);
2988 if (operand_equal_p (op
, arg
, 0))
2995 /* If this function is marked as returning non-null, then we can
2996 infer OP is non-null if it is used in the return statement. */
2997 if (greturn
*return_stmt
= dyn_cast
<greturn
*> (stmt
))
2998 if (gimple_return_retval (return_stmt
)
2999 && operand_equal_p (gimple_return_retval (return_stmt
), op
, 0)
3000 && lookup_attribute ("returns_nonnull",
3001 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
))))
3007 /* Compare two case labels. Because the front end should already have
3008 made sure that case ranges do not overlap, it is enough to only compare
3009 the CASE_LOW values of each case label. */
3012 compare_case_labels (const void *p1
, const void *p2
)
3014 const_tree
const case1
= *(const_tree
const*)p1
;
3015 const_tree
const case2
= *(const_tree
const*)p2
;
3017 /* The 'default' case label always goes first. */
3018 if (!CASE_LOW (case1
))
3020 else if (!CASE_LOW (case2
))
3023 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
3026 /* Sort the case labels in LABEL_VEC in place in ascending order. */
3029 sort_case_labels (vec
<tree
> label_vec
)
3031 label_vec
.qsort (compare_case_labels
);
3034 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
3036 LABELS is a vector that contains all case labels to look at.
3038 INDEX_TYPE is the type of the switch index expression. Case labels
3039 in LABELS are discarded if their values are not in the value range
3040 covered by INDEX_TYPE. The remaining case label values are folded
3043 If a default case exists in LABELS, it is removed from LABELS and
3044 returned in DEFAULT_CASEP. If no default case exists, but the
3045 case labels already cover the whole range of INDEX_TYPE, a default
3046 case is returned pointing to one of the existing case labels.
3047 Otherwise DEFAULT_CASEP is set to NULL_TREE.
3049 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
3050 apply and no action is taken regardless of whether a default case is
3054 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
3056 tree
*default_casep
)
3058 tree min_value
, max_value
;
3059 tree default_case
= NULL_TREE
;
3063 min_value
= TYPE_MIN_VALUE (index_type
);
3064 max_value
= TYPE_MAX_VALUE (index_type
);
3065 while (i
< labels
.length ())
3067 tree elt
= labels
[i
];
3068 tree low
= CASE_LOW (elt
);
3069 tree high
= CASE_HIGH (elt
);
3070 bool remove_element
= FALSE
;
3074 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
3075 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
3077 /* This is a non-default case label, i.e. it has a value.
3079 See if the case label is reachable within the range of
3080 the index type. Remove out-of-range case values. Turn
3081 case ranges into a canonical form (high > low strictly)
3082 and convert the case label values to the index type.
3084 NB: The type of gimple_switch_index() may be the promoted
3085 type, but the case labels retain the original type. */
3089 /* This is a case range. Discard empty ranges.
3090 If the bounds or the range are equal, turn this
3091 into a simple (one-value) case. */
3092 int cmp
= tree_int_cst_compare (high
, low
);
3094 remove_element
= TRUE
;
3101 /* If the simple case value is unreachable, ignore it. */
3102 if ((TREE_CODE (min_value
) == INTEGER_CST
3103 && tree_int_cst_compare (low
, min_value
) < 0)
3104 || (TREE_CODE (max_value
) == INTEGER_CST
3105 && tree_int_cst_compare (low
, max_value
) > 0))
3106 remove_element
= TRUE
;
3108 low
= fold_convert (index_type
, low
);
3112 /* If the entire case range is unreachable, ignore it. */
3113 if ((TREE_CODE (min_value
) == INTEGER_CST
3114 && tree_int_cst_compare (high
, min_value
) < 0)
3115 || (TREE_CODE (max_value
) == INTEGER_CST
3116 && tree_int_cst_compare (low
, max_value
) > 0))
3117 remove_element
= TRUE
;
3120 /* If the lower bound is less than the index type's
3121 minimum value, truncate the range bounds. */
3122 if (TREE_CODE (min_value
) == INTEGER_CST
3123 && tree_int_cst_compare (low
, min_value
) < 0)
3125 low
= fold_convert (index_type
, low
);
3127 /* If the upper bound is greater than the index type's
3128 maximum value, truncate the range bounds. */
3129 if (TREE_CODE (max_value
) == INTEGER_CST
3130 && tree_int_cst_compare (high
, max_value
) > 0)
3132 high
= fold_convert (index_type
, high
);
3134 /* We may have folded a case range to a one-value case. */
3135 if (tree_int_cst_equal (low
, high
))
3140 CASE_LOW (elt
) = low
;
3141 CASE_HIGH (elt
) = high
;
3145 gcc_assert (!default_case
);
3147 /* The default case must be passed separately to the
3148 gimple_build_switch routine. But if DEFAULT_CASEP
3149 is NULL, we do not remove the default case (it would
3150 be completely lost). */
3152 remove_element
= TRUE
;
3156 labels
.ordered_remove (i
);
3162 if (!labels
.is_empty ())
3163 sort_case_labels (labels
);
3165 if (default_casep
&& !default_case
)
3167 /* If the switch has no default label, add one, so that we jump
3168 around the switch body. If the labels already cover the whole
3169 range of the switch index_type, add the default label pointing
3170 to one of the existing labels. */
3172 && TYPE_MIN_VALUE (index_type
)
3173 && TYPE_MAX_VALUE (index_type
)
3174 && tree_int_cst_equal (CASE_LOW (labels
[0]),
3175 TYPE_MIN_VALUE (index_type
)))
3177 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
3179 high
= CASE_LOW (labels
[len
- 1]);
3180 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
3182 tree widest_label
= labels
[0];
3183 for (i
= 1; i
< len
; i
++)
3185 high
= CASE_LOW (labels
[i
]);
3186 low
= CASE_HIGH (labels
[i
- 1]);
3188 low
= CASE_LOW (labels
[i
- 1]);
3190 if (CASE_HIGH (labels
[i
]) != NULL_TREE
3191 && (CASE_HIGH (widest_label
) == NULL_TREE
3193 (wi::to_wide (CASE_HIGH (labels
[i
]))
3194 - wi::to_wide (CASE_LOW (labels
[i
])),
3195 wi::to_wide (CASE_HIGH (widest_label
))
3196 - wi::to_wide (CASE_LOW (widest_label
))))))
3197 widest_label
= labels
[i
];
3199 if (wi::to_wide (low
) + 1 != wi::to_wide (high
))
3204 /* Designate the label with the widest range to be the
3206 tree label
= CASE_LABEL (widest_label
);
3207 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
3215 *default_casep
= default_case
;
3218 /* Set the location of all statements in SEQ to LOC. */
3221 gimple_seq_set_location (gimple_seq seq
, location_t loc
)
3223 for (gimple_stmt_iterator i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
3224 gimple_set_location (gsi_stmt (i
), loc
);
3227 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
3230 gimple_seq_discard (gimple_seq seq
)
3232 gimple_stmt_iterator gsi
;
3234 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); )
3236 gimple
*stmt
= gsi_stmt (gsi
);
3237 gsi_remove (&gsi
, true);
3238 release_defs (stmt
);
3243 /* See if STMT now calls function that takes no parameters and if so, drop
3244 call arguments. This is used when devirtualization machinery redirects
3245 to __builtin_unreachable or __cxa_pure_virtual. */
3248 maybe_remove_unused_call_args (struct function
*fn
, gimple
*stmt
)
3250 tree decl
= gimple_call_fndecl (stmt
);
3251 if (TYPE_ARG_TYPES (TREE_TYPE (decl
))
3252 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
))) == void_type_node
3253 && gimple_call_num_args (stmt
))
3255 gimple_set_num_ops (stmt
, 3);
3256 update_stmt_fn (fn
, stmt
);
3260 /* Return false if STMT will likely expand to real function call. */
3263 gimple_inexpensive_call_p (gcall
*stmt
)
3265 if (gimple_call_internal_p (stmt
))
3267 tree decl
= gimple_call_fndecl (stmt
);
3268 if (decl
&& is_inexpensive_builtin (decl
))
3273 /* Return a non-artificial location for STMT. If STMT does not have
3274 location information, get the location from EXPR. */
3277 gimple_or_expr_nonartificial_location (gimple
*stmt
, tree expr
)
3279 location_t loc
= gimple_nonartificial_location (stmt
);
3280 if (loc
== UNKNOWN_LOCATION
&& EXPR_HAS_LOCATION (expr
))
3281 loc
= tree_nonartificial_location (expr
);
3282 return expansion_point_location_if_in_system_header (loc
);
3288 namespace selftest
{
3290 /* Selftests for core gimple structures. */
3292 /* Verify that STMT is pretty-printed as EXPECTED.
3293 Helper function for selftests. */
3296 verify_gimple_pp (const char *expected
, gimple
*stmt
)
3299 pp_gimple_stmt_1 (&pp
, stmt
, 0 /* spc */, TDF_NONE
/* flags */);
3300 ASSERT_STREQ (expected
, pp_formatted_text (&pp
));
3303 /* Build a GIMPLE_ASSIGN equivalent to
3305 and verify various properties of it. */
3308 test_assign_single ()
3310 tree type
= integer_type_node
;
3311 tree lhs
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3312 get_identifier ("tmp"),
3314 tree rhs
= build_int_cst (type
, 5);
3315 gassign
*stmt
= gimple_build_assign (lhs
, rhs
);
3316 verify_gimple_pp ("tmp = 5;", stmt
);
3318 ASSERT_TRUE (is_gimple_assign (stmt
));
3319 ASSERT_EQ (lhs
, gimple_assign_lhs (stmt
));
3320 ASSERT_EQ (lhs
, gimple_get_lhs (stmt
));
3321 ASSERT_EQ (rhs
, gimple_assign_rhs1 (stmt
));
3322 ASSERT_EQ (NULL
, gimple_assign_rhs2 (stmt
));
3323 ASSERT_EQ (NULL
, gimple_assign_rhs3 (stmt
));
3324 ASSERT_TRUE (gimple_assign_single_p (stmt
));
3325 ASSERT_EQ (INTEGER_CST
, gimple_assign_rhs_code (stmt
));
3328 /* Build a GIMPLE_ASSIGN equivalent to
3330 and verify various properties of it. */
3333 test_assign_binop ()
3335 tree type
= integer_type_node
;
3336 tree lhs
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3337 get_identifier ("tmp"),
3339 tree a
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3340 get_identifier ("a"),
3342 tree b
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3343 get_identifier ("b"),
3345 gassign
*stmt
= gimple_build_assign (lhs
, MULT_EXPR
, a
, b
);
3346 verify_gimple_pp ("tmp = a * b;", stmt
);
3348 ASSERT_TRUE (is_gimple_assign (stmt
));
3349 ASSERT_EQ (lhs
, gimple_assign_lhs (stmt
));
3350 ASSERT_EQ (lhs
, gimple_get_lhs (stmt
));
3351 ASSERT_EQ (a
, gimple_assign_rhs1 (stmt
));
3352 ASSERT_EQ (b
, gimple_assign_rhs2 (stmt
));
3353 ASSERT_EQ (NULL
, gimple_assign_rhs3 (stmt
));
3354 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3355 ASSERT_EQ (MULT_EXPR
, gimple_assign_rhs_code (stmt
));
3358 /* Build a GIMPLE_NOP and verify various properties of it. */
3363 gimple
*stmt
= gimple_build_nop ();
3364 verify_gimple_pp ("GIMPLE_NOP", stmt
);
3365 ASSERT_EQ (GIMPLE_NOP
, gimple_code (stmt
));
3366 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3367 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3370 /* Build a GIMPLE_RETURN equivalent to
3372 and verify various properties of it. */
3377 tree type
= integer_type_node
;
3378 tree val
= build_int_cst (type
, 7);
3379 greturn
*stmt
= gimple_build_return (val
);
3380 verify_gimple_pp ("return 7;", stmt
);
3382 ASSERT_EQ (GIMPLE_RETURN
, gimple_code (stmt
));
3383 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3384 ASSERT_EQ (val
, gimple_return_retval (stmt
));
3385 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3388 /* Build a GIMPLE_RETURN equivalent to
3390 and verify various properties of it. */
3393 test_return_without_value ()
3395 greturn
*stmt
= gimple_build_return (NULL
);
3396 verify_gimple_pp ("return;", stmt
);
3398 ASSERT_EQ (GIMPLE_RETURN
, gimple_code (stmt
));
3399 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3400 ASSERT_EQ (NULL
, gimple_return_retval (stmt
));
3401 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3404 /* Run all of the selftests within this file. */
3409 test_assign_single ();
3410 test_assign_binop ();
3412 test_return_stmt ();
3413 test_return_without_value ();
3416 } // namespace selftest
3419 #endif /* CHECKING_P */