1 /* Gimple IR support functions.
3 Copyright (C) 2007-2014 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 "stor-layout.h"
31 #include "hard-reg-set.h"
39 #include "dominance.h"
41 #include "basic-block.h"
42 #include "tree-ssa-alias.h"
43 #include "internal-fn.h"
45 #include "gimple-expr.h"
48 #include "gimple-iterator.h"
49 #include "gimple-walk.h"
52 #include "diagnostic.h"
53 #include "value-prof.h"
57 #include "langhooks.h"
59 #include "stringpool.h"
60 #include "tree-ssanames.h"
63 /* All the tuples have their operand vector (if present) at the very bottom
64 of the structure. Therefore, the offset required to find the
65 operands vector the size of the structure minus the size of the 1
66 element tree array at the end (see gimple_ops). */
67 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
68 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
69 EXPORTED_CONST
size_t gimple_ops_offset_
[] = {
70 #include "gsstruct.def"
74 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
75 static const size_t gsstruct_code_size
[] = {
76 #include "gsstruct.def"
80 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
81 const char *const gimple_code_name
[] = {
86 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
87 EXPORTED_CONST
enum gimple_statement_structure_enum gss_for_code_
[] = {
94 int gimple_alloc_counts
[(int) gimple_alloc_kind_all
];
95 int gimple_alloc_sizes
[(int) gimple_alloc_kind_all
];
97 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
98 static const char * const gimple_alloc_kind_names
[] = {
105 /* Gimple tuple constructors.
106 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
107 be passed a NULL to start with an empty sequence. */
109 /* Set the code for statement G to CODE. */
112 gimple_set_code (gimple g
, enum gimple_code code
)
117 /* Return the number of bytes needed to hold a GIMPLE statement with
121 gimple_size (enum gimple_code code
)
123 return gsstruct_code_size
[gss_for_code (code
)];
126 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
130 gimple_alloc_stat (enum gimple_code code
, unsigned num_ops MEM_STAT_DECL
)
135 size
= gimple_size (code
);
137 size
+= sizeof (tree
) * (num_ops
- 1);
139 if (GATHER_STATISTICS
)
141 enum gimple_alloc_kind kind
= gimple_alloc_kind (code
);
142 gimple_alloc_counts
[(int) kind
]++;
143 gimple_alloc_sizes
[(int) kind
] += size
;
146 stmt
= ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT
);
147 gimple_set_code (stmt
, code
);
148 gimple_set_num_ops (stmt
, num_ops
);
150 /* Do not call gimple_set_modified here as it has other side
151 effects and this tuple is still not completely built. */
153 gimple_init_singleton (stmt
);
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_stat (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
)
194 gimple s
= gimple_build_with_ops (GIMPLE_RETURN
, ERROR_MARK
, 2);
196 gimple_return_set_retval (s
, retval
);
200 /* Reset alias information on call S. */
203 gimple_call_reset_alias_info (gimple s
)
205 if (gimple_call_flags (s
) & ECF_CONST
)
206 memset (gimple_call_use_set (s
), 0, sizeof (struct pt_solution
));
208 pt_solution_reset (gimple_call_use_set (s
));
209 if (gimple_call_flags (s
) & (ECF_CONST
|ECF_PURE
|ECF_NOVOPS
))
210 memset (gimple_call_clobber_set (s
), 0, sizeof (struct pt_solution
));
212 pt_solution_reset (gimple_call_clobber_set (s
));
215 /* Helper for gimple_build_call, gimple_build_call_valist,
216 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
217 components of a GIMPLE_CALL statement to function FN with NARGS
221 gimple_build_call_1 (tree fn
, unsigned nargs
)
223 gimple s
= gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
, nargs
+ 3);
224 if (TREE_CODE (fn
) == FUNCTION_DECL
)
225 fn
= build_fold_addr_expr (fn
);
226 gimple_set_op (s
, 1, fn
);
227 gimple_call_set_fntype (s
, TREE_TYPE (TREE_TYPE (fn
)));
228 gimple_call_reset_alias_info (s
);
233 /* Build a GIMPLE_CALL statement to function FN with the arguments
234 specified in vector ARGS. */
237 gimple_build_call_vec (tree fn
, vec
<tree
> args
)
240 unsigned nargs
= args
.length ();
241 gimple call
= gimple_build_call_1 (fn
, nargs
);
243 for (i
= 0; i
< nargs
; i
++)
244 gimple_call_set_arg (call
, i
, args
[i
]);
250 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
251 arguments. The ... are the arguments. */
254 gimple_build_call (tree fn
, unsigned nargs
, ...)
260 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
262 call
= gimple_build_call_1 (fn
, nargs
);
264 va_start (ap
, nargs
);
265 for (i
= 0; i
< nargs
; i
++)
266 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
273 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
274 arguments. AP contains the arguments. */
277 gimple_build_call_valist (tree fn
, unsigned nargs
, va_list ap
)
282 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
284 call
= gimple_build_call_1 (fn
, nargs
);
286 for (i
= 0; i
< nargs
; i
++)
287 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
293 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
294 Build the basic components of a GIMPLE_CALL statement to internal
295 function FN with NARGS arguments. */
298 gimple_build_call_internal_1 (enum internal_fn fn
, unsigned nargs
)
300 gimple s
= gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
, nargs
+ 3);
301 s
->subcode
|= GF_CALL_INTERNAL
;
302 gimple_call_set_internal_fn (s
, fn
);
303 gimple_call_reset_alias_info (s
);
308 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
309 the number of arguments. The ... are the arguments. */
312 gimple_build_call_internal (enum internal_fn fn
, unsigned nargs
, ...)
318 call
= gimple_build_call_internal_1 (fn
, nargs
);
319 va_start (ap
, nargs
);
320 for (i
= 0; i
< nargs
; i
++)
321 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
328 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
329 specified in vector ARGS. */
332 gimple_build_call_internal_vec (enum internal_fn fn
, vec
<tree
> args
)
337 nargs
= args
.length ();
338 call
= gimple_build_call_internal_1 (fn
, nargs
);
339 for (i
= 0; i
< nargs
; i
++)
340 gimple_call_set_arg (call
, i
, args
[i
]);
346 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
347 assumed to be in GIMPLE form already. Minimal checking is done of
351 gimple_build_call_from_tree (tree t
)
355 tree fndecl
= get_callee_fndecl (t
);
357 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
359 nargs
= call_expr_nargs (t
);
360 call
= gimple_build_call_1 (fndecl
? fndecl
: CALL_EXPR_FN (t
), nargs
);
362 for (i
= 0; i
< nargs
; i
++)
363 gimple_call_set_arg (call
, i
, CALL_EXPR_ARG (t
, i
));
365 gimple_set_block (call
, TREE_BLOCK (t
));
367 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
368 gimple_call_set_chain (call
, CALL_EXPR_STATIC_CHAIN (t
));
369 gimple_call_set_tail (call
, CALL_EXPR_TAILCALL (t
));
370 gimple_call_set_return_slot_opt (call
, CALL_EXPR_RETURN_SLOT_OPT (t
));
372 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
373 && (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA
374 || DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
375 gimple_call_set_alloca_for_var (call
, CALL_ALLOCA_FOR_VAR_P (t
));
377 gimple_call_set_from_thunk (call
, CALL_FROM_THUNK_P (t
));
378 gimple_call_set_va_arg_pack (call
, CALL_EXPR_VA_ARG_PACK (t
));
379 gimple_call_set_nothrow (call
, TREE_NOTHROW (t
));
380 gimple_set_no_warning (call
, TREE_NO_WARNING (t
));
381 gimple_call_set_with_bounds (call
, CALL_WITH_BOUNDS_P (t
));
387 /* Build a GIMPLE_ASSIGN statement.
389 LHS of the assignment.
390 RHS of the assignment which can be unary or binary. */
393 gimple_build_assign_stat (tree lhs
, tree rhs MEM_STAT_DECL
)
395 enum tree_code subcode
;
398 extract_ops_from_tree_1 (rhs
, &subcode
, &op1
, &op2
, &op3
);
399 return gimple_build_assign_with_ops (subcode
, lhs
, op1
, op2
, op3
404 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
405 OP1 and OP2. If OP2 is NULL then SUBCODE must be of class
406 GIMPLE_UNARY_RHS or GIMPLE_SINGLE_RHS. */
409 gimple_build_assign_with_ops (enum tree_code subcode
, tree lhs
, tree op1
,
410 tree op2
, tree op3 MEM_STAT_DECL
)
415 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
417 num_ops
= get_gimple_rhs_num_ops (subcode
) + 1;
419 p
= gimple_build_with_ops_stat (GIMPLE_ASSIGN
, (unsigned)subcode
, num_ops
421 gimple_assign_set_lhs (p
, lhs
);
422 gimple_assign_set_rhs1 (p
, op1
);
425 gcc_assert (num_ops
> 2);
426 gimple_assign_set_rhs2 (p
, op2
);
431 gcc_assert (num_ops
> 3);
432 gimple_assign_set_rhs3 (p
, op3
);
439 gimple_build_assign_with_ops (enum tree_code subcode
, tree lhs
, tree op1
,
440 tree op2 MEM_STAT_DECL
)
442 return gimple_build_assign_with_ops (subcode
, lhs
, op1
, op2
, NULL_TREE
447 /* Build a GIMPLE_COND statement.
449 PRED is the condition used to compare LHS and the RHS.
450 T_LABEL is the label to jump to if the condition is true.
451 F_LABEL is the label to jump to otherwise. */
454 gimple_build_cond (enum tree_code pred_code
, tree lhs
, tree rhs
,
455 tree t_label
, tree f_label
)
459 gcc_assert (TREE_CODE_CLASS (pred_code
) == tcc_comparison
);
460 p
= gimple_build_with_ops (GIMPLE_COND
, pred_code
, 4);
461 gimple_cond_set_lhs (p
, lhs
);
462 gimple_cond_set_rhs (p
, rhs
);
463 gimple_cond_set_true_label (p
, t_label
);
464 gimple_cond_set_false_label (p
, f_label
);
468 /* Build a GIMPLE_COND statement from the conditional expression tree
469 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
472 gimple_build_cond_from_tree (tree cond
, tree t_label
, tree f_label
)
477 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
478 return gimple_build_cond (code
, lhs
, rhs
, t_label
, f_label
);
481 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
482 boolean expression tree COND. */
485 gimple_cond_set_condition_from_tree (gimple stmt
, tree cond
)
490 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
491 gimple_cond_set_condition (stmt
, code
, lhs
, rhs
);
494 /* Build a GIMPLE_LABEL statement for LABEL. */
497 gimple_build_label (tree label
)
499 gimple p
= gimple_build_with_ops (GIMPLE_LABEL
, ERROR_MARK
, 1);
500 gimple_label_set_label (p
, label
);
504 /* Build a GIMPLE_GOTO statement to label DEST. */
507 gimple_build_goto (tree dest
)
509 gimple p
= gimple_build_with_ops (GIMPLE_GOTO
, ERROR_MARK
, 1);
510 gimple_goto_set_dest (p
, dest
);
515 /* Build a GIMPLE_NOP statement. */
518 gimple_build_nop (void)
520 return gimple_alloc (GIMPLE_NOP
, 0);
524 /* Build a GIMPLE_BIND statement.
525 VARS are the variables in BODY.
526 BLOCK is the containing block. */
529 gimple_build_bind (tree vars
, gimple_seq body
, tree block
)
531 gimple p
= gimple_alloc (GIMPLE_BIND
, 0);
532 gimple_bind_set_vars (p
, vars
);
534 gimple_bind_set_body (p
, body
);
536 gimple_bind_set_block (p
, block
);
540 /* Helper function to set the simple fields of a asm stmt.
542 STRING is a pointer to a string that is the asm blocks assembly code.
543 NINPUT is the number of register inputs.
544 NOUTPUT is the number of register outputs.
545 NCLOBBERS is the number of clobbered registers.
549 gimple_build_asm_1 (const char *string
, unsigned ninputs
, unsigned noutputs
,
550 unsigned nclobbers
, unsigned nlabels
)
552 gimple_statement_asm
*p
;
553 int size
= strlen (string
);
555 /* ASMs with labels cannot have outputs. This should have been
556 enforced by the front end. */
557 gcc_assert (nlabels
== 0 || noutputs
== 0);
559 p
= as_a
<gimple_statement_asm
*> (
560 gimple_build_with_ops (GIMPLE_ASM
, ERROR_MARK
,
561 ninputs
+ noutputs
+ nclobbers
+ nlabels
));
567 p
->string
= ggc_alloc_string (string
, size
);
569 if (GATHER_STATISTICS
)
570 gimple_alloc_sizes
[(int) gimple_alloc_kind (GIMPLE_ASM
)] += size
;
575 /* Build a GIMPLE_ASM statement.
577 STRING is the assembly code.
578 NINPUT is the number of register inputs.
579 NOUTPUT is the number of register outputs.
580 NCLOBBERS is the number of clobbered registers.
581 INPUTS is a vector of the input register parameters.
582 OUTPUTS is a vector of the output register parameters.
583 CLOBBERS is a vector of the clobbered register parameters.
584 LABELS is a vector of destination labels. */
587 gimple_build_asm_vec (const char *string
, vec
<tree
, va_gc
> *inputs
,
588 vec
<tree
, va_gc
> *outputs
, vec
<tree
, va_gc
> *clobbers
,
589 vec
<tree
, va_gc
> *labels
)
594 p
= gimple_build_asm_1 (string
,
595 vec_safe_length (inputs
),
596 vec_safe_length (outputs
),
597 vec_safe_length (clobbers
),
598 vec_safe_length (labels
));
600 for (i
= 0; i
< vec_safe_length (inputs
); i
++)
601 gimple_asm_set_input_op (p
, i
, (*inputs
)[i
]);
603 for (i
= 0; i
< vec_safe_length (outputs
); i
++)
604 gimple_asm_set_output_op (p
, i
, (*outputs
)[i
]);
606 for (i
= 0; i
< vec_safe_length (clobbers
); i
++)
607 gimple_asm_set_clobber_op (p
, i
, (*clobbers
)[i
]);
609 for (i
= 0; i
< vec_safe_length (labels
); i
++)
610 gimple_asm_set_label_op (p
, i
, (*labels
)[i
]);
615 /* Build a GIMPLE_CATCH statement.
617 TYPES are the catch types.
618 HANDLER is the exception handler. */
621 gimple_build_catch (tree types
, gimple_seq handler
)
623 gimple p
= gimple_alloc (GIMPLE_CATCH
, 0);
624 gimple_catch_set_types (p
, types
);
626 gimple_catch_set_handler (p
, handler
);
631 /* Build a GIMPLE_EH_FILTER statement.
633 TYPES are the filter's types.
634 FAILURE is the filter's failure action. */
637 gimple_build_eh_filter (tree types
, gimple_seq failure
)
639 gimple p
= gimple_alloc (GIMPLE_EH_FILTER
, 0);
640 gimple_eh_filter_set_types (p
, types
);
642 gimple_eh_filter_set_failure (p
, failure
);
647 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
650 gimple_build_eh_must_not_throw (tree decl
)
652 gimple p
= gimple_alloc (GIMPLE_EH_MUST_NOT_THROW
, 0);
654 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
655 gcc_assert (flags_from_decl_or_type (decl
) & ECF_NORETURN
);
656 gimple_eh_must_not_throw_set_fndecl (p
, decl
);
661 /* Build a GIMPLE_EH_ELSE statement. */
664 gimple_build_eh_else (gimple_seq n_body
, gimple_seq e_body
)
666 gimple p
= gimple_alloc (GIMPLE_EH_ELSE
, 0);
667 gimple_eh_else_set_n_body (p
, n_body
);
668 gimple_eh_else_set_e_body (p
, e_body
);
672 /* Build a GIMPLE_TRY statement.
674 EVAL is the expression to evaluate.
675 CLEANUP is the cleanup expression.
676 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
677 whether this is a try/catch or a try/finally respectively. */
679 gimple_statement_try
*
680 gimple_build_try (gimple_seq eval
, gimple_seq cleanup
,
681 enum gimple_try_flags kind
)
683 gimple_statement_try
*p
;
685 gcc_assert (kind
== GIMPLE_TRY_CATCH
|| kind
== GIMPLE_TRY_FINALLY
);
686 p
= as_a
<gimple_statement_try
*> (gimple_alloc (GIMPLE_TRY
, 0));
687 gimple_set_subcode (p
, kind
);
689 gimple_try_set_eval (p
, eval
);
691 gimple_try_set_cleanup (p
, cleanup
);
696 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
698 CLEANUP is the cleanup expression. */
701 gimple_build_wce (gimple_seq cleanup
)
703 gimple p
= gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR
, 0);
705 gimple_wce_set_cleanup (p
, cleanup
);
711 /* Build a GIMPLE_RESX statement. */
714 gimple_build_resx (int region
)
716 gimple_statement_resx
*p
=
717 as_a
<gimple_statement_resx
*> (
718 gimple_build_with_ops (GIMPLE_RESX
, ERROR_MARK
, 0));
724 /* The helper for constructing a gimple switch statement.
725 INDEX is the switch's index.
726 NLABELS is the number of labels in the switch excluding the default.
727 DEFAULT_LABEL is the default label for the switch statement. */
730 gimple_build_switch_nlabels (unsigned nlabels
, tree index
, tree default_label
)
732 /* nlabels + 1 default label + 1 index. */
733 gcc_checking_assert (default_label
);
734 gimple p
= gimple_build_with_ops (GIMPLE_SWITCH
, ERROR_MARK
,
736 gimple_switch_set_index (p
, index
);
737 gimple_switch_set_default_label (p
, default_label
);
741 /* Build a GIMPLE_SWITCH statement.
743 INDEX is the switch's index.
744 DEFAULT_LABEL is the default label
745 ARGS is a vector of labels excluding the default. */
748 gimple_build_switch (tree index
, tree default_label
, vec
<tree
> args
)
750 unsigned i
, nlabels
= args
.length ();
752 gimple p
= gimple_build_switch_nlabels (nlabels
, index
, default_label
);
754 /* Copy the labels from the vector to the switch statement. */
755 for (i
= 0; i
< nlabels
; i
++)
756 gimple_switch_set_label (p
, i
+ 1, args
[i
]);
761 /* Build a GIMPLE_EH_DISPATCH statement. */
764 gimple_build_eh_dispatch (int region
)
766 gimple_statement_eh_dispatch
*p
=
767 as_a
<gimple_statement_eh_dispatch
*> (
768 gimple_build_with_ops (GIMPLE_EH_DISPATCH
, ERROR_MARK
, 0));
773 /* Build a new GIMPLE_DEBUG_BIND statement.
775 VAR is bound to VALUE; block and location are taken from STMT. */
778 gimple_build_debug_bind_stat (tree var
, tree value
, gimple stmt MEM_STAT_DECL
)
780 gimple p
= gimple_build_with_ops_stat (GIMPLE_DEBUG
,
781 (unsigned)GIMPLE_DEBUG_BIND
, 2
784 gimple_debug_bind_set_var (p
, var
);
785 gimple_debug_bind_set_value (p
, value
);
787 gimple_set_location (p
, gimple_location (stmt
));
793 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
795 VAR is bound to VALUE; block and location are taken from STMT. */
798 gimple_build_debug_source_bind_stat (tree var
, tree value
,
799 gimple stmt MEM_STAT_DECL
)
801 gimple p
= gimple_build_with_ops_stat (GIMPLE_DEBUG
,
802 (unsigned)GIMPLE_DEBUG_SOURCE_BIND
, 2
805 gimple_debug_source_bind_set_var (p
, var
);
806 gimple_debug_source_bind_set_value (p
, value
);
808 gimple_set_location (p
, gimple_location (stmt
));
814 /* Build a GIMPLE_OMP_CRITICAL statement.
816 BODY is the sequence of statements for which only one thread can execute.
817 NAME is optional identifier for this critical block. */
820 gimple_build_omp_critical (gimple_seq body
, tree name
)
822 gimple p
= gimple_alloc (GIMPLE_OMP_CRITICAL
, 0);
823 gimple_omp_critical_set_name (p
, name
);
825 gimple_omp_set_body (p
, body
);
830 /* Build a GIMPLE_OMP_FOR statement.
832 BODY is sequence of statements inside the for loop.
833 KIND is the `for' variant.
834 CLAUSES, are any of the loop construct's clauses.
835 COLLAPSE is the collapse count.
836 PRE_BODY is the sequence of statements that are loop invariant. */
839 gimple_build_omp_for (gimple_seq body
, int kind
, tree clauses
, size_t collapse
,
842 gimple_statement_omp_for
*p
=
843 as_a
<gimple_statement_omp_for
*> (gimple_alloc (GIMPLE_OMP_FOR
, 0));
845 gimple_omp_set_body (p
, body
);
846 gimple_omp_for_set_clauses (p
, clauses
);
847 gimple_omp_for_set_kind (p
, kind
);
848 p
->collapse
= collapse
;
849 p
->iter
= ggc_cleared_vec_alloc
<gimple_omp_for_iter
> (collapse
);
852 gimple_omp_for_set_pre_body (p
, pre_body
);
858 /* Build a GIMPLE_OMP_PARALLEL statement.
860 BODY is sequence of statements which are executed in parallel.
861 CLAUSES, are the OMP parallel construct's clauses.
862 CHILD_FN is the function created for the parallel threads to execute.
863 DATA_ARG are the shared data argument(s). */
866 gimple_build_omp_parallel (gimple_seq body
, tree clauses
, tree child_fn
,
869 gimple p
= gimple_alloc (GIMPLE_OMP_PARALLEL
, 0);
871 gimple_omp_set_body (p
, body
);
872 gimple_omp_parallel_set_clauses (p
, clauses
);
873 gimple_omp_parallel_set_child_fn (p
, child_fn
);
874 gimple_omp_parallel_set_data_arg (p
, data_arg
);
880 /* Build a GIMPLE_OMP_TASK statement.
882 BODY is sequence of statements which are executed by the explicit task.
883 CLAUSES, are the OMP parallel construct's clauses.
884 CHILD_FN is the function created for the parallel threads to execute.
885 DATA_ARG are the shared data argument(s).
886 COPY_FN is the optional function for firstprivate initialization.
887 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
890 gimple_build_omp_task (gimple_seq body
, tree clauses
, tree child_fn
,
891 tree data_arg
, tree copy_fn
, tree arg_size
,
894 gimple p
= gimple_alloc (GIMPLE_OMP_TASK
, 0);
896 gimple_omp_set_body (p
, body
);
897 gimple_omp_task_set_clauses (p
, clauses
);
898 gimple_omp_task_set_child_fn (p
, child_fn
);
899 gimple_omp_task_set_data_arg (p
, data_arg
);
900 gimple_omp_task_set_copy_fn (p
, copy_fn
);
901 gimple_omp_task_set_arg_size (p
, arg_size
);
902 gimple_omp_task_set_arg_align (p
, arg_align
);
908 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
910 BODY is the sequence of statements in the section. */
913 gimple_build_omp_section (gimple_seq body
)
915 gimple p
= gimple_alloc (GIMPLE_OMP_SECTION
, 0);
917 gimple_omp_set_body (p
, body
);
923 /* Build a GIMPLE_OMP_MASTER statement.
925 BODY is the sequence of statements to be executed by just the master. */
928 gimple_build_omp_master (gimple_seq body
)
930 gimple p
= gimple_alloc (GIMPLE_OMP_MASTER
, 0);
932 gimple_omp_set_body (p
, body
);
938 /* Build a GIMPLE_OMP_TASKGROUP statement.
940 BODY is the sequence of statements to be executed by the taskgroup
944 gimple_build_omp_taskgroup (gimple_seq body
)
946 gimple p
= gimple_alloc (GIMPLE_OMP_TASKGROUP
, 0);
948 gimple_omp_set_body (p
, body
);
954 /* Build a GIMPLE_OMP_CONTINUE statement.
956 CONTROL_DEF is the definition of the control variable.
957 CONTROL_USE is the use of the control variable. */
960 gimple_build_omp_continue (tree control_def
, tree control_use
)
962 gimple p
= gimple_alloc (GIMPLE_OMP_CONTINUE
, 0);
963 gimple_omp_continue_set_control_def (p
, control_def
);
964 gimple_omp_continue_set_control_use (p
, control_use
);
968 /* Build a GIMPLE_OMP_ORDERED statement.
970 BODY is the sequence of statements inside a loop that will executed in
974 gimple_build_omp_ordered (gimple_seq body
)
976 gimple p
= gimple_alloc (GIMPLE_OMP_ORDERED
, 0);
978 gimple_omp_set_body (p
, body
);
984 /* Build a GIMPLE_OMP_RETURN statement.
985 WAIT_P is true if this is a non-waiting return. */
988 gimple_build_omp_return (bool wait_p
)
990 gimple p
= gimple_alloc (GIMPLE_OMP_RETURN
, 0);
992 gimple_omp_return_set_nowait (p
);
998 /* Build a GIMPLE_OMP_SECTIONS statement.
1000 BODY is a sequence of section statements.
1001 CLAUSES are any of the OMP sections contsruct's clauses: private,
1002 firstprivate, lastprivate, reduction, and nowait. */
1005 gimple_build_omp_sections (gimple_seq body
, tree clauses
)
1007 gimple p
= gimple_alloc (GIMPLE_OMP_SECTIONS
, 0);
1009 gimple_omp_set_body (p
, body
);
1010 gimple_omp_sections_set_clauses (p
, clauses
);
1016 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1019 gimple_build_omp_sections_switch (void)
1021 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH
, 0);
1025 /* Build a GIMPLE_OMP_SINGLE statement.
1027 BODY is the sequence of statements that will be executed once.
1028 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1029 copyprivate, nowait. */
1032 gimple_build_omp_single (gimple_seq body
, tree clauses
)
1034 gimple p
= gimple_alloc (GIMPLE_OMP_SINGLE
, 0);
1036 gimple_omp_set_body (p
, body
);
1037 gimple_omp_single_set_clauses (p
, clauses
);
1043 /* Build a GIMPLE_OMP_TARGET statement.
1045 BODY is the sequence of statements that will be executed.
1046 KIND is the kind of the region.
1047 CLAUSES are any of the construct's clauses. */
1050 gimple_build_omp_target (gimple_seq body
, int kind
, tree clauses
)
1052 gimple p
= gimple_alloc (GIMPLE_OMP_TARGET
, 0);
1054 gimple_omp_set_body (p
, body
);
1055 gimple_omp_target_set_clauses (p
, clauses
);
1056 gimple_omp_target_set_kind (p
, kind
);
1062 /* Build a GIMPLE_OMP_TEAMS statement.
1064 BODY is the sequence of statements that will be executed.
1065 CLAUSES are any of the OMP teams construct's clauses. */
1068 gimple_build_omp_teams (gimple_seq body
, tree clauses
)
1070 gimple p
= gimple_alloc (GIMPLE_OMP_TEAMS
, 0);
1072 gimple_omp_set_body (p
, body
);
1073 gimple_omp_teams_set_clauses (p
, clauses
);
1079 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1082 gimple_build_omp_atomic_load (tree lhs
, tree rhs
)
1084 gimple p
= gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD
, 0);
1085 gimple_omp_atomic_load_set_lhs (p
, lhs
);
1086 gimple_omp_atomic_load_set_rhs (p
, rhs
);
1090 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1092 VAL is the value we are storing. */
1095 gimple_build_omp_atomic_store (tree val
)
1097 gimple p
= gimple_alloc (GIMPLE_OMP_ATOMIC_STORE
, 0);
1098 gimple_omp_atomic_store_set_val (p
, val
);
1102 /* Build a GIMPLE_TRANSACTION statement. */
1105 gimple_build_transaction (gimple_seq body
, tree label
)
1107 gimple p
= gimple_alloc (GIMPLE_TRANSACTION
, 0);
1108 gimple_transaction_set_body (p
, body
);
1109 gimple_transaction_set_label (p
, label
);
1113 /* Build a GIMPLE_PREDICT statement. PREDICT is one of the predictors from
1114 predict.def, OUTCOME is NOT_TAKEN or TAKEN. */
1117 gimple_build_predict (enum br_predictor predictor
, enum prediction outcome
)
1119 gimple p
= gimple_alloc (GIMPLE_PREDICT
, 0);
1120 /* Ensure all the predictors fit into the lower bits of the subcode. */
1121 gcc_assert ((int) END_PREDICTORS
<= GF_PREDICT_TAKEN
);
1122 gimple_predict_set_predictor (p
, predictor
);
1123 gimple_predict_set_outcome (p
, outcome
);
1127 #if defined ENABLE_GIMPLE_CHECKING
1128 /* Complain of a gimple type mismatch and die. */
1131 gimple_check_failed (const_gimple gs
, const char *file
, int line
,
1132 const char *function
, enum gimple_code code
,
1133 enum tree_code subcode
)
1135 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1136 gimple_code_name
[code
],
1137 get_tree_code_name (subcode
),
1138 gimple_code_name
[gimple_code (gs
)],
1140 ? get_tree_code_name ((enum tree_code
) gs
->subcode
)
1142 function
, trim_filename (file
), line
);
1144 #endif /* ENABLE_GIMPLE_CHECKING */
1147 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1148 *SEQ_P is NULL, a new sequence is allocated. */
1151 gimple_seq_add_stmt (gimple_seq
*seq_p
, gimple gs
)
1153 gimple_stmt_iterator si
;
1157 si
= gsi_last (*seq_p
);
1158 gsi_insert_after (&si
, gs
, GSI_NEW_STMT
);
1161 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1162 *SEQ_P is NULL, a new sequence is allocated. This function is
1163 similar to gimple_seq_add_stmt, but does not scan the operands.
1164 During gimplification, we need to manipulate statement sequences
1165 before the def/use vectors have been constructed. */
1168 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple gs
)
1170 gimple_stmt_iterator si
;
1175 si
= gsi_last (*seq_p
);
1176 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
1179 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1180 NULL, a new sequence is allocated. */
1183 gimple_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
1185 gimple_stmt_iterator si
;
1189 si
= gsi_last (*dst_p
);
1190 gsi_insert_seq_after (&si
, src
, GSI_NEW_STMT
);
1193 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1194 NULL, a new sequence is allocated. This function is
1195 similar to gimple_seq_add_seq, but does not scan the operands. */
1198 gimple_seq_add_seq_without_update (gimple_seq
*dst_p
, gimple_seq src
)
1200 gimple_stmt_iterator si
;
1204 si
= gsi_last (*dst_p
);
1205 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
1208 /* Determine whether to assign a location to the statement GS. */
1211 should_carry_location_p (gimple gs
)
1213 /* Don't emit a line note for a label. We particularly don't want to
1214 emit one for the break label, since it doesn't actually correspond
1215 to the beginning of the loop/switch. */
1216 if (gimple_code (gs
) == GIMPLE_LABEL
)
1222 /* Set the location for gimple statement GS to LOCATION. */
1225 annotate_one_with_location (gimple gs
, location_t location
)
1227 if (!gimple_has_location (gs
)
1228 && !gimple_do_not_emit_location_p (gs
)
1229 && should_carry_location_p (gs
))
1230 gimple_set_location (gs
, location
);
1233 /* Set LOCATION for all the statements after iterator GSI in sequence
1234 SEQ. If GSI is pointing to the end of the sequence, start with the
1235 first statement in SEQ. */
1238 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
1239 location_t location
)
1241 if (gsi_end_p (gsi
))
1242 gsi
= gsi_start (seq
);
1246 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
1247 annotate_one_with_location (gsi_stmt (gsi
), location
);
1250 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1253 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
1255 gimple_stmt_iterator i
;
1257 if (gimple_seq_empty_p (stmt_p
))
1260 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
1262 gimple gs
= gsi_stmt (i
);
1263 annotate_one_with_location (gs
, location
);
1267 /* Helper function of empty_body_p. Return true if STMT is an empty
1271 empty_stmt_p (gimple stmt
)
1273 if (gimple_code (stmt
) == GIMPLE_NOP
)
1275 if (gimple_code (stmt
) == GIMPLE_BIND
)
1276 return empty_body_p (gimple_bind_body (stmt
));
1281 /* Return true if BODY contains nothing but empty statements. */
1284 empty_body_p (gimple_seq body
)
1286 gimple_stmt_iterator i
;
1288 if (gimple_seq_empty_p (body
))
1290 for (i
= gsi_start (body
); !gsi_end_p (i
); gsi_next (&i
))
1291 if (!empty_stmt_p (gsi_stmt (i
))
1292 && !is_gimple_debug (gsi_stmt (i
)))
1299 /* Perform a deep copy of sequence SRC and return the result. */
1302 gimple_seq_copy (gimple_seq src
)
1304 gimple_stmt_iterator gsi
;
1305 gimple_seq new_seq
= NULL
;
1308 for (gsi
= gsi_start (src
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1310 stmt
= gimple_copy (gsi_stmt (gsi
));
1311 gimple_seq_add_stmt (&new_seq
, stmt
);
1319 /* Return true if calls C1 and C2 are known to go to the same function. */
1322 gimple_call_same_target_p (const_gimple c1
, const_gimple c2
)
1324 if (gimple_call_internal_p (c1
))
1325 return (gimple_call_internal_p (c2
)
1326 && gimple_call_internal_fn (c1
) == gimple_call_internal_fn (c2
));
1328 return (gimple_call_fn (c1
) == gimple_call_fn (c2
)
1329 || (gimple_call_fndecl (c1
)
1330 && gimple_call_fndecl (c1
) == gimple_call_fndecl (c2
)));
1333 /* Detect flags from a GIMPLE_CALL. This is just like
1334 call_expr_flags, but for gimple tuples. */
1337 gimple_call_flags (const_gimple stmt
)
1340 tree decl
= gimple_call_fndecl (stmt
);
1343 flags
= flags_from_decl_or_type (decl
);
1344 else if (gimple_call_internal_p (stmt
))
1345 flags
= internal_fn_flags (gimple_call_internal_fn (stmt
));
1347 flags
= flags_from_decl_or_type (gimple_call_fntype (stmt
));
1349 if (stmt
->subcode
& GF_CALL_NOTHROW
)
1350 flags
|= ECF_NOTHROW
;
1355 /* Return the "fn spec" string for call STMT. */
1358 gimple_call_fnspec (const_gimple stmt
)
1362 if (gimple_call_internal_p (stmt
))
1363 return internal_fn_fnspec (gimple_call_internal_fn (stmt
));
1365 type
= gimple_call_fntype (stmt
);
1369 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
1373 return TREE_VALUE (TREE_VALUE (attr
));
1376 /* Detects argument flags for argument number ARG on call STMT. */
1379 gimple_call_arg_flags (const_gimple stmt
, unsigned arg
)
1381 const_tree attr
= gimple_call_fnspec (stmt
);
1383 if (!attr
|| 1 + arg
>= (unsigned) TREE_STRING_LENGTH (attr
))
1386 switch (TREE_STRING_POINTER (attr
)[1 + arg
])
1393 return EAF_DIRECT
| EAF_NOCLOBBER
| EAF_NOESCAPE
;
1396 return EAF_NOCLOBBER
| EAF_NOESCAPE
;
1399 return EAF_DIRECT
| EAF_NOESCAPE
;
1402 return EAF_NOESCAPE
;
1410 /* Detects return flags for the call STMT. */
1413 gimple_call_return_flags (const_gimple stmt
)
1417 if (gimple_call_flags (stmt
) & ECF_MALLOC
)
1420 attr
= gimple_call_fnspec (stmt
);
1421 if (!attr
|| TREE_STRING_LENGTH (attr
) < 1)
1424 switch (TREE_STRING_POINTER (attr
)[0])
1430 return ERF_RETURNS_ARG
| (TREE_STRING_POINTER (attr
)[0] - '1');
1442 /* Return true if GS is a copy assignment. */
1445 gimple_assign_copy_p (gimple gs
)
1447 return (gimple_assign_single_p (gs
)
1448 && is_gimple_val (gimple_op (gs
, 1)));
1452 /* Return true if GS is a SSA_NAME copy assignment. */
1455 gimple_assign_ssa_name_copy_p (gimple gs
)
1457 return (gimple_assign_single_p (gs
)
1458 && TREE_CODE (gimple_assign_lhs (gs
)) == SSA_NAME
1459 && TREE_CODE (gimple_assign_rhs1 (gs
)) == SSA_NAME
);
1463 /* Return true if GS is an assignment with a unary RHS, but the
1464 operator has no effect on the assigned value. The logic is adapted
1465 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1466 instances in which STRIP_NOPS was previously applied to the RHS of
1469 NOTE: In the use cases that led to the creation of this function
1470 and of gimple_assign_single_p, it is typical to test for either
1471 condition and to proceed in the same manner. In each case, the
1472 assigned value is represented by the single RHS operand of the
1473 assignment. I suspect there may be cases where gimple_assign_copy_p,
1474 gimple_assign_single_p, or equivalent logic is used where a similar
1475 treatment of unary NOPs is appropriate. */
1478 gimple_assign_unary_nop_p (gimple gs
)
1480 return (is_gimple_assign (gs
)
1481 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs
))
1482 || gimple_assign_rhs_code (gs
) == NON_LVALUE_EXPR
)
1483 && gimple_assign_rhs1 (gs
) != error_mark_node
1484 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs
)))
1485 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs
)))));
1488 /* Set BB to be the basic block holding G. */
1491 gimple_set_bb (gimple stmt
, basic_block bb
)
1495 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1498 /* If the statement is a label, add the label to block-to-labels map
1499 so that we can speed up edge creation for GIMPLE_GOTOs. */
1505 t
= gimple_label_label (stmt
);
1506 uid
= LABEL_DECL_UID (t
);
1510 vec_safe_length (label_to_block_map_for_fn (cfun
));
1511 LABEL_DECL_UID (t
) = uid
= cfun
->cfg
->last_label_uid
++;
1512 if (old_len
<= (unsigned) uid
)
1514 unsigned new_len
= 3 * uid
/ 2 + 1;
1516 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun
),
1521 (*label_to_block_map_for_fn (cfun
))[uid
] = bb
;
1526 /* Modify the RHS of the assignment pointed-to by GSI using the
1527 operands in the expression tree EXPR.
1529 NOTE: The statement pointed-to by GSI may be reallocated if it
1530 did not have enough operand slots.
1532 This function is useful to convert an existing tree expression into
1533 the flat representation used for the RHS of a GIMPLE assignment.
1534 It will reallocate memory as needed to expand or shrink the number
1535 of operand slots needed to represent EXPR.
1537 NOTE: If you find yourself building a tree and then calling this
1538 function, you are most certainly doing it the slow way. It is much
1539 better to build a new assignment or to use the function
1540 gimple_assign_set_rhs_with_ops, which does not require an
1541 expression tree to be built. */
1544 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*gsi
, tree expr
)
1546 enum tree_code subcode
;
1549 extract_ops_from_tree_1 (expr
, &subcode
, &op1
, &op2
, &op3
);
1550 gimple_assign_set_rhs_with_ops_1 (gsi
, subcode
, op1
, op2
, op3
);
1554 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1555 operands OP1, OP2 and OP3.
1557 NOTE: The statement pointed-to by GSI may be reallocated if it
1558 did not have enough operand slots. */
1561 gimple_assign_set_rhs_with_ops_1 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
1562 tree op1
, tree op2
, tree op3
)
1564 unsigned new_rhs_ops
= get_gimple_rhs_num_ops (code
);
1565 gimple stmt
= gsi_stmt (*gsi
);
1567 /* If the new CODE needs more operands, allocate a new statement. */
1568 if (gimple_num_ops (stmt
) < new_rhs_ops
+ 1)
1570 tree lhs
= gimple_assign_lhs (stmt
);
1571 gimple new_stmt
= gimple_alloc (gimple_code (stmt
), new_rhs_ops
+ 1);
1572 memcpy (new_stmt
, stmt
, gimple_size (gimple_code (stmt
)));
1573 gimple_init_singleton (new_stmt
);
1574 gsi_replace (gsi
, new_stmt
, true);
1577 /* The LHS needs to be reset as this also changes the SSA name
1579 gimple_assign_set_lhs (stmt
, lhs
);
1582 gimple_set_num_ops (stmt
, new_rhs_ops
+ 1);
1583 gimple_set_subcode (stmt
, code
);
1584 gimple_assign_set_rhs1 (stmt
, op1
);
1585 if (new_rhs_ops
> 1)
1586 gimple_assign_set_rhs2 (stmt
, op2
);
1587 if (new_rhs_ops
> 2)
1588 gimple_assign_set_rhs3 (stmt
, op3
);
1592 /* Return the LHS of a statement that performs an assignment,
1593 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1594 for a call to a function that returns no value, or for a
1595 statement other than an assignment or a call. */
1598 gimple_get_lhs (const_gimple stmt
)
1600 enum gimple_code code
= gimple_code (stmt
);
1602 if (code
== GIMPLE_ASSIGN
)
1603 return gimple_assign_lhs (stmt
);
1604 else if (code
== GIMPLE_CALL
)
1605 return gimple_call_lhs (stmt
);
1611 /* Set the LHS of a statement that performs an assignment,
1612 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1615 gimple_set_lhs (gimple stmt
, tree lhs
)
1617 enum gimple_code code
= gimple_code (stmt
);
1619 if (code
== GIMPLE_ASSIGN
)
1620 gimple_assign_set_lhs (stmt
, lhs
);
1621 else if (code
== GIMPLE_CALL
)
1622 gimple_call_set_lhs (stmt
, lhs
);
1628 /* Return a deep copy of statement STMT. All the operands from STMT
1629 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1630 and VUSE operand arrays are set to empty in the new copy. The new
1631 copy isn't part of any sequence. */
1634 gimple_copy (gimple stmt
)
1636 enum gimple_code code
= gimple_code (stmt
);
1637 unsigned num_ops
= gimple_num_ops (stmt
);
1638 gimple copy
= gimple_alloc (code
, num_ops
);
1641 /* Shallow copy all the fields from STMT. */
1642 memcpy (copy
, stmt
, gimple_size (code
));
1643 gimple_init_singleton (copy
);
1645 /* If STMT has sub-statements, deep-copy them as well. */
1646 if (gimple_has_substatements (stmt
))
1651 switch (gimple_code (stmt
))
1654 new_seq
= gimple_seq_copy (gimple_bind_body (stmt
));
1655 gimple_bind_set_body (copy
, new_seq
);
1656 gimple_bind_set_vars (copy
, unshare_expr (gimple_bind_vars (stmt
)));
1657 gimple_bind_set_block (copy
, gimple_bind_block (stmt
));
1661 new_seq
= gimple_seq_copy (gimple_catch_handler (stmt
));
1662 gimple_catch_set_handler (copy
, new_seq
);
1663 t
= unshare_expr (gimple_catch_types (stmt
));
1664 gimple_catch_set_types (copy
, t
);
1667 case GIMPLE_EH_FILTER
:
1668 new_seq
= gimple_seq_copy (gimple_eh_filter_failure (stmt
));
1669 gimple_eh_filter_set_failure (copy
, new_seq
);
1670 t
= unshare_expr (gimple_eh_filter_types (stmt
));
1671 gimple_eh_filter_set_types (copy
, t
);
1674 case GIMPLE_EH_ELSE
:
1675 new_seq
= gimple_seq_copy (gimple_eh_else_n_body (stmt
));
1676 gimple_eh_else_set_n_body (copy
, new_seq
);
1677 new_seq
= gimple_seq_copy (gimple_eh_else_e_body (stmt
));
1678 gimple_eh_else_set_e_body (copy
, new_seq
);
1682 new_seq
= gimple_seq_copy (gimple_try_eval (stmt
));
1683 gimple_try_set_eval (copy
, new_seq
);
1684 new_seq
= gimple_seq_copy (gimple_try_cleanup (stmt
));
1685 gimple_try_set_cleanup (copy
, new_seq
);
1688 case GIMPLE_OMP_FOR
:
1689 gcc_assert (!is_gimple_omp_oacc_specifically (stmt
));
1690 new_seq
= gimple_seq_copy (gimple_omp_for_pre_body (stmt
));
1691 gimple_omp_for_set_pre_body (copy
, new_seq
);
1692 t
= unshare_expr (gimple_omp_for_clauses (stmt
));
1693 gimple_omp_for_set_clauses (copy
, t
);
1695 gimple_statement_omp_for
*omp_for_copy
=
1696 as_a
<gimple_statement_omp_for
*> (copy
);
1697 omp_for_copy
->iter
= ggc_vec_alloc
<gimple_omp_for_iter
>
1698 ( gimple_omp_for_collapse (stmt
));
1700 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1702 gimple_omp_for_set_cond (copy
, i
,
1703 gimple_omp_for_cond (stmt
, i
));
1704 gimple_omp_for_set_index (copy
, i
,
1705 gimple_omp_for_index (stmt
, i
));
1706 t
= unshare_expr (gimple_omp_for_initial (stmt
, i
));
1707 gimple_omp_for_set_initial (copy
, i
, t
);
1708 t
= unshare_expr (gimple_omp_for_final (stmt
, i
));
1709 gimple_omp_for_set_final (copy
, i
, t
);
1710 t
= unshare_expr (gimple_omp_for_incr (stmt
, i
));
1711 gimple_omp_for_set_incr (copy
, i
, t
);
1715 case GIMPLE_OMP_PARALLEL
:
1716 t
= unshare_expr (gimple_omp_parallel_clauses (stmt
));
1717 gimple_omp_parallel_set_clauses (copy
, t
);
1718 t
= unshare_expr (gimple_omp_parallel_child_fn (stmt
));
1719 gimple_omp_parallel_set_child_fn (copy
, t
);
1720 t
= unshare_expr (gimple_omp_parallel_data_arg (stmt
));
1721 gimple_omp_parallel_set_data_arg (copy
, t
);
1724 case GIMPLE_OMP_TASK
:
1725 t
= unshare_expr (gimple_omp_task_clauses (stmt
));
1726 gimple_omp_task_set_clauses (copy
, t
);
1727 t
= unshare_expr (gimple_omp_task_child_fn (stmt
));
1728 gimple_omp_task_set_child_fn (copy
, t
);
1729 t
= unshare_expr (gimple_omp_task_data_arg (stmt
));
1730 gimple_omp_task_set_data_arg (copy
, t
);
1731 t
= unshare_expr (gimple_omp_task_copy_fn (stmt
));
1732 gimple_omp_task_set_copy_fn (copy
, t
);
1733 t
= unshare_expr (gimple_omp_task_arg_size (stmt
));
1734 gimple_omp_task_set_arg_size (copy
, t
);
1735 t
= unshare_expr (gimple_omp_task_arg_align (stmt
));
1736 gimple_omp_task_set_arg_align (copy
, t
);
1739 case GIMPLE_OMP_CRITICAL
:
1740 t
= unshare_expr (gimple_omp_critical_name (stmt
));
1741 gimple_omp_critical_set_name (copy
, t
);
1744 case GIMPLE_OMP_SECTIONS
:
1745 t
= unshare_expr (gimple_omp_sections_clauses (stmt
));
1746 gimple_omp_sections_set_clauses (copy
, t
);
1747 t
= unshare_expr (gimple_omp_sections_control (stmt
));
1748 gimple_omp_sections_set_control (copy
, t
);
1751 case GIMPLE_OMP_SINGLE
:
1752 case GIMPLE_OMP_TARGET
:
1753 case GIMPLE_OMP_TEAMS
:
1754 case GIMPLE_OMP_SECTION
:
1755 case GIMPLE_OMP_MASTER
:
1756 case GIMPLE_OMP_TASKGROUP
:
1757 case GIMPLE_OMP_ORDERED
:
1759 gcc_assert (!is_gimple_omp_oacc_specifically (stmt
));
1760 new_seq
= gimple_seq_copy (gimple_omp_body (stmt
));
1761 gimple_omp_set_body (copy
, new_seq
);
1764 case GIMPLE_TRANSACTION
:
1765 new_seq
= gimple_seq_copy (gimple_transaction_body (stmt
));
1766 gimple_transaction_set_body (copy
, new_seq
);
1769 case GIMPLE_WITH_CLEANUP_EXPR
:
1770 new_seq
= gimple_seq_copy (gimple_wce_cleanup (stmt
));
1771 gimple_wce_set_cleanup (copy
, new_seq
);
1779 /* Make copy of operands. */
1780 for (i
= 0; i
< num_ops
; i
++)
1781 gimple_set_op (copy
, i
, unshare_expr (gimple_op (stmt
, i
)));
1783 if (gimple_has_mem_ops (stmt
))
1785 gimple_set_vdef (copy
, gimple_vdef (stmt
));
1786 gimple_set_vuse (copy
, gimple_vuse (stmt
));
1789 /* Clear out SSA operand vectors on COPY. */
1790 if (gimple_has_ops (stmt
))
1792 gimple_set_use_ops (copy
, NULL
);
1794 /* SSA operands need to be updated. */
1795 gimple_set_modified (copy
, true);
1802 /* Return true if statement S has side-effects. We consider a
1803 statement to have side effects if:
1805 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
1806 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
1809 gimple_has_side_effects (const_gimple s
)
1811 if (is_gimple_debug (s
))
1814 /* We don't have to scan the arguments to check for
1815 volatile arguments, though, at present, we still
1816 do a scan to check for TREE_SIDE_EFFECTS. */
1817 if (gimple_has_volatile_ops (s
))
1820 if (gimple_code (s
) == GIMPLE_ASM
1821 && gimple_asm_volatile_p (s
))
1824 if (is_gimple_call (s
))
1826 int flags
= gimple_call_flags (s
);
1828 /* An infinite loop is considered a side effect. */
1829 if (!(flags
& (ECF_CONST
| ECF_PURE
))
1830 || (flags
& ECF_LOOPING_CONST_OR_PURE
))
1839 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
1840 Return true if S can trap. When INCLUDE_MEM is true, check whether
1841 the memory operations could trap. When INCLUDE_STORES is true and
1842 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
1845 gimple_could_trap_p_1 (gimple s
, bool include_mem
, bool include_stores
)
1847 tree t
, div
= NULL_TREE
;
1852 unsigned i
, start
= (is_gimple_assign (s
) && !include_stores
) ? 1 : 0;
1854 for (i
= start
; i
< gimple_num_ops (s
); i
++)
1855 if (tree_could_trap_p (gimple_op (s
, i
)))
1859 switch (gimple_code (s
))
1862 return gimple_asm_volatile_p (s
);
1865 t
= gimple_call_fndecl (s
);
1866 /* Assume that calls to weak functions may trap. */
1867 if (!t
|| !DECL_P (t
) || DECL_WEAK (t
))
1872 t
= gimple_expr_type (s
);
1873 op
= gimple_assign_rhs_code (s
);
1874 if (get_gimple_rhs_class (op
) == GIMPLE_BINARY_RHS
)
1875 div
= gimple_assign_rhs2 (s
);
1876 return (operation_could_trap_p (op
, FLOAT_TYPE_P (t
),
1877 (INTEGRAL_TYPE_P (t
)
1878 && TYPE_OVERFLOW_TRAPS (t
)),
1888 /* Return true if statement S can trap. */
1891 gimple_could_trap_p (gimple s
)
1893 return gimple_could_trap_p_1 (s
, true, true);
1896 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
1899 gimple_assign_rhs_could_trap_p (gimple s
)
1901 gcc_assert (is_gimple_assign (s
));
1902 return gimple_could_trap_p_1 (s
, true, false);
1906 /* Print debugging information for gimple stmts generated. */
1909 dump_gimple_statistics (void)
1911 int i
, total_tuples
= 0, total_bytes
= 0;
1913 if (! GATHER_STATISTICS
)
1915 fprintf (stderr
, "No gimple statistics\n");
1919 fprintf (stderr
, "\nGIMPLE statements\n");
1920 fprintf (stderr
, "Kind Stmts Bytes\n");
1921 fprintf (stderr
, "---------------------------------------\n");
1922 for (i
= 0; i
< (int) gimple_alloc_kind_all
; ++i
)
1924 fprintf (stderr
, "%-20s %7d %10d\n", gimple_alloc_kind_names
[i
],
1925 gimple_alloc_counts
[i
], gimple_alloc_sizes
[i
]);
1926 total_tuples
+= gimple_alloc_counts
[i
];
1927 total_bytes
+= gimple_alloc_sizes
[i
];
1929 fprintf (stderr
, "---------------------------------------\n");
1930 fprintf (stderr
, "%-20s %7d %10d\n", "Total", total_tuples
, total_bytes
);
1931 fprintf (stderr
, "---------------------------------------\n");
1935 /* Return the number of operands needed on the RHS of a GIMPLE
1936 assignment for an expression with tree code CODE. */
1939 get_gimple_rhs_num_ops (enum tree_code code
)
1941 enum gimple_rhs_class rhs_class
= get_gimple_rhs_class (code
);
1943 if (rhs_class
== GIMPLE_UNARY_RHS
|| rhs_class
== GIMPLE_SINGLE_RHS
)
1945 else if (rhs_class
== GIMPLE_BINARY_RHS
)
1947 else if (rhs_class
== GIMPLE_TERNARY_RHS
)
1953 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
1955 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
1956 : ((TYPE) == tcc_binary \
1957 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
1958 : ((TYPE) == tcc_constant \
1959 || (TYPE) == tcc_declaration \
1960 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
1961 : ((SYM) == TRUTH_AND_EXPR \
1962 || (SYM) == TRUTH_OR_EXPR \
1963 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
1964 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
1965 : ((SYM) == COND_EXPR \
1966 || (SYM) == WIDEN_MULT_PLUS_EXPR \
1967 || (SYM) == WIDEN_MULT_MINUS_EXPR \
1968 || (SYM) == DOT_PROD_EXPR \
1969 || (SYM) == SAD_EXPR \
1970 || (SYM) == REALIGN_LOAD_EXPR \
1971 || (SYM) == VEC_COND_EXPR \
1972 || (SYM) == VEC_PERM_EXPR \
1973 || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS \
1974 : ((SYM) == CONSTRUCTOR \
1975 || (SYM) == OBJ_TYPE_REF \
1976 || (SYM) == ASSERT_EXPR \
1977 || (SYM) == ADDR_EXPR \
1978 || (SYM) == WITH_SIZE_EXPR \
1979 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
1980 : GIMPLE_INVALID_RHS),
1981 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
1983 const unsigned char gimple_rhs_class_table
[] = {
1984 #include "all-tree.def"
1988 #undef END_OF_BASE_TREE_CODES
1990 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
1991 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
1992 we failed to create one. */
1995 canonicalize_cond_expr_cond (tree t
)
1997 /* Strip conversions around boolean operations. */
1998 if (CONVERT_EXPR_P (t
)
1999 && (truth_value_p (TREE_CODE (TREE_OPERAND (t
, 0)))
2000 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
2002 t
= TREE_OPERAND (t
, 0);
2004 /* For !x use x == 0. */
2005 if (TREE_CODE (t
) == TRUTH_NOT_EXPR
)
2007 tree top0
= TREE_OPERAND (t
, 0);
2008 t
= build2 (EQ_EXPR
, TREE_TYPE (t
),
2009 top0
, build_int_cst (TREE_TYPE (top0
), 0));
2011 /* For cmp ? 1 : 0 use cmp. */
2012 else if (TREE_CODE (t
) == COND_EXPR
2013 && COMPARISON_CLASS_P (TREE_OPERAND (t
, 0))
2014 && integer_onep (TREE_OPERAND (t
, 1))
2015 && integer_zerop (TREE_OPERAND (t
, 2)))
2017 tree top0
= TREE_OPERAND (t
, 0);
2018 t
= build2 (TREE_CODE (top0
), TREE_TYPE (t
),
2019 TREE_OPERAND (top0
, 0), TREE_OPERAND (top0
, 1));
2021 /* For x ^ y use x != y. */
2022 else if (TREE_CODE (t
) == BIT_XOR_EXPR
)
2023 t
= build2 (NE_EXPR
, TREE_TYPE (t
),
2024 TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1));
2026 if (is_gimple_condexpr (t
))
2032 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2033 the positions marked by the set ARGS_TO_SKIP. */
2036 gimple_call_copy_skip_args (gimple stmt
, bitmap args_to_skip
)
2039 int nargs
= gimple_call_num_args (stmt
);
2040 auto_vec
<tree
> vargs (nargs
);
2043 for (i
= 0; i
< nargs
; i
++)
2044 if (!bitmap_bit_p (args_to_skip
, i
))
2045 vargs
.quick_push (gimple_call_arg (stmt
, i
));
2047 if (gimple_call_internal_p (stmt
))
2048 new_stmt
= gimple_build_call_internal_vec (gimple_call_internal_fn (stmt
),
2051 new_stmt
= gimple_build_call_vec (gimple_call_fn (stmt
), vargs
);
2053 if (gimple_call_lhs (stmt
))
2054 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2056 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2057 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
2059 if (gimple_has_location (stmt
))
2060 gimple_set_location (new_stmt
, gimple_location (stmt
));
2061 gimple_call_copy_flags (new_stmt
, stmt
);
2062 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2064 gimple_set_modified (new_stmt
, true);
2071 /* Return true if the field decls F1 and F2 are at the same offset.
2073 This is intended to be used on GIMPLE types only. */
2076 gimple_compare_field_offset (tree f1
, tree f2
)
2078 if (DECL_OFFSET_ALIGN (f1
) == DECL_OFFSET_ALIGN (f2
))
2080 tree offset1
= DECL_FIELD_OFFSET (f1
);
2081 tree offset2
= DECL_FIELD_OFFSET (f2
);
2082 return ((offset1
== offset2
2083 /* Once gimplification is done, self-referential offsets are
2084 instantiated as operand #2 of the COMPONENT_REF built for
2085 each access and reset. Therefore, they are not relevant
2086 anymore and fields are interchangeable provided that they
2087 represent the same access. */
2088 || (TREE_CODE (offset1
) == PLACEHOLDER_EXPR
2089 && TREE_CODE (offset2
) == PLACEHOLDER_EXPR
2090 && (DECL_SIZE (f1
) == DECL_SIZE (f2
)
2091 || (TREE_CODE (DECL_SIZE (f1
)) == PLACEHOLDER_EXPR
2092 && TREE_CODE (DECL_SIZE (f2
)) == PLACEHOLDER_EXPR
)
2093 || operand_equal_p (DECL_SIZE (f1
), DECL_SIZE (f2
), 0))
2094 && DECL_ALIGN (f1
) == DECL_ALIGN (f2
))
2095 || operand_equal_p (offset1
, offset2
, 0))
2096 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1
),
2097 DECL_FIELD_BIT_OFFSET (f2
)));
2100 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2101 should be, so handle differing ones specially by decomposing
2102 the offset into a byte and bit offset manually. */
2103 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1
))
2104 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2
)))
2106 unsigned HOST_WIDE_INT byte_offset1
, byte_offset2
;
2107 unsigned HOST_WIDE_INT bit_offset1
, bit_offset2
;
2108 bit_offset1
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1
));
2109 byte_offset1
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1
))
2110 + bit_offset1
/ BITS_PER_UNIT
);
2111 bit_offset2
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2
));
2112 byte_offset2
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2
))
2113 + bit_offset2
/ BITS_PER_UNIT
);
2114 if (byte_offset1
!= byte_offset2
)
2116 return bit_offset1
% BITS_PER_UNIT
== bit_offset2
% BITS_PER_UNIT
;
2123 /* Return a type the same as TYPE except unsigned or
2124 signed according to UNSIGNEDP. */
2127 gimple_signed_or_unsigned_type (bool unsignedp
, tree type
)
2132 type1
= TYPE_MAIN_VARIANT (type
);
2133 if (type1
== signed_char_type_node
2134 || type1
== char_type_node
2135 || type1
== unsigned_char_type_node
)
2136 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2137 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2138 return unsignedp
? unsigned_type_node
: integer_type_node
;
2139 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2140 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2141 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2142 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2143 if (type1
== long_long_integer_type_node
2144 || type1
== long_long_unsigned_type_node
)
2146 ? long_long_unsigned_type_node
2147 : long_long_integer_type_node
;
2149 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2150 if (int_n_enabled_p
[i
]
2151 && (type1
== int_n_trees
[i
].unsigned_type
2152 || type1
== int_n_trees
[i
].signed_type
))
2154 ? int_n_trees
[i
].unsigned_type
2155 : int_n_trees
[i
].signed_type
;
2157 #if HOST_BITS_PER_WIDE_INT >= 64
2158 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2159 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2161 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2162 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2163 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2164 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2165 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2166 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2167 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2168 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2170 #define GIMPLE_FIXED_TYPES(NAME) \
2171 if (type1 == short_ ## NAME ## _type_node \
2172 || type1 == unsigned_short_ ## NAME ## _type_node) \
2173 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2174 : short_ ## NAME ## _type_node; \
2175 if (type1 == NAME ## _type_node \
2176 || type1 == unsigned_ ## NAME ## _type_node) \
2177 return unsignedp ? unsigned_ ## NAME ## _type_node \
2178 : NAME ## _type_node; \
2179 if (type1 == long_ ## NAME ## _type_node \
2180 || type1 == unsigned_long_ ## NAME ## _type_node) \
2181 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2182 : long_ ## NAME ## _type_node; \
2183 if (type1 == long_long_ ## NAME ## _type_node \
2184 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2185 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2186 : long_long_ ## NAME ## _type_node;
2188 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2189 if (type1 == NAME ## _type_node \
2190 || type1 == u ## NAME ## _type_node) \
2191 return unsignedp ? u ## NAME ## _type_node \
2192 : NAME ## _type_node;
2194 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2195 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2196 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2197 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2198 : sat_ ## short_ ## NAME ## _type_node; \
2199 if (type1 == sat_ ## NAME ## _type_node \
2200 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2201 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2202 : sat_ ## NAME ## _type_node; \
2203 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2204 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2205 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2206 : sat_ ## long_ ## NAME ## _type_node; \
2207 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2208 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2209 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2210 : sat_ ## long_long_ ## NAME ## _type_node;
2212 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2213 if (type1 == sat_ ## NAME ## _type_node \
2214 || type1 == sat_ ## u ## NAME ## _type_node) \
2215 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2216 : sat_ ## NAME ## _type_node;
2218 GIMPLE_FIXED_TYPES (fract
);
2219 GIMPLE_FIXED_TYPES_SAT (fract
);
2220 GIMPLE_FIXED_TYPES (accum
);
2221 GIMPLE_FIXED_TYPES_SAT (accum
);
2223 GIMPLE_FIXED_MODE_TYPES (qq
);
2224 GIMPLE_FIXED_MODE_TYPES (hq
);
2225 GIMPLE_FIXED_MODE_TYPES (sq
);
2226 GIMPLE_FIXED_MODE_TYPES (dq
);
2227 GIMPLE_FIXED_MODE_TYPES (tq
);
2228 GIMPLE_FIXED_MODE_TYPES_SAT (qq
);
2229 GIMPLE_FIXED_MODE_TYPES_SAT (hq
);
2230 GIMPLE_FIXED_MODE_TYPES_SAT (sq
);
2231 GIMPLE_FIXED_MODE_TYPES_SAT (dq
);
2232 GIMPLE_FIXED_MODE_TYPES_SAT (tq
);
2233 GIMPLE_FIXED_MODE_TYPES (ha
);
2234 GIMPLE_FIXED_MODE_TYPES (sa
);
2235 GIMPLE_FIXED_MODE_TYPES (da
);
2236 GIMPLE_FIXED_MODE_TYPES (ta
);
2237 GIMPLE_FIXED_MODE_TYPES_SAT (ha
);
2238 GIMPLE_FIXED_MODE_TYPES_SAT (sa
);
2239 GIMPLE_FIXED_MODE_TYPES_SAT (da
);
2240 GIMPLE_FIXED_MODE_TYPES_SAT (ta
);
2242 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2243 the precision; they have precision set to match their range, but
2244 may use a wider mode to match an ABI. If we change modes, we may
2245 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2246 the precision as well, so as to yield correct results for
2247 bit-field types. C++ does not have these separate bit-field
2248 types, and producing a signed or unsigned variant of an
2249 ENUMERAL_TYPE may cause other problems as well. */
2250 if (!INTEGRAL_TYPE_P (type
)
2251 || TYPE_UNSIGNED (type
) == unsignedp
)
2254 #define TYPE_OK(node) \
2255 (TYPE_MODE (type) == TYPE_MODE (node) \
2256 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2257 if (TYPE_OK (signed_char_type_node
))
2258 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2259 if (TYPE_OK (integer_type_node
))
2260 return unsignedp
? unsigned_type_node
: integer_type_node
;
2261 if (TYPE_OK (short_integer_type_node
))
2262 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2263 if (TYPE_OK (long_integer_type_node
))
2264 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2265 if (TYPE_OK (long_long_integer_type_node
))
2267 ? long_long_unsigned_type_node
2268 : long_long_integer_type_node
);
2270 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2271 if (int_n_enabled_p
[i
]
2272 && TYPE_MODE (type
) == int_n_data
[i
].m
2273 && TYPE_PRECISION (type
) == int_n_data
[i
].bitsize
)
2275 ? int_n_trees
[i
].unsigned_type
2276 : int_n_trees
[i
].signed_type
;
2278 #if HOST_BITS_PER_WIDE_INT >= 64
2279 if (TYPE_OK (intTI_type_node
))
2280 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2282 if (TYPE_OK (intDI_type_node
))
2283 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2284 if (TYPE_OK (intSI_type_node
))
2285 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2286 if (TYPE_OK (intHI_type_node
))
2287 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2288 if (TYPE_OK (intQI_type_node
))
2289 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2291 #undef GIMPLE_FIXED_TYPES
2292 #undef GIMPLE_FIXED_MODE_TYPES
2293 #undef GIMPLE_FIXED_TYPES_SAT
2294 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2297 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2301 /* Return an unsigned type the same as TYPE in other respects. */
2304 gimple_unsigned_type (tree type
)
2306 return gimple_signed_or_unsigned_type (true, type
);
2310 /* Return a signed type the same as TYPE in other respects. */
2313 gimple_signed_type (tree type
)
2315 return gimple_signed_or_unsigned_type (false, type
);
2319 /* Return the typed-based alias set for T, which may be an expression
2320 or a type. Return -1 if we don't do anything special. */
2323 gimple_get_alias_set (tree t
)
2327 /* Permit type-punning when accessing a union, provided the access
2328 is directly through the union. For example, this code does not
2329 permit taking the address of a union member and then storing
2330 through it. Even the type-punning allowed here is a GCC
2331 extension, albeit a common and useful one; the C standard says
2332 that such accesses have implementation-defined behavior. */
2334 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2335 u
= TREE_OPERAND (u
, 0))
2336 if (TREE_CODE (u
) == COMPONENT_REF
2337 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2340 /* That's all the expressions we handle specially. */
2344 /* For convenience, follow the C standard when dealing with
2345 character types. Any object may be accessed via an lvalue that
2346 has character type. */
2347 if (t
== char_type_node
2348 || t
== signed_char_type_node
2349 || t
== unsigned_char_type_node
)
2352 /* Allow aliasing between signed and unsigned variants of the same
2353 type. We treat the signed variant as canonical. */
2354 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2356 tree t1
= gimple_signed_type (t
);
2358 /* t1 == t can happen for boolean nodes which are always unsigned. */
2360 return get_alias_set (t1
);
2367 /* Helper for gimple_ior_addresses_taken_1. */
2370 gimple_ior_addresses_taken_1 (gimple
, tree addr
, tree
, void *data
)
2372 bitmap addresses_taken
= (bitmap
)data
;
2373 addr
= get_base_address (addr
);
2377 bitmap_set_bit (addresses_taken
, DECL_UID (addr
));
2383 /* Set the bit for the uid of all decls that have their address taken
2384 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2385 were any in this stmt. */
2388 gimple_ior_addresses_taken (bitmap addresses_taken
, gimple stmt
)
2390 return walk_stmt_load_store_addr_ops (stmt
, addresses_taken
, NULL
, NULL
,
2391 gimple_ior_addresses_taken_1
);
2395 /* Return true if TYPE1 and TYPE2 are compatible enough for builtin
2399 validate_type (tree type1
, tree type2
)
2401 if (INTEGRAL_TYPE_P (type1
)
2402 && INTEGRAL_TYPE_P (type2
))
2404 else if (POINTER_TYPE_P (type1
)
2405 && POINTER_TYPE_P (type2
))
2407 else if (TREE_CODE (type1
)
2408 != TREE_CODE (type2
))
2413 /* Return true when STMTs arguments and return value match those of FNDECL,
2414 a decl of a builtin function. */
2417 gimple_builtin_call_types_compatible_p (const_gimple stmt
, tree fndecl
)
2419 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
);
2421 tree ret
= gimple_call_lhs (stmt
);
2423 && !validate_type (TREE_TYPE (ret
), TREE_TYPE (TREE_TYPE (fndecl
))))
2426 tree targs
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2427 unsigned nargs
= gimple_call_num_args (stmt
);
2428 for (unsigned i
= 0; i
< nargs
; ++i
)
2430 /* Variadic args follow. */
2433 tree arg
= gimple_call_arg (stmt
, i
);
2434 if (!validate_type (TREE_TYPE (arg
), TREE_VALUE (targs
)))
2436 targs
= TREE_CHAIN (targs
);
2438 if (targs
&& !VOID_TYPE_P (TREE_VALUE (targs
)))
2443 /* Return true when STMT is builtins call. */
2446 gimple_call_builtin_p (const_gimple stmt
)
2449 if (is_gimple_call (stmt
)
2450 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2451 && DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
)
2452 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2456 /* Return true when STMT is builtins call to CLASS. */
2459 gimple_call_builtin_p (const_gimple stmt
, enum built_in_class klass
)
2462 if (is_gimple_call (stmt
)
2463 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2464 && DECL_BUILT_IN_CLASS (fndecl
) == klass
)
2465 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2469 /* Return true when STMT is builtins call to CODE of CLASS. */
2472 gimple_call_builtin_p (const_gimple stmt
, enum built_in_function code
)
2475 if (is_gimple_call (stmt
)
2476 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2477 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
2478 && DECL_FUNCTION_CODE (fndecl
) == code
)
2479 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2483 /* Return true if STMT clobbers memory. STMT is required to be a
2487 gimple_asm_clobbers_memory_p (const_gimple stmt
)
2491 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
2493 tree op
= gimple_asm_clobber_op (stmt
, i
);
2494 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op
)), "memory") == 0)
2501 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2504 dump_decl_set (FILE *file
, bitmap set
)
2511 fprintf (file
, "{ ");
2513 EXECUTE_IF_SET_IN_BITMAP (set
, 0, i
, bi
)
2515 fprintf (file
, "D.%u", i
);
2516 fprintf (file
, " ");
2519 fprintf (file
, "}");
2522 fprintf (file
, "NIL");
2525 /* Return true when CALL is a call stmt that definitely doesn't
2526 free any memory or makes it unavailable otherwise. */
2528 nonfreeing_call_p (gimple call
)
2530 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2531 && gimple_call_flags (call
) & ECF_LEAF
)
2532 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call
)))
2534 /* Just in case these become ECF_LEAF in the future. */
2536 case BUILT_IN_TM_FREE
:
2537 case BUILT_IN_REALLOC
:
2538 case BUILT_IN_STACK_RESTORE
:
2547 /* Callback for walk_stmt_load_store_ops.
2549 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2552 This routine only makes a superficial check for a dereference. Thus
2553 it must only be used if it is safe to return a false negative. */
2555 check_loadstore (gimple
, tree op
, tree
, void *data
)
2557 if ((TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
2558 && operand_equal_p (TREE_OPERAND (op
, 0), (tree
)data
, 0))
2563 /* If OP can be inferred to be non-NULL after STMT executes, return true.
2565 DEREFERENCE is TRUE if we can use a pointer dereference to infer a
2566 non-NULL range, FALSE otherwise.
2568 ATTRIBUTE is TRUE if we can use attributes to infer a non-NULL range
2569 for function arguments and return values. FALSE otherwise. */
2572 infer_nonnull_range (gimple stmt
, tree op
, bool dereference
, bool attribute
)
2574 /* We can only assume that a pointer dereference will yield
2575 non-NULL if -fdelete-null-pointer-checks is enabled. */
2576 if (!flag_delete_null_pointer_checks
2577 || !POINTER_TYPE_P (TREE_TYPE (op
))
2578 || gimple_code (stmt
) == GIMPLE_ASM
)
2582 && walk_stmt_load_store_ops (stmt
, (void *)op
,
2583 check_loadstore
, check_loadstore
))
2587 && is_gimple_call (stmt
) && !gimple_call_internal_p (stmt
))
2589 tree fntype
= gimple_call_fntype (stmt
);
2590 tree attrs
= TYPE_ATTRIBUTES (fntype
);
2591 for (; attrs
; attrs
= TREE_CHAIN (attrs
))
2593 attrs
= lookup_attribute ("nonnull", attrs
);
2595 /* If "nonnull" wasn't specified, we know nothing about
2597 if (attrs
== NULL_TREE
)
2600 /* If "nonnull" applies to all the arguments, then ARG
2601 is non-null if it's in the argument list. */
2602 if (TREE_VALUE (attrs
) == NULL_TREE
)
2604 for (unsigned int i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2606 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt
, i
)))
2607 && operand_equal_p (op
, gimple_call_arg (stmt
, i
), 0))
2613 /* Now see if op appears in the nonnull list. */
2614 for (tree t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
2616 int idx
= TREE_INT_CST_LOW (TREE_VALUE (t
)) - 1;
2617 tree arg
= gimple_call_arg (stmt
, idx
);
2618 if (operand_equal_p (op
, arg
, 0))
2624 /* If this function is marked as returning non-null, then we can
2625 infer OP is non-null if it is used in the return statement. */
2627 && gimple_code (stmt
) == GIMPLE_RETURN
2628 && gimple_return_retval (stmt
)
2629 && operand_equal_p (gimple_return_retval (stmt
), op
, 0)
2630 && lookup_attribute ("returns_nonnull",
2631 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
))))
2637 /* Compare two case labels. Because the front end should already have
2638 made sure that case ranges do not overlap, it is enough to only compare
2639 the CASE_LOW values of each case label. */
2642 compare_case_labels (const void *p1
, const void *p2
)
2644 const_tree
const case1
= *(const_tree
const*)p1
;
2645 const_tree
const case2
= *(const_tree
const*)p2
;
2647 /* The 'default' case label always goes first. */
2648 if (!CASE_LOW (case1
))
2650 else if (!CASE_LOW (case2
))
2653 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
2656 /* Sort the case labels in LABEL_VEC in place in ascending order. */
2659 sort_case_labels (vec
<tree
> label_vec
)
2661 label_vec
.qsort (compare_case_labels
);
2664 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2666 LABELS is a vector that contains all case labels to look at.
2668 INDEX_TYPE is the type of the switch index expression. Case labels
2669 in LABELS are discarded if their values are not in the value range
2670 covered by INDEX_TYPE. The remaining case label values are folded
2673 If a default case exists in LABELS, it is removed from LABELS and
2674 returned in DEFAULT_CASEP. If no default case exists, but the
2675 case labels already cover the whole range of INDEX_TYPE, a default
2676 case is returned pointing to one of the existing case labels.
2677 Otherwise DEFAULT_CASEP is set to NULL_TREE.
2679 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2680 apply and no action is taken regardless of whether a default case is
2684 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
2686 tree
*default_casep
)
2688 tree min_value
, max_value
;
2689 tree default_case
= NULL_TREE
;
2693 min_value
= TYPE_MIN_VALUE (index_type
);
2694 max_value
= TYPE_MAX_VALUE (index_type
);
2695 while (i
< labels
.length ())
2697 tree elt
= labels
[i
];
2698 tree low
= CASE_LOW (elt
);
2699 tree high
= CASE_HIGH (elt
);
2700 bool remove_element
= FALSE
;
2704 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
2705 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
2707 /* This is a non-default case label, i.e. it has a value.
2709 See if the case label is reachable within the range of
2710 the index type. Remove out-of-range case values. Turn
2711 case ranges into a canonical form (high > low strictly)
2712 and convert the case label values to the index type.
2714 NB: The type of gimple_switch_index() may be the promoted
2715 type, but the case labels retain the original type. */
2719 /* This is a case range. Discard empty ranges.
2720 If the bounds or the range are equal, turn this
2721 into a simple (one-value) case. */
2722 int cmp
= tree_int_cst_compare (high
, low
);
2724 remove_element
= TRUE
;
2731 /* If the simple case value is unreachable, ignore it. */
2732 if ((TREE_CODE (min_value
) == INTEGER_CST
2733 && tree_int_cst_compare (low
, min_value
) < 0)
2734 || (TREE_CODE (max_value
) == INTEGER_CST
2735 && tree_int_cst_compare (low
, max_value
) > 0))
2736 remove_element
= TRUE
;
2738 low
= fold_convert (index_type
, low
);
2742 /* If the entire case range is unreachable, ignore it. */
2743 if ((TREE_CODE (min_value
) == INTEGER_CST
2744 && tree_int_cst_compare (high
, min_value
) < 0)
2745 || (TREE_CODE (max_value
) == INTEGER_CST
2746 && tree_int_cst_compare (low
, max_value
) > 0))
2747 remove_element
= TRUE
;
2750 /* If the lower bound is less than the index type's
2751 minimum value, truncate the range bounds. */
2752 if (TREE_CODE (min_value
) == INTEGER_CST
2753 && tree_int_cst_compare (low
, min_value
) < 0)
2755 low
= fold_convert (index_type
, low
);
2757 /* If the upper bound is greater than the index type's
2758 maximum value, truncate the range bounds. */
2759 if (TREE_CODE (max_value
) == INTEGER_CST
2760 && tree_int_cst_compare (high
, max_value
) > 0)
2762 high
= fold_convert (index_type
, high
);
2764 /* We may have folded a case range to a one-value case. */
2765 if (tree_int_cst_equal (low
, high
))
2770 CASE_LOW (elt
) = low
;
2771 CASE_HIGH (elt
) = high
;
2775 gcc_assert (!default_case
);
2777 /* The default case must be passed separately to the
2778 gimple_build_switch routine. But if DEFAULT_CASEP
2779 is NULL, we do not remove the default case (it would
2780 be completely lost). */
2782 remove_element
= TRUE
;
2786 labels
.ordered_remove (i
);
2792 if (!labels
.is_empty ())
2793 sort_case_labels (labels
);
2795 if (default_casep
&& !default_case
)
2797 /* If the switch has no default label, add one, so that we jump
2798 around the switch body. If the labels already cover the whole
2799 range of the switch index_type, add the default label pointing
2800 to one of the existing labels. */
2802 && TYPE_MIN_VALUE (index_type
)
2803 && TYPE_MAX_VALUE (index_type
)
2804 && tree_int_cst_equal (CASE_LOW (labels
[0]),
2805 TYPE_MIN_VALUE (index_type
)))
2807 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
2809 high
= CASE_LOW (labels
[len
- 1]);
2810 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
2812 for (i
= 1; i
< len
; i
++)
2814 high
= CASE_LOW (labels
[i
]);
2815 low
= CASE_HIGH (labels
[i
- 1]);
2817 low
= CASE_LOW (labels
[i
- 1]);
2818 if (wi::add (low
, 1) != high
)
2823 tree label
= CASE_LABEL (labels
[0]);
2824 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
2832 *default_casep
= default_case
;
2835 /* Set the location of all statements in SEQ to LOC. */
2838 gimple_seq_set_location (gimple_seq seq
, location_t loc
)
2840 for (gimple_stmt_iterator i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
2841 gimple_set_location (gsi_stmt (i
), loc
);
2844 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
2847 gimple_seq_discard (gimple_seq seq
)
2849 gimple_stmt_iterator gsi
;
2851 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); )
2853 gimple stmt
= gsi_stmt (gsi
);
2854 gsi_remove (&gsi
, true);
2855 release_defs (stmt
);