1 /* Gimple IR support functions.
3 Copyright (C) 2007-2019 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
)
116 return gsstruct_code_size
[gss_for_code (code
)];
119 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
123 gimple_alloc (enum gimple_code code
, unsigned num_ops MEM_STAT_DECL
)
128 size
= gimple_size (code
);
130 size
+= sizeof (tree
) * (num_ops
- 1);
132 if (GATHER_STATISTICS
)
134 enum gimple_alloc_kind kind
= gimple_alloc_kind (code
);
135 gimple_alloc_counts
[(int) kind
]++;
136 gimple_alloc_sizes
[(int) kind
] += size
;
139 stmt
= ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT
);
140 gimple_set_code (stmt
, code
);
141 gimple_set_num_ops (stmt
, num_ops
);
143 /* Do not call gimple_set_modified here as it has other side
144 effects and this tuple is still not completely built. */
146 gimple_init_singleton (stmt
);
151 /* Set SUBCODE to be the code of the expression computed by statement G. */
154 gimple_set_subcode (gimple
*g
, unsigned subcode
)
156 /* We only have 16 bits for the RHS code. Assert that we are not
158 gcc_assert (subcode
< (1 << 16));
159 g
->subcode
= subcode
;
164 /* Build a tuple with operands. CODE is the statement to build (which
165 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
166 for the new tuple. NUM_OPS is the number of operands to allocate. */
168 #define gimple_build_with_ops(c, s, n) \
169 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
172 gimple_build_with_ops_stat (enum gimple_code code
, unsigned subcode
,
173 unsigned num_ops MEM_STAT_DECL
)
175 gimple
*s
= gimple_alloc (code
, num_ops PASS_MEM_STAT
);
176 gimple_set_subcode (s
, subcode
);
182 /* Build a GIMPLE_RETURN statement returning RETVAL. */
185 gimple_build_return (tree retval
)
188 = as_a
<greturn
*> (gimple_build_with_ops (GIMPLE_RETURN
, ERROR_MARK
,
191 gimple_return_set_retval (s
, retval
);
195 /* Reset alias information on call S. */
198 gimple_call_reset_alias_info (gcall
*s
)
200 if (gimple_call_flags (s
) & ECF_CONST
)
201 memset (gimple_call_use_set (s
), 0, sizeof (struct pt_solution
));
203 pt_solution_reset (gimple_call_use_set (s
));
204 if (gimple_call_flags (s
) & (ECF_CONST
|ECF_PURE
|ECF_NOVOPS
))
205 memset (gimple_call_clobber_set (s
), 0, sizeof (struct pt_solution
));
207 pt_solution_reset (gimple_call_clobber_set (s
));
210 /* Helper for gimple_build_call, gimple_build_call_valist,
211 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
212 components of a GIMPLE_CALL statement to function FN with NARGS
215 static inline gcall
*
216 gimple_build_call_1 (tree fn
, unsigned nargs
)
219 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
221 if (TREE_CODE (fn
) == FUNCTION_DECL
)
222 fn
= build_fold_addr_expr (fn
);
223 gimple_set_op (s
, 1, fn
);
224 gimple_call_set_fntype (s
, TREE_TYPE (TREE_TYPE (fn
)));
225 gimple_call_reset_alias_info (s
);
230 /* Build a GIMPLE_CALL statement to function FN with the arguments
231 specified in vector ARGS. */
234 gimple_build_call_vec (tree fn
, vec
<tree
> args
)
237 unsigned nargs
= args
.length ();
238 gcall
*call
= gimple_build_call_1 (fn
, nargs
);
240 for (i
= 0; i
< nargs
; i
++)
241 gimple_call_set_arg (call
, i
, args
[i
]);
247 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
248 arguments. The ... are the arguments. */
251 gimple_build_call (tree fn
, unsigned nargs
, ...)
257 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
259 call
= gimple_build_call_1 (fn
, nargs
);
261 va_start (ap
, nargs
);
262 for (i
= 0; i
< nargs
; i
++)
263 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
270 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
271 arguments. AP contains the arguments. */
274 gimple_build_call_valist (tree fn
, unsigned nargs
, va_list ap
)
279 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
281 call
= gimple_build_call_1 (fn
, nargs
);
283 for (i
= 0; i
< nargs
; i
++)
284 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
290 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
291 Build the basic components of a GIMPLE_CALL statement to internal
292 function FN with NARGS arguments. */
294 static inline gcall
*
295 gimple_build_call_internal_1 (enum internal_fn fn
, unsigned nargs
)
298 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
300 s
->subcode
|= GF_CALL_INTERNAL
;
301 gimple_call_set_internal_fn (s
, fn
);
302 gimple_call_reset_alias_info (s
);
307 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
308 the number of arguments. The ... are the arguments. */
311 gimple_build_call_internal (enum internal_fn fn
, unsigned nargs
, ...)
317 call
= gimple_build_call_internal_1 (fn
, nargs
);
318 va_start (ap
, nargs
);
319 for (i
= 0; i
< nargs
; i
++)
320 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
327 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
328 specified in vector ARGS. */
331 gimple_build_call_internal_vec (enum internal_fn fn
, vec
<tree
> args
)
336 nargs
= args
.length ();
337 call
= gimple_build_call_internal_1 (fn
, nargs
);
338 for (i
= 0; i
< nargs
; i
++)
339 gimple_call_set_arg (call
, i
, args
[i
]);
345 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
346 assumed to be in GIMPLE form already. Minimal checking is done of
350 gimple_build_call_from_tree (tree t
, tree fnptrtype
)
355 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
357 nargs
= call_expr_nargs (t
);
359 tree fndecl
= NULL_TREE
;
360 if (CALL_EXPR_FN (t
) == NULL_TREE
)
361 call
= gimple_build_call_internal_1 (CALL_EXPR_IFN (t
), nargs
);
364 fndecl
= get_callee_fndecl (t
);
365 call
= gimple_build_call_1 (fndecl
? fndecl
: CALL_EXPR_FN (t
), nargs
);
368 for (i
= 0; i
< nargs
; i
++)
369 gimple_call_set_arg (call
, i
, CALL_EXPR_ARG (t
, i
));
371 gimple_set_block (call
, TREE_BLOCK (t
));
372 gimple_set_location (call
, EXPR_LOCATION (t
));
374 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
375 gimple_call_set_chain (call
, CALL_EXPR_STATIC_CHAIN (t
));
376 gimple_call_set_tail (call
, CALL_EXPR_TAILCALL (t
));
377 gimple_call_set_must_tail (call
, CALL_EXPR_MUST_TAIL_CALL (t
));
378 gimple_call_set_return_slot_opt (call
, CALL_EXPR_RETURN_SLOT_OPT (t
));
380 && fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
)
381 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl
)))
382 gimple_call_set_alloca_for_var (call
, CALL_ALLOCA_FOR_VAR_P (t
));
384 gimple_call_set_from_thunk (call
, CALL_FROM_THUNK_P (t
));
385 gimple_call_set_va_arg_pack (call
, CALL_EXPR_VA_ARG_PACK (t
));
386 gimple_call_set_nothrow (call
, TREE_NOTHROW (t
));
387 gimple_call_set_by_descriptor (call
, CALL_EXPR_BY_DESCRIPTOR (t
));
388 gimple_set_no_warning (call
, TREE_NO_WARNING (t
));
392 gimple_call_set_fntype (call
, TREE_TYPE (fnptrtype
));
394 /* Check if it's an indirect CALL and the type has the
395 nocf_check attribute. In that case propagate the information
396 to the gimple CALL insn. */
399 gcc_assert (POINTER_TYPE_P (fnptrtype
));
400 tree fntype
= TREE_TYPE (fnptrtype
);
402 if (lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (fntype
)))
403 gimple_call_set_nocf_check (call
, TRUE
);
411 /* Build a GIMPLE_ASSIGN statement.
413 LHS of the assignment.
414 RHS of the assignment which can be unary or binary. */
417 gimple_build_assign (tree lhs
, tree rhs MEM_STAT_DECL
)
419 enum tree_code subcode
;
422 extract_ops_from_tree (rhs
, &subcode
, &op1
, &op2
, &op3
);
423 return gimple_build_assign (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
427 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
430 static inline gassign
*
431 gimple_build_assign_1 (tree lhs
, enum tree_code subcode
, tree op1
,
432 tree op2
, tree op3 MEM_STAT_DECL
)
437 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
439 num_ops
= get_gimple_rhs_num_ops (subcode
) + 1;
441 p
= as_a
<gassign
*> (
442 gimple_build_with_ops_stat (GIMPLE_ASSIGN
, (unsigned)subcode
, num_ops
444 gimple_assign_set_lhs (p
, lhs
);
445 gimple_assign_set_rhs1 (p
, op1
);
448 gcc_assert (num_ops
> 2);
449 gimple_assign_set_rhs2 (p
, op2
);
454 gcc_assert (num_ops
> 3);
455 gimple_assign_set_rhs3 (p
, op3
);
461 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
465 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
466 tree op2
, tree op3 MEM_STAT_DECL
)
468 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
471 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
475 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
476 tree op2 MEM_STAT_DECL
)
478 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, NULL_TREE
482 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
485 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1 MEM_STAT_DECL
)
487 return gimple_build_assign_1 (lhs
, subcode
, op1
, NULL_TREE
, NULL_TREE
492 /* Build a GIMPLE_COND statement.
494 PRED is the condition used to compare LHS and the RHS.
495 T_LABEL is the label to jump to if the condition is true.
496 F_LABEL is the label to jump to otherwise. */
499 gimple_build_cond (enum tree_code pred_code
, tree lhs
, tree rhs
,
500 tree t_label
, tree f_label
)
504 gcc_assert (TREE_CODE_CLASS (pred_code
) == tcc_comparison
);
505 p
= as_a
<gcond
*> (gimple_build_with_ops (GIMPLE_COND
, pred_code
, 4));
506 gimple_cond_set_lhs (p
, lhs
);
507 gimple_cond_set_rhs (p
, rhs
);
508 gimple_cond_set_true_label (p
, t_label
);
509 gimple_cond_set_false_label (p
, f_label
);
513 /* Build a GIMPLE_COND statement from the conditional expression tree
514 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
517 gimple_build_cond_from_tree (tree cond
, tree t_label
, tree f_label
)
522 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
523 return gimple_build_cond (code
, lhs
, rhs
, t_label
, f_label
);
526 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
527 boolean expression tree COND. */
530 gimple_cond_set_condition_from_tree (gcond
*stmt
, tree cond
)
535 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
536 gimple_cond_set_condition (stmt
, code
, lhs
, rhs
);
539 /* Build a GIMPLE_LABEL statement for LABEL. */
542 gimple_build_label (tree label
)
545 = as_a
<glabel
*> (gimple_build_with_ops (GIMPLE_LABEL
, ERROR_MARK
, 1));
546 gimple_label_set_label (p
, label
);
550 /* Build a GIMPLE_GOTO statement to label DEST. */
553 gimple_build_goto (tree dest
)
556 = as_a
<ggoto
*> (gimple_build_with_ops (GIMPLE_GOTO
, ERROR_MARK
, 1));
557 gimple_goto_set_dest (p
, dest
);
562 /* Build a GIMPLE_NOP statement. */
565 gimple_build_nop (void)
567 return gimple_alloc (GIMPLE_NOP
, 0);
571 /* Build a GIMPLE_BIND statement.
572 VARS are the variables in BODY.
573 BLOCK is the containing block. */
576 gimple_build_bind (tree vars
, gimple_seq body
, tree block
)
578 gbind
*p
= as_a
<gbind
*> (gimple_alloc (GIMPLE_BIND
, 0));
579 gimple_bind_set_vars (p
, vars
);
581 gimple_bind_set_body (p
, body
);
583 gimple_bind_set_block (p
, block
);
587 /* Helper function to set the simple fields of a asm stmt.
589 STRING is a pointer to a string that is the asm blocks assembly code.
590 NINPUT is the number of register inputs.
591 NOUTPUT is the number of register outputs.
592 NCLOBBERS is the number of clobbered registers.
596 gimple_build_asm_1 (const char *string
, unsigned ninputs
, unsigned noutputs
,
597 unsigned nclobbers
, unsigned nlabels
)
600 int size
= strlen (string
);
602 /* ASMs with labels cannot have outputs. This should have been
603 enforced by the front end. */
604 gcc_assert (nlabels
== 0 || noutputs
== 0);
607 gimple_build_with_ops (GIMPLE_ASM
, ERROR_MARK
,
608 ninputs
+ noutputs
+ nclobbers
+ nlabels
));
614 p
->string
= ggc_alloc_string (string
, size
);
616 if (GATHER_STATISTICS
)
617 gimple_alloc_sizes
[(int) gimple_alloc_kind (GIMPLE_ASM
)] += size
;
622 /* Build a GIMPLE_ASM statement.
624 STRING is the assembly code.
625 NINPUT is the number of register inputs.
626 NOUTPUT is the number of register outputs.
627 NCLOBBERS is the number of clobbered registers.
628 INPUTS is a vector of the input register parameters.
629 OUTPUTS is a vector of the output register parameters.
630 CLOBBERS is a vector of the clobbered register parameters.
631 LABELS is a vector of destination labels. */
634 gimple_build_asm_vec (const char *string
, vec
<tree
, va_gc
> *inputs
,
635 vec
<tree
, va_gc
> *outputs
, vec
<tree
, va_gc
> *clobbers
,
636 vec
<tree
, va_gc
> *labels
)
641 p
= gimple_build_asm_1 (string
,
642 vec_safe_length (inputs
),
643 vec_safe_length (outputs
),
644 vec_safe_length (clobbers
),
645 vec_safe_length (labels
));
647 for (i
= 0; i
< vec_safe_length (inputs
); i
++)
648 gimple_asm_set_input_op (p
, i
, (*inputs
)[i
]);
650 for (i
= 0; i
< vec_safe_length (outputs
); i
++)
651 gimple_asm_set_output_op (p
, i
, (*outputs
)[i
]);
653 for (i
= 0; i
< vec_safe_length (clobbers
); i
++)
654 gimple_asm_set_clobber_op (p
, i
, (*clobbers
)[i
]);
656 for (i
= 0; i
< vec_safe_length (labels
); i
++)
657 gimple_asm_set_label_op (p
, i
, (*labels
)[i
]);
662 /* Build a GIMPLE_CATCH statement.
664 TYPES are the catch types.
665 HANDLER is the exception handler. */
668 gimple_build_catch (tree types
, gimple_seq handler
)
670 gcatch
*p
= as_a
<gcatch
*> (gimple_alloc (GIMPLE_CATCH
, 0));
671 gimple_catch_set_types (p
, types
);
673 gimple_catch_set_handler (p
, handler
);
678 /* Build a GIMPLE_EH_FILTER statement.
680 TYPES are the filter's types.
681 FAILURE is the filter's failure action. */
684 gimple_build_eh_filter (tree types
, gimple_seq failure
)
686 geh_filter
*p
= as_a
<geh_filter
*> (gimple_alloc (GIMPLE_EH_FILTER
, 0));
687 gimple_eh_filter_set_types (p
, types
);
689 gimple_eh_filter_set_failure (p
, failure
);
694 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
697 gimple_build_eh_must_not_throw (tree decl
)
699 geh_mnt
*p
= as_a
<geh_mnt
*> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW
, 0));
701 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
702 gcc_assert (flags_from_decl_or_type (decl
) & ECF_NORETURN
);
703 gimple_eh_must_not_throw_set_fndecl (p
, decl
);
708 /* Build a GIMPLE_EH_ELSE statement. */
711 gimple_build_eh_else (gimple_seq n_body
, gimple_seq e_body
)
713 geh_else
*p
= as_a
<geh_else
*> (gimple_alloc (GIMPLE_EH_ELSE
, 0));
714 gimple_eh_else_set_n_body (p
, n_body
);
715 gimple_eh_else_set_e_body (p
, e_body
);
719 /* Build a GIMPLE_TRY statement.
721 EVAL is the expression to evaluate.
722 CLEANUP is the cleanup expression.
723 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
724 whether this is a try/catch or a try/finally respectively. */
727 gimple_build_try (gimple_seq eval
, gimple_seq cleanup
,
728 enum gimple_try_flags kind
)
732 gcc_assert (kind
== GIMPLE_TRY_CATCH
|| kind
== GIMPLE_TRY_FINALLY
);
733 p
= as_a
<gtry
*> (gimple_alloc (GIMPLE_TRY
, 0));
734 gimple_set_subcode (p
, kind
);
736 gimple_try_set_eval (p
, eval
);
738 gimple_try_set_cleanup (p
, cleanup
);
743 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
745 CLEANUP is the cleanup expression. */
748 gimple_build_wce (gimple_seq cleanup
)
750 gimple
*p
= gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR
, 0);
752 gimple_wce_set_cleanup (p
, cleanup
);
758 /* Build a GIMPLE_RESX statement. */
761 gimple_build_resx (int region
)
764 = as_a
<gresx
*> (gimple_build_with_ops (GIMPLE_RESX
, ERROR_MARK
, 0));
770 /* The helper for constructing a gimple switch statement.
771 INDEX is the switch's index.
772 NLABELS is the number of labels in the switch excluding the default.
773 DEFAULT_LABEL is the default label for the switch statement. */
776 gimple_build_switch_nlabels (unsigned nlabels
, tree index
, tree default_label
)
778 /* nlabels + 1 default label + 1 index. */
779 gcc_checking_assert (default_label
);
780 gswitch
*p
= as_a
<gswitch
*> (gimple_build_with_ops (GIMPLE_SWITCH
,
783 gimple_switch_set_index (p
, index
);
784 gimple_switch_set_default_label (p
, default_label
);
788 /* Build a GIMPLE_SWITCH statement.
790 INDEX is the switch's index.
791 DEFAULT_LABEL is the default label
792 ARGS is a vector of labels excluding the default. */
795 gimple_build_switch (tree index
, tree default_label
, vec
<tree
> args
)
797 unsigned i
, nlabels
= args
.length ();
799 gswitch
*p
= gimple_build_switch_nlabels (nlabels
, index
, default_label
);
801 /* Copy the labels from the vector to the switch statement. */
802 for (i
= 0; i
< nlabels
; i
++)
803 gimple_switch_set_label (p
, i
+ 1, args
[i
]);
808 /* Build a GIMPLE_EH_DISPATCH statement. */
811 gimple_build_eh_dispatch (int region
)
814 = as_a
<geh_dispatch
*> (
815 gimple_build_with_ops (GIMPLE_EH_DISPATCH
, ERROR_MARK
, 0));
820 /* Build a new GIMPLE_DEBUG_BIND statement.
822 VAR is bound to VALUE; block and location are taken from STMT. */
825 gimple_build_debug_bind (tree var
, tree value
, gimple
*stmt MEM_STAT_DECL
)
828 = as_a
<gdebug
*> (gimple_build_with_ops_stat (GIMPLE_DEBUG
,
829 (unsigned)GIMPLE_DEBUG_BIND
, 2
831 gimple_debug_bind_set_var (p
, var
);
832 gimple_debug_bind_set_value (p
, value
);
834 gimple_set_location (p
, gimple_location (stmt
));
840 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
842 VAR is bound to VALUE; block and location are taken from STMT. */
845 gimple_build_debug_source_bind (tree var
, tree value
,
846 gimple
*stmt MEM_STAT_DECL
)
850 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
851 (unsigned)GIMPLE_DEBUG_SOURCE_BIND
, 2
854 gimple_debug_source_bind_set_var (p
, var
);
855 gimple_debug_source_bind_set_value (p
, value
);
857 gimple_set_location (p
, gimple_location (stmt
));
863 /* Build a new GIMPLE_DEBUG_BEGIN_STMT statement in BLOCK at
867 gimple_build_debug_begin_stmt (tree block
, location_t location
872 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
873 (unsigned)GIMPLE_DEBUG_BEGIN_STMT
, 0
876 gimple_set_location (p
, location
);
877 gimple_set_block (p
, block
);
878 cfun
->debug_marker_count
++;
884 /* Build a new GIMPLE_DEBUG_INLINE_ENTRY statement in BLOCK at
885 LOCATION. The BLOCK links to the inlined function. */
888 gimple_build_debug_inline_entry (tree block
, location_t location
893 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
894 (unsigned)GIMPLE_DEBUG_INLINE_ENTRY
, 0
897 gimple_set_location (p
, location
);
898 gimple_set_block (p
, block
);
899 cfun
->debug_marker_count
++;
905 /* Build a GIMPLE_OMP_CRITICAL statement.
907 BODY is the sequence of statements for which only one thread can execute.
908 NAME is optional identifier for this critical block.
909 CLAUSES are clauses for this critical block. */
912 gimple_build_omp_critical (gimple_seq body
, tree name
, tree clauses
)
915 = as_a
<gomp_critical
*> (gimple_alloc (GIMPLE_OMP_CRITICAL
, 0));
916 gimple_omp_critical_set_name (p
, name
);
917 gimple_omp_critical_set_clauses (p
, clauses
);
919 gimple_omp_set_body (p
, body
);
924 /* Build a GIMPLE_OMP_FOR statement.
926 BODY is sequence of statements inside the for loop.
927 KIND is the `for' variant.
928 CLAUSES are any of the construct's clauses.
929 COLLAPSE is the collapse count.
930 PRE_BODY is the sequence of statements that are loop invariant. */
933 gimple_build_omp_for (gimple_seq body
, int kind
, tree clauses
, size_t collapse
,
936 gomp_for
*p
= as_a
<gomp_for
*> (gimple_alloc (GIMPLE_OMP_FOR
, 0));
938 gimple_omp_set_body (p
, body
);
939 gimple_omp_for_set_clauses (p
, clauses
);
940 gimple_omp_for_set_kind (p
, kind
);
941 p
->collapse
= collapse
;
942 p
->iter
= ggc_cleared_vec_alloc
<gimple_omp_for_iter
> (collapse
);
945 gimple_omp_for_set_pre_body (p
, pre_body
);
951 /* Build a GIMPLE_OMP_PARALLEL statement.
953 BODY is sequence of statements which are executed in parallel.
954 CLAUSES are the OMP parallel construct's clauses.
955 CHILD_FN is the function created for the parallel threads to execute.
956 DATA_ARG are the shared data argument(s). */
959 gimple_build_omp_parallel (gimple_seq body
, tree clauses
, tree child_fn
,
963 = as_a
<gomp_parallel
*> (gimple_alloc (GIMPLE_OMP_PARALLEL
, 0));
965 gimple_omp_set_body (p
, body
);
966 gimple_omp_parallel_set_clauses (p
, clauses
);
967 gimple_omp_parallel_set_child_fn (p
, child_fn
);
968 gimple_omp_parallel_set_data_arg (p
, data_arg
);
974 /* Build a GIMPLE_OMP_TASK statement.
976 BODY is sequence of statements which are executed by the explicit task.
977 CLAUSES are the OMP task construct's clauses.
978 CHILD_FN is the function created for the parallel threads to execute.
979 DATA_ARG are the shared data argument(s).
980 COPY_FN is the optional function for firstprivate initialization.
981 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
984 gimple_build_omp_task (gimple_seq body
, tree clauses
, tree child_fn
,
985 tree data_arg
, tree copy_fn
, tree arg_size
,
988 gomp_task
*p
= as_a
<gomp_task
*> (gimple_alloc (GIMPLE_OMP_TASK
, 0));
990 gimple_omp_set_body (p
, body
);
991 gimple_omp_task_set_clauses (p
, clauses
);
992 gimple_omp_task_set_child_fn (p
, child_fn
);
993 gimple_omp_task_set_data_arg (p
, data_arg
);
994 gimple_omp_task_set_copy_fn (p
, copy_fn
);
995 gimple_omp_task_set_arg_size (p
, arg_size
);
996 gimple_omp_task_set_arg_align (p
, arg_align
);
1002 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
1004 BODY is the sequence of statements in the section. */
1007 gimple_build_omp_section (gimple_seq body
)
1009 gimple
*p
= gimple_alloc (GIMPLE_OMP_SECTION
, 0);
1011 gimple_omp_set_body (p
, body
);
1017 /* Build a GIMPLE_OMP_MASTER statement.
1019 BODY is the sequence of statements to be executed by just the master. */
1022 gimple_build_omp_master (gimple_seq body
)
1024 gimple
*p
= gimple_alloc (GIMPLE_OMP_MASTER
, 0);
1026 gimple_omp_set_body (p
, body
);
1031 /* Build a GIMPLE_OMP_GRID_BODY statement.
1033 BODY is the sequence of statements to be executed by the kernel. */
1036 gimple_build_omp_grid_body (gimple_seq body
)
1038 gimple
*p
= gimple_alloc (GIMPLE_OMP_GRID_BODY
, 0);
1040 gimple_omp_set_body (p
, body
);
1045 /* Build a GIMPLE_OMP_TASKGROUP statement.
1047 BODY is the sequence of statements to be executed by the taskgroup
1049 CLAUSES are any of the construct's clauses. */
1052 gimple_build_omp_taskgroup (gimple_seq body
, tree clauses
)
1054 gimple
*p
= gimple_alloc (GIMPLE_OMP_TASKGROUP
, 0);
1055 gimple_omp_taskgroup_set_clauses (p
, clauses
);
1057 gimple_omp_set_body (p
, body
);
1063 /* Build a GIMPLE_OMP_CONTINUE statement.
1065 CONTROL_DEF is the definition of the control variable.
1066 CONTROL_USE is the use of the control variable. */
1069 gimple_build_omp_continue (tree control_def
, tree control_use
)
1072 = as_a
<gomp_continue
*> (gimple_alloc (GIMPLE_OMP_CONTINUE
, 0));
1073 gimple_omp_continue_set_control_def (p
, control_def
);
1074 gimple_omp_continue_set_control_use (p
, control_use
);
1078 /* Build a GIMPLE_OMP_ORDERED statement.
1080 BODY is the sequence of statements inside a loop that will executed in
1082 CLAUSES are clauses for this statement. */
1085 gimple_build_omp_ordered (gimple_seq body
, tree clauses
)
1088 = as_a
<gomp_ordered
*> (gimple_alloc (GIMPLE_OMP_ORDERED
, 0));
1089 gimple_omp_ordered_set_clauses (p
, clauses
);
1091 gimple_omp_set_body (p
, body
);
1097 /* Build a GIMPLE_OMP_RETURN statement.
1098 WAIT_P is true if this is a non-waiting return. */
1101 gimple_build_omp_return (bool wait_p
)
1103 gimple
*p
= gimple_alloc (GIMPLE_OMP_RETURN
, 0);
1105 gimple_omp_return_set_nowait (p
);
1111 /* Build a GIMPLE_OMP_SCAN statement.
1113 BODY is the sequence of statements to be executed by the scan
1115 CLAUSES are any of the construct's clauses. */
1118 gimple_build_omp_scan (gimple_seq body
, tree clauses
)
1121 = as_a
<gomp_scan
*> (gimple_alloc (GIMPLE_OMP_SCAN
, 0));
1122 gimple_omp_scan_set_clauses (p
, clauses
);
1124 gimple_omp_set_body (p
, body
);
1130 /* Build a GIMPLE_OMP_SECTIONS statement.
1132 BODY is a sequence of section statements.
1133 CLAUSES are any of the OMP sections contsruct's clauses: private,
1134 firstprivate, lastprivate, reduction, and nowait. */
1137 gimple_build_omp_sections (gimple_seq body
, tree clauses
)
1140 = as_a
<gomp_sections
*> (gimple_alloc (GIMPLE_OMP_SECTIONS
, 0));
1142 gimple_omp_set_body (p
, body
);
1143 gimple_omp_sections_set_clauses (p
, clauses
);
1149 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1152 gimple_build_omp_sections_switch (void)
1154 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH
, 0);
1158 /* Build a GIMPLE_OMP_SINGLE statement.
1160 BODY is the sequence of statements that will be executed once.
1161 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1162 copyprivate, nowait. */
1165 gimple_build_omp_single (gimple_seq body
, tree clauses
)
1168 = as_a
<gomp_single
*> (gimple_alloc (GIMPLE_OMP_SINGLE
, 0));
1170 gimple_omp_set_body (p
, body
);
1171 gimple_omp_single_set_clauses (p
, clauses
);
1177 /* Build a GIMPLE_OMP_TARGET statement.
1179 BODY is the sequence of statements that will be executed.
1180 KIND is the kind of the region.
1181 CLAUSES are any of the construct's clauses. */
1184 gimple_build_omp_target (gimple_seq body
, int kind
, tree clauses
)
1187 = as_a
<gomp_target
*> (gimple_alloc (GIMPLE_OMP_TARGET
, 0));
1189 gimple_omp_set_body (p
, body
);
1190 gimple_omp_target_set_clauses (p
, clauses
);
1191 gimple_omp_target_set_kind (p
, kind
);
1197 /* Build a GIMPLE_OMP_TEAMS statement.
1199 BODY is the sequence of statements that will be executed.
1200 CLAUSES are any of the OMP teams construct's clauses. */
1203 gimple_build_omp_teams (gimple_seq body
, tree clauses
)
1205 gomp_teams
*p
= as_a
<gomp_teams
*> (gimple_alloc (GIMPLE_OMP_TEAMS
, 0));
1207 gimple_omp_set_body (p
, body
);
1208 gimple_omp_teams_set_clauses (p
, clauses
);
1214 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1217 gimple_build_omp_atomic_load (tree lhs
, tree rhs
, enum omp_memory_order mo
)
1220 = as_a
<gomp_atomic_load
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD
, 0));
1221 gimple_omp_atomic_load_set_lhs (p
, lhs
);
1222 gimple_omp_atomic_load_set_rhs (p
, rhs
);
1223 gimple_omp_atomic_set_memory_order (p
, mo
);
1227 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1229 VAL is the value we are storing. */
1232 gimple_build_omp_atomic_store (tree val
, enum omp_memory_order mo
)
1234 gomp_atomic_store
*p
1235 = as_a
<gomp_atomic_store
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE
, 0));
1236 gimple_omp_atomic_store_set_val (p
, val
);
1237 gimple_omp_atomic_set_memory_order (p
, mo
);
1241 /* Build a GIMPLE_TRANSACTION statement. */
1244 gimple_build_transaction (gimple_seq body
)
1247 = as_a
<gtransaction
*> (gimple_alloc (GIMPLE_TRANSACTION
, 0));
1248 gimple_transaction_set_body (p
, body
);
1249 gimple_transaction_set_label_norm (p
, 0);
1250 gimple_transaction_set_label_uninst (p
, 0);
1251 gimple_transaction_set_label_over (p
, 0);
1255 #if defined ENABLE_GIMPLE_CHECKING
1256 /* Complain of a gimple type mismatch and die. */
1259 gimple_check_failed (const gimple
*gs
, const char *file
, int line
,
1260 const char *function
, enum gimple_code code
,
1261 enum tree_code subcode
)
1263 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1264 gimple_code_name
[code
],
1265 get_tree_code_name (subcode
),
1266 gimple_code_name
[gimple_code (gs
)],
1268 ? get_tree_code_name ((enum tree_code
) gs
->subcode
)
1270 function
, trim_filename (file
), line
);
1272 #endif /* ENABLE_GIMPLE_CHECKING */
1275 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1276 *SEQ_P is NULL, a new sequence is allocated. */
1279 gimple_seq_add_stmt (gimple_seq
*seq_p
, gimple
*gs
)
1281 gimple_stmt_iterator si
;
1285 si
= gsi_last (*seq_p
);
1286 gsi_insert_after (&si
, gs
, GSI_NEW_STMT
);
1289 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1290 *SEQ_P is NULL, a new sequence is allocated. This function is
1291 similar to gimple_seq_add_stmt, but does not scan the operands.
1292 During gimplification, we need to manipulate statement sequences
1293 before the def/use vectors have been constructed. */
1296 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple
*gs
)
1298 gimple_stmt_iterator si
;
1303 si
= gsi_last (*seq_p
);
1304 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
1307 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1308 NULL, a new sequence is allocated. */
1311 gimple_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
1313 gimple_stmt_iterator si
;
1317 si
= gsi_last (*dst_p
);
1318 gsi_insert_seq_after (&si
, src
, GSI_NEW_STMT
);
1321 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1322 NULL, a new sequence is allocated. This function is
1323 similar to gimple_seq_add_seq, but does not scan the operands. */
1326 gimple_seq_add_seq_without_update (gimple_seq
*dst_p
, gimple_seq src
)
1328 gimple_stmt_iterator si
;
1332 si
= gsi_last (*dst_p
);
1333 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
1336 /* Determine whether to assign a location to the statement GS. */
1339 should_carry_location_p (gimple
*gs
)
1341 /* Don't emit a line note for a label. We particularly don't want to
1342 emit one for the break label, since it doesn't actually correspond
1343 to the beginning of the loop/switch. */
1344 if (gimple_code (gs
) == GIMPLE_LABEL
)
1350 /* Set the location for gimple statement GS to LOCATION. */
1353 annotate_one_with_location (gimple
*gs
, location_t location
)
1355 if (!gimple_has_location (gs
)
1356 && !gimple_do_not_emit_location_p (gs
)
1357 && should_carry_location_p (gs
))
1358 gimple_set_location (gs
, location
);
1361 /* Set LOCATION for all the statements after iterator GSI in sequence
1362 SEQ. If GSI is pointing to the end of the sequence, start with the
1363 first statement in SEQ. */
1366 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
1367 location_t location
)
1369 if (gsi_end_p (gsi
))
1370 gsi
= gsi_start (seq
);
1374 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
1375 annotate_one_with_location (gsi_stmt (gsi
), location
);
1378 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1381 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
1383 gimple_stmt_iterator i
;
1385 if (gimple_seq_empty_p (stmt_p
))
1388 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
1390 gimple
*gs
= gsi_stmt (i
);
1391 annotate_one_with_location (gs
, location
);
1395 /* Helper function of empty_body_p. Return true if STMT is an empty
1399 empty_stmt_p (gimple
*stmt
)
1401 if (gimple_code (stmt
) == GIMPLE_NOP
)
1403 if (gbind
*bind_stmt
= dyn_cast
<gbind
*> (stmt
))
1404 return empty_body_p (gimple_bind_body (bind_stmt
));
1409 /* Return true if BODY contains nothing but empty statements. */
1412 empty_body_p (gimple_seq body
)
1414 gimple_stmt_iterator i
;
1416 if (gimple_seq_empty_p (body
))
1418 for (i
= gsi_start (body
); !gsi_end_p (i
); gsi_next (&i
))
1419 if (!empty_stmt_p (gsi_stmt (i
))
1420 && !is_gimple_debug (gsi_stmt (i
)))
1427 /* Perform a deep copy of sequence SRC and return the result. */
1430 gimple_seq_copy (gimple_seq src
)
1432 gimple_stmt_iterator gsi
;
1433 gimple_seq new_seq
= NULL
;
1436 for (gsi
= gsi_start (src
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1438 stmt
= gimple_copy (gsi_stmt (gsi
));
1439 gimple_seq_add_stmt (&new_seq
, stmt
);
1447 /* Return true if calls C1 and C2 are known to go to the same function. */
1450 gimple_call_same_target_p (const gimple
*c1
, const gimple
*c2
)
1452 if (gimple_call_internal_p (c1
))
1453 return (gimple_call_internal_p (c2
)
1454 && gimple_call_internal_fn (c1
) == gimple_call_internal_fn (c2
)
1455 && (!gimple_call_internal_unique_p (as_a
<const gcall
*> (c1
))
1458 return (gimple_call_fn (c1
) == gimple_call_fn (c2
)
1459 || (gimple_call_fndecl (c1
)
1460 && gimple_call_fndecl (c1
) == gimple_call_fndecl (c2
)));
1463 /* Detect flags from a GIMPLE_CALL. This is just like
1464 call_expr_flags, but for gimple tuples. */
1467 gimple_call_flags (const gimple
*stmt
)
1471 if (gimple_call_internal_p (stmt
))
1472 flags
= internal_fn_flags (gimple_call_internal_fn (stmt
));
1475 tree decl
= gimple_call_fndecl (stmt
);
1477 flags
= flags_from_decl_or_type (decl
);
1478 flags
|= flags_from_decl_or_type (gimple_call_fntype (stmt
));
1481 if (stmt
->subcode
& GF_CALL_NOTHROW
)
1482 flags
|= ECF_NOTHROW
;
1484 if (stmt
->subcode
& GF_CALL_BY_DESCRIPTOR
)
1485 flags
|= ECF_BY_DESCRIPTOR
;
1490 /* Return the "fn spec" string for call STMT. */
1493 gimple_call_fnspec (const gcall
*stmt
)
1497 if (gimple_call_internal_p (stmt
))
1498 return internal_fn_fnspec (gimple_call_internal_fn (stmt
));
1500 type
= gimple_call_fntype (stmt
);
1504 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
1508 return TREE_VALUE (TREE_VALUE (attr
));
1511 /* Detects argument flags for argument number ARG on call STMT. */
1514 gimple_call_arg_flags (const gcall
*stmt
, unsigned arg
)
1516 const_tree attr
= gimple_call_fnspec (stmt
);
1518 if (!attr
|| 1 + arg
>= (unsigned) TREE_STRING_LENGTH (attr
))
1521 switch (TREE_STRING_POINTER (attr
)[1 + arg
])
1528 return EAF_DIRECT
| EAF_NOCLOBBER
| EAF_NOESCAPE
;
1531 return EAF_NOCLOBBER
| EAF_NOESCAPE
;
1534 return EAF_DIRECT
| EAF_NOESCAPE
;
1537 return EAF_NOESCAPE
;
1545 /* Detects return flags for the call STMT. */
1548 gimple_call_return_flags (const gcall
*stmt
)
1552 if (gimple_call_flags (stmt
) & ECF_MALLOC
)
1555 attr
= gimple_call_fnspec (stmt
);
1556 if (!attr
|| TREE_STRING_LENGTH (attr
) < 1)
1559 switch (TREE_STRING_POINTER (attr
)[0])
1565 return ERF_RETURNS_ARG
| (TREE_STRING_POINTER (attr
)[0] - '1');
1577 /* Return true if call STMT is known to return a non-zero result. */
1580 gimple_call_nonnull_result_p (gcall
*call
)
1582 tree fndecl
= gimple_call_fndecl (call
);
1585 if (flag_delete_null_pointer_checks
&& !flag_check_new
1586 && DECL_IS_OPERATOR_NEW_P (fndecl
)
1587 && !TREE_NOTHROW (fndecl
))
1590 /* References are always non-NULL. */
1591 if (flag_delete_null_pointer_checks
1592 && TREE_CODE (TREE_TYPE (fndecl
)) == REFERENCE_TYPE
)
1595 if (flag_delete_null_pointer_checks
1596 && lookup_attribute ("returns_nonnull",
1597 TYPE_ATTRIBUTES (gimple_call_fntype (call
))))
1599 return gimple_alloca_call_p (call
);
1603 /* If CALL returns a non-null result in an argument, return that arg. */
1606 gimple_call_nonnull_arg (gcall
*call
)
1608 tree fndecl
= gimple_call_fndecl (call
);
1612 unsigned rf
= gimple_call_return_flags (call
);
1613 if (rf
& ERF_RETURNS_ARG
)
1615 unsigned argnum
= rf
& ERF_RETURN_ARG_MASK
;
1616 if (argnum
< gimple_call_num_args (call
))
1618 tree arg
= gimple_call_arg (call
, argnum
);
1620 && infer_nonnull_range_by_attribute (call
, arg
))
1628 /* Return true if GS is a copy assignment. */
1631 gimple_assign_copy_p (gimple
*gs
)
1633 return (gimple_assign_single_p (gs
)
1634 && is_gimple_val (gimple_op (gs
, 1)));
1638 /* Return true if GS is a SSA_NAME copy assignment. */
1641 gimple_assign_ssa_name_copy_p (gimple
*gs
)
1643 return (gimple_assign_single_p (gs
)
1644 && TREE_CODE (gimple_assign_lhs (gs
)) == SSA_NAME
1645 && TREE_CODE (gimple_assign_rhs1 (gs
)) == SSA_NAME
);
1649 /* Return true if GS is an assignment with a unary RHS, but the
1650 operator has no effect on the assigned value. The logic is adapted
1651 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1652 instances in which STRIP_NOPS was previously applied to the RHS of
1655 NOTE: In the use cases that led to the creation of this function
1656 and of gimple_assign_single_p, it is typical to test for either
1657 condition and to proceed in the same manner. In each case, the
1658 assigned value is represented by the single RHS operand of the
1659 assignment. I suspect there may be cases where gimple_assign_copy_p,
1660 gimple_assign_single_p, or equivalent logic is used where a similar
1661 treatment of unary NOPs is appropriate. */
1664 gimple_assign_unary_nop_p (gimple
*gs
)
1666 return (is_gimple_assign (gs
)
1667 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs
))
1668 || gimple_assign_rhs_code (gs
) == NON_LVALUE_EXPR
)
1669 && gimple_assign_rhs1 (gs
) != error_mark_node
1670 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs
)))
1671 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs
)))));
1674 /* Set BB to be the basic block holding G. */
1677 gimple_set_bb (gimple
*stmt
, basic_block bb
)
1681 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1684 /* If the statement is a label, add the label to block-to-labels map
1685 so that we can speed up edge creation for GIMPLE_GOTOs. */
1691 t
= gimple_label_label (as_a
<glabel
*> (stmt
));
1692 uid
= LABEL_DECL_UID (t
);
1696 vec_safe_length (label_to_block_map_for_fn (cfun
));
1697 LABEL_DECL_UID (t
) = uid
= cfun
->cfg
->last_label_uid
++;
1698 if (old_len
<= (unsigned) uid
)
1700 unsigned new_len
= 3 * uid
/ 2 + 1;
1702 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun
),
1707 (*label_to_block_map_for_fn (cfun
))[uid
] = bb
;
1712 /* Modify the RHS of the assignment pointed-to by GSI using the
1713 operands in the expression tree EXPR.
1715 NOTE: The statement pointed-to by GSI may be reallocated if it
1716 did not have enough operand slots.
1718 This function is useful to convert an existing tree expression into
1719 the flat representation used for the RHS of a GIMPLE assignment.
1720 It will reallocate memory as needed to expand or shrink the number
1721 of operand slots needed to represent EXPR.
1723 NOTE: If you find yourself building a tree and then calling this
1724 function, you are most certainly doing it the slow way. It is much
1725 better to build a new assignment or to use the function
1726 gimple_assign_set_rhs_with_ops, which does not require an
1727 expression tree to be built. */
1730 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*gsi
, tree expr
)
1732 enum tree_code subcode
;
1735 extract_ops_from_tree (expr
, &subcode
, &op1
, &op2
, &op3
);
1736 gimple_assign_set_rhs_with_ops (gsi
, subcode
, op1
, op2
, op3
);
1740 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1741 operands OP1, OP2 and OP3.
1743 NOTE: The statement pointed-to by GSI may be reallocated if it
1744 did not have enough operand slots. */
1747 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*gsi
, enum tree_code code
,
1748 tree op1
, tree op2
, tree op3
)
1750 unsigned new_rhs_ops
= get_gimple_rhs_num_ops (code
);
1751 gimple
*stmt
= gsi_stmt (*gsi
);
1752 gimple
*old_stmt
= stmt
;
1754 /* If the new CODE needs more operands, allocate a new statement. */
1755 if (gimple_num_ops (stmt
) < new_rhs_ops
+ 1)
1757 tree lhs
= gimple_assign_lhs (old_stmt
);
1758 stmt
= gimple_alloc (gimple_code (old_stmt
), new_rhs_ops
+ 1);
1759 memcpy (stmt
, old_stmt
, gimple_size (gimple_code (old_stmt
)));
1760 gimple_init_singleton (stmt
);
1762 /* The LHS needs to be reset as this also changes the SSA name
1764 gimple_assign_set_lhs (stmt
, lhs
);
1767 gimple_set_num_ops (stmt
, new_rhs_ops
+ 1);
1768 gimple_set_subcode (stmt
, code
);
1769 gimple_assign_set_rhs1 (stmt
, op1
);
1770 if (new_rhs_ops
> 1)
1771 gimple_assign_set_rhs2 (stmt
, op2
);
1772 if (new_rhs_ops
> 2)
1773 gimple_assign_set_rhs3 (stmt
, op3
);
1774 if (stmt
!= old_stmt
)
1775 gsi_replace (gsi
, stmt
, false);
1779 /* Return the LHS of a statement that performs an assignment,
1780 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1781 for a call to a function that returns no value, or for a
1782 statement other than an assignment or a call. */
1785 gimple_get_lhs (const gimple
*stmt
)
1787 enum gimple_code code
= gimple_code (stmt
);
1789 if (code
== GIMPLE_ASSIGN
)
1790 return gimple_assign_lhs (stmt
);
1791 else if (code
== GIMPLE_CALL
)
1792 return gimple_call_lhs (stmt
);
1798 /* Set the LHS of a statement that performs an assignment,
1799 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1802 gimple_set_lhs (gimple
*stmt
, tree lhs
)
1804 enum gimple_code code
= gimple_code (stmt
);
1806 if (code
== GIMPLE_ASSIGN
)
1807 gimple_assign_set_lhs (stmt
, lhs
);
1808 else if (code
== GIMPLE_CALL
)
1809 gimple_call_set_lhs (stmt
, lhs
);
1815 /* Return a deep copy of statement STMT. All the operands from STMT
1816 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1817 and VUSE operand arrays are set to empty in the new copy. The new
1818 copy isn't part of any sequence. */
1821 gimple_copy (gimple
*stmt
)
1823 enum gimple_code code
= gimple_code (stmt
);
1824 unsigned num_ops
= gimple_num_ops (stmt
);
1825 gimple
*copy
= gimple_alloc (code
, num_ops
);
1828 /* Shallow copy all the fields from STMT. */
1829 memcpy (copy
, stmt
, gimple_size (code
));
1830 gimple_init_singleton (copy
);
1832 /* If STMT has sub-statements, deep-copy them as well. */
1833 if (gimple_has_substatements (stmt
))
1838 switch (gimple_code (stmt
))
1842 gbind
*bind_stmt
= as_a
<gbind
*> (stmt
);
1843 gbind
*bind_copy
= as_a
<gbind
*> (copy
);
1844 new_seq
= gimple_seq_copy (gimple_bind_body (bind_stmt
));
1845 gimple_bind_set_body (bind_copy
, new_seq
);
1846 gimple_bind_set_vars (bind_copy
,
1847 unshare_expr (gimple_bind_vars (bind_stmt
)));
1848 gimple_bind_set_block (bind_copy
, gimple_bind_block (bind_stmt
));
1854 gcatch
*catch_stmt
= as_a
<gcatch
*> (stmt
);
1855 gcatch
*catch_copy
= as_a
<gcatch
*> (copy
);
1856 new_seq
= gimple_seq_copy (gimple_catch_handler (catch_stmt
));
1857 gimple_catch_set_handler (catch_copy
, new_seq
);
1858 t
= unshare_expr (gimple_catch_types (catch_stmt
));
1859 gimple_catch_set_types (catch_copy
, t
);
1863 case GIMPLE_EH_FILTER
:
1865 geh_filter
*eh_filter_stmt
= as_a
<geh_filter
*> (stmt
);
1866 geh_filter
*eh_filter_copy
= as_a
<geh_filter
*> (copy
);
1868 = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt
));
1869 gimple_eh_filter_set_failure (eh_filter_copy
, new_seq
);
1870 t
= unshare_expr (gimple_eh_filter_types (eh_filter_stmt
));
1871 gimple_eh_filter_set_types (eh_filter_copy
, t
);
1875 case GIMPLE_EH_ELSE
:
1877 geh_else
*eh_else_stmt
= as_a
<geh_else
*> (stmt
);
1878 geh_else
*eh_else_copy
= as_a
<geh_else
*> (copy
);
1879 new_seq
= gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt
));
1880 gimple_eh_else_set_n_body (eh_else_copy
, new_seq
);
1881 new_seq
= gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt
));
1882 gimple_eh_else_set_e_body (eh_else_copy
, new_seq
);
1888 gtry
*try_stmt
= as_a
<gtry
*> (stmt
);
1889 gtry
*try_copy
= as_a
<gtry
*> (copy
);
1890 new_seq
= gimple_seq_copy (gimple_try_eval (try_stmt
));
1891 gimple_try_set_eval (try_copy
, new_seq
);
1892 new_seq
= gimple_seq_copy (gimple_try_cleanup (try_stmt
));
1893 gimple_try_set_cleanup (try_copy
, new_seq
);
1897 case GIMPLE_OMP_FOR
:
1898 new_seq
= gimple_seq_copy (gimple_omp_for_pre_body (stmt
));
1899 gimple_omp_for_set_pre_body (copy
, new_seq
);
1900 t
= unshare_expr (gimple_omp_for_clauses (stmt
));
1901 gimple_omp_for_set_clauses (copy
, t
);
1903 gomp_for
*omp_for_copy
= as_a
<gomp_for
*> (copy
);
1904 omp_for_copy
->iter
= ggc_vec_alloc
<gimple_omp_for_iter
>
1905 ( gimple_omp_for_collapse (stmt
));
1907 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1909 gimple_omp_for_set_cond (copy
, i
,
1910 gimple_omp_for_cond (stmt
, i
));
1911 gimple_omp_for_set_index (copy
, i
,
1912 gimple_omp_for_index (stmt
, i
));
1913 t
= unshare_expr (gimple_omp_for_initial (stmt
, i
));
1914 gimple_omp_for_set_initial (copy
, i
, t
);
1915 t
= unshare_expr (gimple_omp_for_final (stmt
, i
));
1916 gimple_omp_for_set_final (copy
, i
, t
);
1917 t
= unshare_expr (gimple_omp_for_incr (stmt
, i
));
1918 gimple_omp_for_set_incr (copy
, i
, t
);
1922 case GIMPLE_OMP_PARALLEL
:
1924 gomp_parallel
*omp_par_stmt
= as_a
<gomp_parallel
*> (stmt
);
1925 gomp_parallel
*omp_par_copy
= as_a
<gomp_parallel
*> (copy
);
1926 t
= unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt
));
1927 gimple_omp_parallel_set_clauses (omp_par_copy
, t
);
1928 t
= unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt
));
1929 gimple_omp_parallel_set_child_fn (omp_par_copy
, t
);
1930 t
= unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt
));
1931 gimple_omp_parallel_set_data_arg (omp_par_copy
, t
);
1935 case GIMPLE_OMP_TASK
:
1936 t
= unshare_expr (gimple_omp_task_clauses (stmt
));
1937 gimple_omp_task_set_clauses (copy
, t
);
1938 t
= unshare_expr (gimple_omp_task_child_fn (stmt
));
1939 gimple_omp_task_set_child_fn (copy
, t
);
1940 t
= unshare_expr (gimple_omp_task_data_arg (stmt
));
1941 gimple_omp_task_set_data_arg (copy
, t
);
1942 t
= unshare_expr (gimple_omp_task_copy_fn (stmt
));
1943 gimple_omp_task_set_copy_fn (copy
, t
);
1944 t
= unshare_expr (gimple_omp_task_arg_size (stmt
));
1945 gimple_omp_task_set_arg_size (copy
, t
);
1946 t
= unshare_expr (gimple_omp_task_arg_align (stmt
));
1947 gimple_omp_task_set_arg_align (copy
, t
);
1950 case GIMPLE_OMP_CRITICAL
:
1951 t
= unshare_expr (gimple_omp_critical_name
1952 (as_a
<gomp_critical
*> (stmt
)));
1953 gimple_omp_critical_set_name (as_a
<gomp_critical
*> (copy
), t
);
1954 t
= unshare_expr (gimple_omp_critical_clauses
1955 (as_a
<gomp_critical
*> (stmt
)));
1956 gimple_omp_critical_set_clauses (as_a
<gomp_critical
*> (copy
), t
);
1959 case GIMPLE_OMP_ORDERED
:
1960 t
= unshare_expr (gimple_omp_ordered_clauses
1961 (as_a
<gomp_ordered
*> (stmt
)));
1962 gimple_omp_ordered_set_clauses (as_a
<gomp_ordered
*> (copy
), t
);
1965 case GIMPLE_OMP_SCAN
:
1966 t
= gimple_omp_scan_clauses (as_a
<gomp_scan
*> (stmt
));
1967 t
= unshare_expr (t
);
1968 gimple_omp_scan_set_clauses (as_a
<gomp_scan
*> (copy
), t
);
1971 case GIMPLE_OMP_TASKGROUP
:
1972 t
= unshare_expr (gimple_omp_taskgroup_clauses (stmt
));
1973 gimple_omp_taskgroup_set_clauses (copy
, t
);
1976 case GIMPLE_OMP_SECTIONS
:
1977 t
= unshare_expr (gimple_omp_sections_clauses (stmt
));
1978 gimple_omp_sections_set_clauses (copy
, t
);
1979 t
= unshare_expr (gimple_omp_sections_control (stmt
));
1980 gimple_omp_sections_set_control (copy
, t
);
1983 case GIMPLE_OMP_SINGLE
:
1985 gomp_single
*omp_single_copy
= as_a
<gomp_single
*> (copy
);
1986 t
= unshare_expr (gimple_omp_single_clauses (stmt
));
1987 gimple_omp_single_set_clauses (omp_single_copy
, t
);
1991 case GIMPLE_OMP_TARGET
:
1993 gomp_target
*omp_target_stmt
= as_a
<gomp_target
*> (stmt
);
1994 gomp_target
*omp_target_copy
= as_a
<gomp_target
*> (copy
);
1995 t
= unshare_expr (gimple_omp_target_clauses (omp_target_stmt
));
1996 gimple_omp_target_set_clauses (omp_target_copy
, t
);
1997 t
= unshare_expr (gimple_omp_target_data_arg (omp_target_stmt
));
1998 gimple_omp_target_set_data_arg (omp_target_copy
, t
);
2002 case GIMPLE_OMP_TEAMS
:
2004 gomp_teams
*omp_teams_copy
= as_a
<gomp_teams
*> (copy
);
2005 t
= unshare_expr (gimple_omp_teams_clauses (stmt
));
2006 gimple_omp_teams_set_clauses (omp_teams_copy
, t
);
2010 case GIMPLE_OMP_SECTION
:
2011 case GIMPLE_OMP_MASTER
:
2012 case GIMPLE_OMP_GRID_BODY
:
2014 new_seq
= gimple_seq_copy (gimple_omp_body (stmt
));
2015 gimple_omp_set_body (copy
, new_seq
);
2018 case GIMPLE_TRANSACTION
:
2019 new_seq
= gimple_seq_copy (gimple_transaction_body (
2020 as_a
<gtransaction
*> (stmt
)));
2021 gimple_transaction_set_body (as_a
<gtransaction
*> (copy
),
2025 case GIMPLE_WITH_CLEANUP_EXPR
:
2026 new_seq
= gimple_seq_copy (gimple_wce_cleanup (stmt
));
2027 gimple_wce_set_cleanup (copy
, new_seq
);
2035 /* Make copy of operands. */
2036 for (i
= 0; i
< num_ops
; i
++)
2037 gimple_set_op (copy
, i
, unshare_expr (gimple_op (stmt
, i
)));
2039 if (gimple_has_mem_ops (stmt
))
2041 gimple_set_vdef (copy
, gimple_vdef (stmt
));
2042 gimple_set_vuse (copy
, gimple_vuse (stmt
));
2045 /* Clear out SSA operand vectors on COPY. */
2046 if (gimple_has_ops (stmt
))
2048 gimple_set_use_ops (copy
, NULL
);
2050 /* SSA operands need to be updated. */
2051 gimple_set_modified (copy
, true);
2054 if (gimple_debug_nonbind_marker_p (stmt
))
2055 cfun
->debug_marker_count
++;
2060 /* Move OLD_STMT's vuse and vdef operands to NEW_STMT, on the assumption
2061 that OLD_STMT is about to be removed. */
2064 gimple_move_vops (gimple
*new_stmt
, gimple
*old_stmt
)
2066 tree vdef
= gimple_vdef (old_stmt
);
2067 gimple_set_vuse (new_stmt
, gimple_vuse (old_stmt
));
2068 gimple_set_vdef (new_stmt
, vdef
);
2069 if (vdef
&& TREE_CODE (vdef
) == SSA_NAME
)
2070 SSA_NAME_DEF_STMT (vdef
) = new_stmt
;
2073 /* Return true if statement S has side-effects. We consider a
2074 statement to have side effects if:
2076 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
2077 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
2080 gimple_has_side_effects (const gimple
*s
)
2082 if (is_gimple_debug (s
))
2085 /* We don't have to scan the arguments to check for
2086 volatile arguments, though, at present, we still
2087 do a scan to check for TREE_SIDE_EFFECTS. */
2088 if (gimple_has_volatile_ops (s
))
2091 if (gimple_code (s
) == GIMPLE_ASM
2092 && gimple_asm_volatile_p (as_a
<const gasm
*> (s
)))
2095 if (is_gimple_call (s
))
2097 int flags
= gimple_call_flags (s
);
2099 /* An infinite loop is considered a side effect. */
2100 if (!(flags
& (ECF_CONST
| ECF_PURE
))
2101 || (flags
& ECF_LOOPING_CONST_OR_PURE
))
2110 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
2111 Return true if S can trap. When INCLUDE_MEM is true, check whether
2112 the memory operations could trap. When INCLUDE_STORES is true and
2113 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
2116 gimple_could_trap_p_1 (gimple
*s
, bool include_mem
, bool include_stores
)
2118 tree t
, div
= NULL_TREE
;
2123 unsigned i
, start
= (is_gimple_assign (s
) && !include_stores
) ? 1 : 0;
2125 for (i
= start
; i
< gimple_num_ops (s
); i
++)
2126 if (tree_could_trap_p (gimple_op (s
, i
)))
2130 switch (gimple_code (s
))
2133 return gimple_asm_volatile_p (as_a
<gasm
*> (s
));
2136 t
= gimple_call_fndecl (s
);
2137 /* Assume that calls to weak functions may trap. */
2138 if (!t
|| !DECL_P (t
) || DECL_WEAK (t
))
2143 t
= gimple_expr_type (s
);
2144 op
= gimple_assign_rhs_code (s
);
2145 if (get_gimple_rhs_class (op
) == GIMPLE_BINARY_RHS
)
2146 div
= gimple_assign_rhs2 (s
);
2147 return (operation_could_trap_p (op
, FLOAT_TYPE_P (t
),
2148 (INTEGRAL_TYPE_P (t
)
2149 && TYPE_OVERFLOW_TRAPS (t
)),
2153 t
= TREE_TYPE (gimple_cond_lhs (s
));
2154 return operation_could_trap_p (gimple_cond_code (s
),
2155 FLOAT_TYPE_P (t
), false, NULL_TREE
);
2164 /* Return true if statement S can trap. */
2167 gimple_could_trap_p (gimple
*s
)
2169 return gimple_could_trap_p_1 (s
, true, true);
2172 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
2175 gimple_assign_rhs_could_trap_p (gimple
*s
)
2177 gcc_assert (is_gimple_assign (s
));
2178 return gimple_could_trap_p_1 (s
, true, false);
2182 /* Print debugging information for gimple stmts generated. */
2185 dump_gimple_statistics (void)
2188 uint64_t total_tuples
= 0, total_bytes
= 0;
2190 if (! GATHER_STATISTICS
)
2192 fprintf (stderr
, "No GIMPLE statistics\n");
2196 fprintf (stderr
, "\nGIMPLE statements\n");
2197 fprintf (stderr
, "Kind Stmts Bytes\n");
2198 fprintf (stderr
, "---------------------------------------\n");
2199 for (i
= 0; i
< (int) gimple_alloc_kind_all
; ++i
)
2201 fprintf (stderr
, "%-20s %7" PRIu64
"%c %10" PRIu64
"%c\n",
2202 gimple_alloc_kind_names
[i
],
2203 SIZE_AMOUNT (gimple_alloc_counts
[i
]),
2204 SIZE_AMOUNT (gimple_alloc_sizes
[i
]));
2205 total_tuples
+= gimple_alloc_counts
[i
];
2206 total_bytes
+= gimple_alloc_sizes
[i
];
2208 fprintf (stderr
, "---------------------------------------\n");
2209 fprintf (stderr
, "%-20s %7" PRIu64
"%c %10" PRIu64
"%c\n", "Total",
2210 SIZE_AMOUNT (total_tuples
), SIZE_AMOUNT (total_bytes
));
2211 fprintf (stderr
, "---------------------------------------\n");
2215 /* Return the number of operands needed on the RHS of a GIMPLE
2216 assignment for an expression with tree code CODE. */
2219 get_gimple_rhs_num_ops (enum tree_code code
)
2221 enum gimple_rhs_class rhs_class
= get_gimple_rhs_class (code
);
2223 if (rhs_class
== GIMPLE_UNARY_RHS
|| rhs_class
== GIMPLE_SINGLE_RHS
)
2225 else if (rhs_class
== GIMPLE_BINARY_RHS
)
2227 else if (rhs_class
== GIMPLE_TERNARY_RHS
)
2233 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2235 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2236 : ((TYPE) == tcc_binary \
2237 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2238 : ((TYPE) == tcc_constant \
2239 || (TYPE) == tcc_declaration \
2240 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2241 : ((SYM) == TRUTH_AND_EXPR \
2242 || (SYM) == TRUTH_OR_EXPR \
2243 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2244 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2245 : ((SYM) == COND_EXPR \
2246 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2247 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2248 || (SYM) == DOT_PROD_EXPR \
2249 || (SYM) == SAD_EXPR \
2250 || (SYM) == REALIGN_LOAD_EXPR \
2251 || (SYM) == VEC_COND_EXPR \
2252 || (SYM) == VEC_PERM_EXPR \
2253 || (SYM) == BIT_INSERT_EXPR) ? GIMPLE_TERNARY_RHS \
2254 : ((SYM) == CONSTRUCTOR \
2255 || (SYM) == OBJ_TYPE_REF \
2256 || (SYM) == ASSERT_EXPR \
2257 || (SYM) == ADDR_EXPR \
2258 || (SYM) == WITH_SIZE_EXPR \
2259 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2260 : GIMPLE_INVALID_RHS),
2261 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2263 const unsigned char gimple_rhs_class_table
[] = {
2264 #include "all-tree.def"
2268 #undef END_OF_BASE_TREE_CODES
2270 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2271 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2272 we failed to create one. */
2275 canonicalize_cond_expr_cond (tree t
)
2277 /* Strip conversions around boolean operations. */
2278 if (CONVERT_EXPR_P (t
)
2279 && (truth_value_p (TREE_CODE (TREE_OPERAND (t
, 0)))
2280 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
2282 t
= TREE_OPERAND (t
, 0);
2284 /* For !x use x == 0. */
2285 if (TREE_CODE (t
) == TRUTH_NOT_EXPR
)
2287 tree top0
= TREE_OPERAND (t
, 0);
2288 t
= build2 (EQ_EXPR
, TREE_TYPE (t
),
2289 top0
, build_int_cst (TREE_TYPE (top0
), 0));
2291 /* For cmp ? 1 : 0 use cmp. */
2292 else if (TREE_CODE (t
) == COND_EXPR
2293 && COMPARISON_CLASS_P (TREE_OPERAND (t
, 0))
2294 && integer_onep (TREE_OPERAND (t
, 1))
2295 && integer_zerop (TREE_OPERAND (t
, 2)))
2297 tree top0
= TREE_OPERAND (t
, 0);
2298 t
= build2 (TREE_CODE (top0
), TREE_TYPE (t
),
2299 TREE_OPERAND (top0
, 0), TREE_OPERAND (top0
, 1));
2301 /* For x ^ y use x != y. */
2302 else if (TREE_CODE (t
) == BIT_XOR_EXPR
)
2303 t
= build2 (NE_EXPR
, TREE_TYPE (t
),
2304 TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1));
2306 if (is_gimple_condexpr (t
))
2312 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2313 the positions marked by the set ARGS_TO_SKIP. */
2316 gimple_call_copy_skip_args (gcall
*stmt
, bitmap args_to_skip
)
2319 int nargs
= gimple_call_num_args (stmt
);
2320 auto_vec
<tree
> vargs (nargs
);
2323 for (i
= 0; i
< nargs
; i
++)
2324 if (!bitmap_bit_p (args_to_skip
, i
))
2325 vargs
.quick_push (gimple_call_arg (stmt
, i
));
2327 if (gimple_call_internal_p (stmt
))
2328 new_stmt
= gimple_build_call_internal_vec (gimple_call_internal_fn (stmt
),
2331 new_stmt
= gimple_build_call_vec (gimple_call_fn (stmt
), vargs
);
2333 if (gimple_call_lhs (stmt
))
2334 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2336 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2337 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
2339 if (gimple_has_location (stmt
))
2340 gimple_set_location (new_stmt
, gimple_location (stmt
));
2341 gimple_call_copy_flags (new_stmt
, stmt
);
2342 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2344 gimple_set_modified (new_stmt
, true);
2351 /* Return true if the field decls F1 and F2 are at the same offset.
2353 This is intended to be used on GIMPLE types only. */
2356 gimple_compare_field_offset (tree f1
, tree f2
)
2358 if (DECL_OFFSET_ALIGN (f1
) == DECL_OFFSET_ALIGN (f2
))
2360 tree offset1
= DECL_FIELD_OFFSET (f1
);
2361 tree offset2
= DECL_FIELD_OFFSET (f2
);
2362 return ((offset1
== offset2
2363 /* Once gimplification is done, self-referential offsets are
2364 instantiated as operand #2 of the COMPONENT_REF built for
2365 each access and reset. Therefore, they are not relevant
2366 anymore and fields are interchangeable provided that they
2367 represent the same access. */
2368 || (TREE_CODE (offset1
) == PLACEHOLDER_EXPR
2369 && TREE_CODE (offset2
) == PLACEHOLDER_EXPR
2370 && (DECL_SIZE (f1
) == DECL_SIZE (f2
)
2371 || (TREE_CODE (DECL_SIZE (f1
)) == PLACEHOLDER_EXPR
2372 && TREE_CODE (DECL_SIZE (f2
)) == PLACEHOLDER_EXPR
)
2373 || operand_equal_p (DECL_SIZE (f1
), DECL_SIZE (f2
), 0))
2374 && DECL_ALIGN (f1
) == DECL_ALIGN (f2
))
2375 || operand_equal_p (offset1
, offset2
, 0))
2376 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1
),
2377 DECL_FIELD_BIT_OFFSET (f2
)));
2380 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2381 should be, so handle differing ones specially by decomposing
2382 the offset into a byte and bit offset manually. */
2383 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1
))
2384 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2
)))
2386 unsigned HOST_WIDE_INT byte_offset1
, byte_offset2
;
2387 unsigned HOST_WIDE_INT bit_offset1
, bit_offset2
;
2388 bit_offset1
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1
));
2389 byte_offset1
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1
))
2390 + bit_offset1
/ BITS_PER_UNIT
);
2391 bit_offset2
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2
));
2392 byte_offset2
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2
))
2393 + bit_offset2
/ BITS_PER_UNIT
);
2394 if (byte_offset1
!= byte_offset2
)
2396 return bit_offset1
% BITS_PER_UNIT
== bit_offset2
% BITS_PER_UNIT
;
2403 /* Return a type the same as TYPE except unsigned or
2404 signed according to UNSIGNEDP. */
2407 gimple_signed_or_unsigned_type (bool unsignedp
, tree type
)
2412 type1
= TYPE_MAIN_VARIANT (type
);
2413 if (type1
== signed_char_type_node
2414 || type1
== char_type_node
2415 || type1
== unsigned_char_type_node
)
2416 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2417 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2418 return unsignedp
? unsigned_type_node
: integer_type_node
;
2419 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2420 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2421 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2422 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2423 if (type1
== long_long_integer_type_node
2424 || type1
== long_long_unsigned_type_node
)
2426 ? long_long_unsigned_type_node
2427 : long_long_integer_type_node
;
2429 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2430 if (int_n_enabled_p
[i
]
2431 && (type1
== int_n_trees
[i
].unsigned_type
2432 || type1
== int_n_trees
[i
].signed_type
))
2434 ? int_n_trees
[i
].unsigned_type
2435 : int_n_trees
[i
].signed_type
;
2437 #if HOST_BITS_PER_WIDE_INT >= 64
2438 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2439 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2441 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2442 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2443 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2444 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2445 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2446 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2447 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2448 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2450 #define GIMPLE_FIXED_TYPES(NAME) \
2451 if (type1 == short_ ## NAME ## _type_node \
2452 || type1 == unsigned_short_ ## NAME ## _type_node) \
2453 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2454 : short_ ## NAME ## _type_node; \
2455 if (type1 == NAME ## _type_node \
2456 || type1 == unsigned_ ## NAME ## _type_node) \
2457 return unsignedp ? unsigned_ ## NAME ## _type_node \
2458 : NAME ## _type_node; \
2459 if (type1 == long_ ## NAME ## _type_node \
2460 || type1 == unsigned_long_ ## NAME ## _type_node) \
2461 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2462 : long_ ## NAME ## _type_node; \
2463 if (type1 == long_long_ ## NAME ## _type_node \
2464 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2465 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2466 : long_long_ ## NAME ## _type_node;
2468 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2469 if (type1 == NAME ## _type_node \
2470 || type1 == u ## NAME ## _type_node) \
2471 return unsignedp ? u ## NAME ## _type_node \
2472 : NAME ## _type_node;
2474 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2475 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2476 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2477 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2478 : sat_ ## short_ ## NAME ## _type_node; \
2479 if (type1 == sat_ ## NAME ## _type_node \
2480 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2481 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2482 : sat_ ## NAME ## _type_node; \
2483 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2484 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2485 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2486 : sat_ ## long_ ## NAME ## _type_node; \
2487 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2488 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2489 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2490 : sat_ ## long_long_ ## NAME ## _type_node;
2492 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2493 if (type1 == sat_ ## NAME ## _type_node \
2494 || type1 == sat_ ## u ## NAME ## _type_node) \
2495 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2496 : sat_ ## NAME ## _type_node;
2498 GIMPLE_FIXED_TYPES (fract
);
2499 GIMPLE_FIXED_TYPES_SAT (fract
);
2500 GIMPLE_FIXED_TYPES (accum
);
2501 GIMPLE_FIXED_TYPES_SAT (accum
);
2503 GIMPLE_FIXED_MODE_TYPES (qq
);
2504 GIMPLE_FIXED_MODE_TYPES (hq
);
2505 GIMPLE_FIXED_MODE_TYPES (sq
);
2506 GIMPLE_FIXED_MODE_TYPES (dq
);
2507 GIMPLE_FIXED_MODE_TYPES (tq
);
2508 GIMPLE_FIXED_MODE_TYPES_SAT (qq
);
2509 GIMPLE_FIXED_MODE_TYPES_SAT (hq
);
2510 GIMPLE_FIXED_MODE_TYPES_SAT (sq
);
2511 GIMPLE_FIXED_MODE_TYPES_SAT (dq
);
2512 GIMPLE_FIXED_MODE_TYPES_SAT (tq
);
2513 GIMPLE_FIXED_MODE_TYPES (ha
);
2514 GIMPLE_FIXED_MODE_TYPES (sa
);
2515 GIMPLE_FIXED_MODE_TYPES (da
);
2516 GIMPLE_FIXED_MODE_TYPES (ta
);
2517 GIMPLE_FIXED_MODE_TYPES_SAT (ha
);
2518 GIMPLE_FIXED_MODE_TYPES_SAT (sa
);
2519 GIMPLE_FIXED_MODE_TYPES_SAT (da
);
2520 GIMPLE_FIXED_MODE_TYPES_SAT (ta
);
2522 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2523 the precision; they have precision set to match their range, but
2524 may use a wider mode to match an ABI. If we change modes, we may
2525 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2526 the precision as well, so as to yield correct results for
2527 bit-field types. C++ does not have these separate bit-field
2528 types, and producing a signed or unsigned variant of an
2529 ENUMERAL_TYPE may cause other problems as well. */
2530 if (!INTEGRAL_TYPE_P (type
)
2531 || TYPE_UNSIGNED (type
) == unsignedp
)
2534 #define TYPE_OK(node) \
2535 (TYPE_MODE (type) == TYPE_MODE (node) \
2536 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2537 if (TYPE_OK (signed_char_type_node
))
2538 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2539 if (TYPE_OK (integer_type_node
))
2540 return unsignedp
? unsigned_type_node
: integer_type_node
;
2541 if (TYPE_OK (short_integer_type_node
))
2542 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2543 if (TYPE_OK (long_integer_type_node
))
2544 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2545 if (TYPE_OK (long_long_integer_type_node
))
2547 ? long_long_unsigned_type_node
2548 : long_long_integer_type_node
);
2550 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2551 if (int_n_enabled_p
[i
]
2552 && TYPE_MODE (type
) == int_n_data
[i
].m
2553 && TYPE_PRECISION (type
) == int_n_data
[i
].bitsize
)
2555 ? int_n_trees
[i
].unsigned_type
2556 : int_n_trees
[i
].signed_type
;
2558 #if HOST_BITS_PER_WIDE_INT >= 64
2559 if (TYPE_OK (intTI_type_node
))
2560 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2562 if (TYPE_OK (intDI_type_node
))
2563 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2564 if (TYPE_OK (intSI_type_node
))
2565 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2566 if (TYPE_OK (intHI_type_node
))
2567 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2568 if (TYPE_OK (intQI_type_node
))
2569 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2571 #undef GIMPLE_FIXED_TYPES
2572 #undef GIMPLE_FIXED_MODE_TYPES
2573 #undef GIMPLE_FIXED_TYPES_SAT
2574 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2577 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2581 /* Return an unsigned type the same as TYPE in other respects. */
2584 gimple_unsigned_type (tree type
)
2586 return gimple_signed_or_unsigned_type (true, type
);
2590 /* Return a signed type the same as TYPE in other respects. */
2593 gimple_signed_type (tree type
)
2595 return gimple_signed_or_unsigned_type (false, type
);
2599 /* Return the typed-based alias set for T, which may be an expression
2600 or a type. Return -1 if we don't do anything special. */
2603 gimple_get_alias_set (tree t
)
2605 /* That's all the expressions we handle specially. */
2609 /* For convenience, follow the C standard when dealing with
2610 character types. Any object may be accessed via an lvalue that
2611 has character type. */
2612 if (t
== char_type_node
2613 || t
== signed_char_type_node
2614 || t
== unsigned_char_type_node
)
2617 /* Allow aliasing between signed and unsigned variants of the same
2618 type. We treat the signed variant as canonical. */
2619 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2621 tree t1
= gimple_signed_type (t
);
2623 /* t1 == t can happen for boolean nodes which are always unsigned. */
2625 return get_alias_set (t1
);
2628 /* Allow aliasing between enumeral types and the underlying
2629 integer type. This is required for C since those are
2630 compatible types. */
2631 else if (TREE_CODE (t
) == ENUMERAL_TYPE
)
2633 tree t1
= lang_hooks
.types
.type_for_size (tree_to_uhwi (TYPE_SIZE (t
)),
2634 false /* short-cut above */);
2635 return get_alias_set (t1
);
2642 /* Helper for gimple_ior_addresses_taken_1. */
2645 gimple_ior_addresses_taken_1 (gimple
*, tree addr
, tree
, void *data
)
2647 bitmap addresses_taken
= (bitmap
)data
;
2648 addr
= get_base_address (addr
);
2652 bitmap_set_bit (addresses_taken
, DECL_UID (addr
));
2658 /* Set the bit for the uid of all decls that have their address taken
2659 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2660 were any in this stmt. */
2663 gimple_ior_addresses_taken (bitmap addresses_taken
, gimple
*stmt
)
2665 return walk_stmt_load_store_addr_ops (stmt
, addresses_taken
, NULL
, NULL
,
2666 gimple_ior_addresses_taken_1
);
2670 /* Return true when STMTs arguments and return value match those of FNDECL,
2671 a decl of a builtin function. */
2674 gimple_builtin_call_types_compatible_p (const gimple
*stmt
, tree fndecl
)
2676 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
);
2678 tree ret
= gimple_call_lhs (stmt
);
2680 && !useless_type_conversion_p (TREE_TYPE (ret
),
2681 TREE_TYPE (TREE_TYPE (fndecl
))))
2684 tree targs
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2685 unsigned nargs
= gimple_call_num_args (stmt
);
2686 for (unsigned i
= 0; i
< nargs
; ++i
)
2688 /* Variadic args follow. */
2691 tree arg
= gimple_call_arg (stmt
, i
);
2692 tree type
= TREE_VALUE (targs
);
2693 if (!useless_type_conversion_p (type
, TREE_TYPE (arg
))
2694 /* char/short integral arguments are promoted to int
2695 by several frontends if targetm.calls.promote_prototypes
2696 is true. Allow such promotion too. */
2697 && !(INTEGRAL_TYPE_P (type
)
2698 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)
2699 && targetm
.calls
.promote_prototypes (TREE_TYPE (fndecl
))
2700 && useless_type_conversion_p (integer_type_node
,
2703 targs
= TREE_CHAIN (targs
);
2705 if (targs
&& !VOID_TYPE_P (TREE_VALUE (targs
)))
2710 /* Return true when STMT is operator delete call. */
2713 gimple_call_operator_delete_p (const gcall
*stmt
)
2717 if ((fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
)
2718 return DECL_IS_OPERATOR_DELETE_P (fndecl
);
2722 /* Return true when STMT is builtins call. */
2725 gimple_call_builtin_p (const gimple
*stmt
)
2728 if (is_gimple_call (stmt
)
2729 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2730 && DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
)
2731 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2735 /* Return true when STMT is builtins call to CLASS. */
2738 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_class klass
)
2741 if (is_gimple_call (stmt
)
2742 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2743 && DECL_BUILT_IN_CLASS (fndecl
) == klass
)
2744 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2748 /* Return true when STMT is builtins call to CODE of CLASS. */
2751 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_function code
)
2754 if (is_gimple_call (stmt
)
2755 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2756 && fndecl_built_in_p (fndecl
, code
))
2757 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2761 /* If CALL is a call to a combined_fn (i.e. an internal function or
2762 a normal built-in function), return its code, otherwise return
2766 gimple_call_combined_fn (const gimple
*stmt
)
2768 if (const gcall
*call
= dyn_cast
<const gcall
*> (stmt
))
2770 if (gimple_call_internal_p (call
))
2771 return as_combined_fn (gimple_call_internal_fn (call
));
2773 tree fndecl
= gimple_call_fndecl (stmt
);
2775 && fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
)
2776 && gimple_builtin_call_types_compatible_p (stmt
, fndecl
))
2777 return as_combined_fn (DECL_FUNCTION_CODE (fndecl
));
2782 /* Return true if STMT clobbers memory. STMT is required to be a
2786 gimple_asm_clobbers_memory_p (const gasm
*stmt
)
2790 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
2792 tree op
= gimple_asm_clobber_op (stmt
, i
);
2793 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op
)), "memory") == 0)
2797 /* Non-empty basic ASM implicitly clobbers memory. */
2798 if (gimple_asm_input_p (stmt
) && strlen (gimple_asm_string (stmt
)) != 0)
2804 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2807 dump_decl_set (FILE *file
, bitmap set
)
2814 fprintf (file
, "{ ");
2816 EXECUTE_IF_SET_IN_BITMAP (set
, 0, i
, bi
)
2818 fprintf (file
, "D.%u", i
);
2819 fprintf (file
, " ");
2822 fprintf (file
, "}");
2825 fprintf (file
, "NIL");
2828 /* Return true when CALL is a call stmt that definitely doesn't
2829 free any memory or makes it unavailable otherwise. */
2831 nonfreeing_call_p (gimple
*call
)
2833 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2834 && gimple_call_flags (call
) & ECF_LEAF
)
2835 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call
)))
2837 /* Just in case these become ECF_LEAF in the future. */
2839 case BUILT_IN_TM_FREE
:
2840 case BUILT_IN_REALLOC
:
2841 case BUILT_IN_STACK_RESTORE
:
2846 else if (gimple_call_internal_p (call
))
2847 switch (gimple_call_internal_fn (call
))
2849 case IFN_ABNORMAL_DISPATCHER
:
2852 return tree_to_uhwi (gimple_call_arg (call
, 0)) == ASAN_MARK_UNPOISON
;
2854 if (gimple_call_flags (call
) & ECF_LEAF
)
2859 tree fndecl
= gimple_call_fndecl (call
);
2862 struct cgraph_node
*n
= cgraph_node::get (fndecl
);
2865 enum availability availability
;
2866 n
= n
->function_symbol (&availability
);
2867 if (!n
|| availability
<= AVAIL_INTERPOSABLE
)
2869 return n
->nonfreeing_fn
;
2872 /* Return true when CALL is a call stmt that definitely need not
2873 be considered to be a memory barrier. */
2875 nonbarrier_call_p (gimple
*call
)
2877 if (gimple_call_flags (call
) & (ECF_PURE
| ECF_CONST
))
2879 /* Should extend this to have a nonbarrier_fn flag, just as above in
2880 the nonfreeing case. */
2884 /* Callback for walk_stmt_load_store_ops.
2886 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2889 This routine only makes a superficial check for a dereference. Thus
2890 it must only be used if it is safe to return a false negative. */
2892 check_loadstore (gimple
*, tree op
, tree
, void *data
)
2894 if (TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
2896 /* Some address spaces may legitimately dereference zero. */
2897 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (op
));
2898 if (targetm
.addr_space
.zero_address_valid (as
))
2901 return operand_equal_p (TREE_OPERAND (op
, 0), (tree
)data
, 0);
2907 /* Return true if OP can be inferred to be non-NULL after STMT executes,
2908 either by using a pointer dereference or attributes. */
2910 infer_nonnull_range (gimple
*stmt
, tree op
)
2912 return infer_nonnull_range_by_dereference (stmt
, op
)
2913 || infer_nonnull_range_by_attribute (stmt
, op
);
2916 /* Return true if OP can be inferred to be non-NULL after STMT
2917 executes by using a pointer dereference. */
2919 infer_nonnull_range_by_dereference (gimple
*stmt
, tree op
)
2921 /* We can only assume that a pointer dereference will yield
2922 non-NULL if -fdelete-null-pointer-checks is enabled. */
2923 if (!flag_delete_null_pointer_checks
2924 || !POINTER_TYPE_P (TREE_TYPE (op
))
2925 || gimple_code (stmt
) == GIMPLE_ASM
)
2928 if (walk_stmt_load_store_ops (stmt
, (void *)op
,
2929 check_loadstore
, check_loadstore
))
2935 /* Return true if OP can be inferred to be a non-NULL after STMT
2936 executes by using attributes. */
2938 infer_nonnull_range_by_attribute (gimple
*stmt
, tree op
)
2940 /* We can only assume that a pointer dereference will yield
2941 non-NULL if -fdelete-null-pointer-checks is enabled. */
2942 if (!flag_delete_null_pointer_checks
2943 || !POINTER_TYPE_P (TREE_TYPE (op
))
2944 || gimple_code (stmt
) == GIMPLE_ASM
)
2947 if (is_gimple_call (stmt
) && !gimple_call_internal_p (stmt
))
2949 tree fntype
= gimple_call_fntype (stmt
);
2950 tree attrs
= TYPE_ATTRIBUTES (fntype
);
2951 for (; attrs
; attrs
= TREE_CHAIN (attrs
))
2953 attrs
= lookup_attribute ("nonnull", attrs
);
2955 /* If "nonnull" wasn't specified, we know nothing about
2957 if (attrs
== NULL_TREE
)
2960 /* If "nonnull" applies to all the arguments, then ARG
2961 is non-null if it's in the argument list. */
2962 if (TREE_VALUE (attrs
) == NULL_TREE
)
2964 for (unsigned int i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2966 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt
, i
)))
2967 && operand_equal_p (op
, gimple_call_arg (stmt
, i
), 0))
2973 /* Now see if op appears in the nonnull list. */
2974 for (tree t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
2976 unsigned int idx
= TREE_INT_CST_LOW (TREE_VALUE (t
)) - 1;
2977 if (idx
< gimple_call_num_args (stmt
))
2979 tree arg
= gimple_call_arg (stmt
, idx
);
2980 if (operand_equal_p (op
, arg
, 0))
2987 /* If this function is marked as returning non-null, then we can
2988 infer OP is non-null if it is used in the return statement. */
2989 if (greturn
*return_stmt
= dyn_cast
<greturn
*> (stmt
))
2990 if (gimple_return_retval (return_stmt
)
2991 && operand_equal_p (gimple_return_retval (return_stmt
), op
, 0)
2992 && lookup_attribute ("returns_nonnull",
2993 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
))))
2999 /* Compare two case labels. Because the front end should already have
3000 made sure that case ranges do not overlap, it is enough to only compare
3001 the CASE_LOW values of each case label. */
3004 compare_case_labels (const void *p1
, const void *p2
)
3006 const_tree
const case1
= *(const_tree
const*)p1
;
3007 const_tree
const case2
= *(const_tree
const*)p2
;
3009 /* The 'default' case label always goes first. */
3010 if (!CASE_LOW (case1
))
3012 else if (!CASE_LOW (case2
))
3015 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
3018 /* Sort the case labels in LABEL_VEC in place in ascending order. */
3021 sort_case_labels (vec
<tree
> label_vec
)
3023 label_vec
.qsort (compare_case_labels
);
3026 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
3028 LABELS is a vector that contains all case labels to look at.
3030 INDEX_TYPE is the type of the switch index expression. Case labels
3031 in LABELS are discarded if their values are not in the value range
3032 covered by INDEX_TYPE. The remaining case label values are folded
3035 If a default case exists in LABELS, it is removed from LABELS and
3036 returned in DEFAULT_CASEP. If no default case exists, but the
3037 case labels already cover the whole range of INDEX_TYPE, a default
3038 case is returned pointing to one of the existing case labels.
3039 Otherwise DEFAULT_CASEP is set to NULL_TREE.
3041 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
3042 apply and no action is taken regardless of whether a default case is
3046 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
3048 tree
*default_casep
)
3050 tree min_value
, max_value
;
3051 tree default_case
= NULL_TREE
;
3055 min_value
= TYPE_MIN_VALUE (index_type
);
3056 max_value
= TYPE_MAX_VALUE (index_type
);
3057 while (i
< labels
.length ())
3059 tree elt
= labels
[i
];
3060 tree low
= CASE_LOW (elt
);
3061 tree high
= CASE_HIGH (elt
);
3062 bool remove_element
= FALSE
;
3066 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
3067 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
3069 /* This is a non-default case label, i.e. it has a value.
3071 See if the case label is reachable within the range of
3072 the index type. Remove out-of-range case values. Turn
3073 case ranges into a canonical form (high > low strictly)
3074 and convert the case label values to the index type.
3076 NB: The type of gimple_switch_index() may be the promoted
3077 type, but the case labels retain the original type. */
3081 /* This is a case range. Discard empty ranges.
3082 If the bounds or the range are equal, turn this
3083 into a simple (one-value) case. */
3084 int cmp
= tree_int_cst_compare (high
, low
);
3086 remove_element
= TRUE
;
3093 /* If the simple case value is unreachable, ignore it. */
3094 if ((TREE_CODE (min_value
) == INTEGER_CST
3095 && tree_int_cst_compare (low
, min_value
) < 0)
3096 || (TREE_CODE (max_value
) == INTEGER_CST
3097 && tree_int_cst_compare (low
, max_value
) > 0))
3098 remove_element
= TRUE
;
3100 low
= fold_convert (index_type
, low
);
3104 /* If the entire case range is unreachable, ignore it. */
3105 if ((TREE_CODE (min_value
) == INTEGER_CST
3106 && tree_int_cst_compare (high
, min_value
) < 0)
3107 || (TREE_CODE (max_value
) == INTEGER_CST
3108 && tree_int_cst_compare (low
, max_value
) > 0))
3109 remove_element
= TRUE
;
3112 /* If the lower bound is less than the index type's
3113 minimum value, truncate the range bounds. */
3114 if (TREE_CODE (min_value
) == INTEGER_CST
3115 && tree_int_cst_compare (low
, min_value
) < 0)
3117 low
= fold_convert (index_type
, low
);
3119 /* If the upper bound is greater than the index type's
3120 maximum value, truncate the range bounds. */
3121 if (TREE_CODE (max_value
) == INTEGER_CST
3122 && tree_int_cst_compare (high
, max_value
) > 0)
3124 high
= fold_convert (index_type
, high
);
3126 /* We may have folded a case range to a one-value case. */
3127 if (tree_int_cst_equal (low
, high
))
3132 CASE_LOW (elt
) = low
;
3133 CASE_HIGH (elt
) = high
;
3137 gcc_assert (!default_case
);
3139 /* The default case must be passed separately to the
3140 gimple_build_switch routine. But if DEFAULT_CASEP
3141 is NULL, we do not remove the default case (it would
3142 be completely lost). */
3144 remove_element
= TRUE
;
3148 labels
.ordered_remove (i
);
3154 if (!labels
.is_empty ())
3155 sort_case_labels (labels
);
3157 if (default_casep
&& !default_case
)
3159 /* If the switch has no default label, add one, so that we jump
3160 around the switch body. If the labels already cover the whole
3161 range of the switch index_type, add the default label pointing
3162 to one of the existing labels. */
3164 && TYPE_MIN_VALUE (index_type
)
3165 && TYPE_MAX_VALUE (index_type
)
3166 && tree_int_cst_equal (CASE_LOW (labels
[0]),
3167 TYPE_MIN_VALUE (index_type
)))
3169 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
3171 high
= CASE_LOW (labels
[len
- 1]);
3172 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
3174 tree widest_label
= labels
[0];
3175 for (i
= 1; i
< len
; i
++)
3177 high
= CASE_LOW (labels
[i
]);
3178 low
= CASE_HIGH (labels
[i
- 1]);
3180 low
= CASE_LOW (labels
[i
- 1]);
3182 if (CASE_HIGH (labels
[i
]) != NULL_TREE
3183 && (CASE_HIGH (widest_label
) == NULL_TREE
3185 (wi::to_wide (CASE_HIGH (labels
[i
]))
3186 - wi::to_wide (CASE_LOW (labels
[i
])),
3187 wi::to_wide (CASE_HIGH (widest_label
))
3188 - wi::to_wide (CASE_LOW (widest_label
))))))
3189 widest_label
= labels
[i
];
3191 if (wi::to_wide (low
) + 1 != wi::to_wide (high
))
3196 /* Designate the label with the widest range to be the
3198 tree label
= CASE_LABEL (widest_label
);
3199 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
3207 *default_casep
= default_case
;
3210 /* Set the location of all statements in SEQ to LOC. */
3213 gimple_seq_set_location (gimple_seq seq
, location_t loc
)
3215 for (gimple_stmt_iterator i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
3216 gimple_set_location (gsi_stmt (i
), loc
);
3219 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
3222 gimple_seq_discard (gimple_seq seq
)
3224 gimple_stmt_iterator gsi
;
3226 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); )
3228 gimple
*stmt
= gsi_stmt (gsi
);
3229 gsi_remove (&gsi
, true);
3230 release_defs (stmt
);
3235 /* See if STMT now calls function that takes no parameters and if so, drop
3236 call arguments. This is used when devirtualization machinery redirects
3237 to __builtin_unreachable or __cxa_pure_virtual. */
3240 maybe_remove_unused_call_args (struct function
*fn
, gimple
*stmt
)
3242 tree decl
= gimple_call_fndecl (stmt
);
3243 if (TYPE_ARG_TYPES (TREE_TYPE (decl
))
3244 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
))) == void_type_node
3245 && gimple_call_num_args (stmt
))
3247 gimple_set_num_ops (stmt
, 3);
3248 update_stmt_fn (fn
, stmt
);
3252 /* Return false if STMT will likely expand to real function call. */
3255 gimple_inexpensive_call_p (gcall
*stmt
)
3257 if (gimple_call_internal_p (stmt
))
3259 tree decl
= gimple_call_fndecl (stmt
);
3260 if (decl
&& is_inexpensive_builtin (decl
))
3267 namespace selftest
{
3269 /* Selftests for core gimple structures. */
3271 /* Verify that STMT is pretty-printed as EXPECTED.
3272 Helper function for selftests. */
3275 verify_gimple_pp (const char *expected
, gimple
*stmt
)
3278 pp_gimple_stmt_1 (&pp
, stmt
, 0 /* spc */, TDF_NONE
/* flags */);
3279 ASSERT_STREQ (expected
, pp_formatted_text (&pp
));
3282 /* Build a GIMPLE_ASSIGN equivalent to
3284 and verify various properties of it. */
3287 test_assign_single ()
3289 tree type
= integer_type_node
;
3290 tree lhs
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3291 get_identifier ("tmp"),
3293 tree rhs
= build_int_cst (type
, 5);
3294 gassign
*stmt
= gimple_build_assign (lhs
, rhs
);
3295 verify_gimple_pp ("tmp = 5;", stmt
);
3297 ASSERT_TRUE (is_gimple_assign (stmt
));
3298 ASSERT_EQ (lhs
, gimple_assign_lhs (stmt
));
3299 ASSERT_EQ (lhs
, gimple_get_lhs (stmt
));
3300 ASSERT_EQ (rhs
, gimple_assign_rhs1 (stmt
));
3301 ASSERT_EQ (NULL
, gimple_assign_rhs2 (stmt
));
3302 ASSERT_EQ (NULL
, gimple_assign_rhs3 (stmt
));
3303 ASSERT_TRUE (gimple_assign_single_p (stmt
));
3304 ASSERT_EQ (INTEGER_CST
, gimple_assign_rhs_code (stmt
));
3307 /* Build a GIMPLE_ASSIGN equivalent to
3309 and verify various properties of it. */
3312 test_assign_binop ()
3314 tree type
= integer_type_node
;
3315 tree lhs
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3316 get_identifier ("tmp"),
3318 tree a
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3319 get_identifier ("a"),
3321 tree b
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3322 get_identifier ("b"),
3324 gassign
*stmt
= gimple_build_assign (lhs
, MULT_EXPR
, a
, b
);
3325 verify_gimple_pp ("tmp = a * b;", stmt
);
3327 ASSERT_TRUE (is_gimple_assign (stmt
));
3328 ASSERT_EQ (lhs
, gimple_assign_lhs (stmt
));
3329 ASSERT_EQ (lhs
, gimple_get_lhs (stmt
));
3330 ASSERT_EQ (a
, gimple_assign_rhs1 (stmt
));
3331 ASSERT_EQ (b
, gimple_assign_rhs2 (stmt
));
3332 ASSERT_EQ (NULL
, gimple_assign_rhs3 (stmt
));
3333 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3334 ASSERT_EQ (MULT_EXPR
, gimple_assign_rhs_code (stmt
));
3337 /* Build a GIMPLE_NOP and verify various properties of it. */
3342 gimple
*stmt
= gimple_build_nop ();
3343 verify_gimple_pp ("GIMPLE_NOP", stmt
);
3344 ASSERT_EQ (GIMPLE_NOP
, gimple_code (stmt
));
3345 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3346 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3349 /* Build a GIMPLE_RETURN equivalent to
3351 and verify various properties of it. */
3356 tree type
= integer_type_node
;
3357 tree val
= build_int_cst (type
, 7);
3358 greturn
*stmt
= gimple_build_return (val
);
3359 verify_gimple_pp ("return 7;", stmt
);
3361 ASSERT_EQ (GIMPLE_RETURN
, gimple_code (stmt
));
3362 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3363 ASSERT_EQ (val
, gimple_return_retval (stmt
));
3364 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3367 /* Build a GIMPLE_RETURN equivalent to
3369 and verify various properties of it. */
3372 test_return_without_value ()
3374 greturn
*stmt
= gimple_build_return (NULL
);
3375 verify_gimple_pp ("return;", stmt
);
3377 ASSERT_EQ (GIMPLE_RETURN
, gimple_code (stmt
));
3378 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3379 ASSERT_EQ (NULL
, gimple_return_retval (stmt
));
3380 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3383 /* Run all of the selftests within this file. */
3388 test_assign_single ();
3389 test_assign_binop ();
3391 test_return_stmt ();
3392 test_return_without_value ();
3395 } // namespace selftest
3398 #endif /* CHECKING_P */