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"
62 #include "lto-streamer.h"
66 /* All the tuples have their operand vector (if present) at the very bottom
67 of the structure. Therefore, the offset required to find the
68 operands vector the size of the structure minus the size of the 1
69 element tree array at the end (see gimple_ops). */
70 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
71 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
72 EXPORTED_CONST
size_t gimple_ops_offset_
[] = {
73 #include "gsstruct.def"
77 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
78 static const size_t gsstruct_code_size
[] = {
79 #include "gsstruct.def"
83 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
84 const char *const gimple_code_name
[] = {
89 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
90 EXPORTED_CONST
enum gimple_statement_structure_enum gss_for_code_
[] = {
97 int gimple_alloc_counts
[(int) gimple_alloc_kind_all
];
98 int gimple_alloc_sizes
[(int) gimple_alloc_kind_all
];
100 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
101 static const char * const gimple_alloc_kind_names
[] = {
108 /* Gimple tuple constructors.
109 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
110 be passed a NULL to start with an empty sequence. */
112 /* Set the code for statement G to CODE. */
115 gimple_set_code (gimple g
, enum gimple_code code
)
120 /* Return the number of bytes needed to hold a GIMPLE statement with
124 gimple_size (enum gimple_code code
)
126 return gsstruct_code_size
[gss_for_code (code
)];
129 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
133 gimple_alloc_stat (enum gimple_code code
, unsigned num_ops MEM_STAT_DECL
)
138 size
= gimple_size (code
);
140 size
+= sizeof (tree
) * (num_ops
- 1);
142 if (GATHER_STATISTICS
)
144 enum gimple_alloc_kind kind
= gimple_alloc_kind (code
);
145 gimple_alloc_counts
[(int) kind
]++;
146 gimple_alloc_sizes
[(int) kind
] += size
;
149 stmt
= ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT
);
150 gimple_set_code (stmt
, code
);
151 gimple_set_num_ops (stmt
, num_ops
);
153 /* Do not call gimple_set_modified here as it has other side
154 effects and this tuple is still not completely built. */
156 gimple_init_singleton (stmt
);
161 /* Set SUBCODE to be the code of the expression computed by statement G. */
164 gimple_set_subcode (gimple g
, unsigned subcode
)
166 /* We only have 16 bits for the RHS code. Assert that we are not
168 gcc_assert (subcode
< (1 << 16));
169 g
->subcode
= subcode
;
174 /* Build a tuple with operands. CODE is the statement to build (which
175 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
176 for the new tuple. NUM_OPS is the number of operands to allocate. */
178 #define gimple_build_with_ops(c, s, n) \
179 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
182 gimple_build_with_ops_stat (enum gimple_code code
, unsigned subcode
,
183 unsigned num_ops MEM_STAT_DECL
)
185 gimple s
= gimple_alloc_stat (code
, num_ops PASS_MEM_STAT
);
186 gimple_set_subcode (s
, subcode
);
192 /* Build a GIMPLE_RETURN statement returning RETVAL. */
195 gimple_build_return (tree retval
)
197 gimple s
= gimple_build_with_ops (GIMPLE_RETURN
, ERROR_MARK
, 2);
199 gimple_return_set_retval (s
, retval
);
203 /* Reset alias information on call S. */
206 gimple_call_reset_alias_info (gimple s
)
208 if (gimple_call_flags (s
) & ECF_CONST
)
209 memset (gimple_call_use_set (s
), 0, sizeof (struct pt_solution
));
211 pt_solution_reset (gimple_call_use_set (s
));
212 if (gimple_call_flags (s
) & (ECF_CONST
|ECF_PURE
|ECF_NOVOPS
))
213 memset (gimple_call_clobber_set (s
), 0, sizeof (struct pt_solution
));
215 pt_solution_reset (gimple_call_clobber_set (s
));
218 /* Helper for gimple_build_call, gimple_build_call_valist,
219 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
220 components of a GIMPLE_CALL statement to function FN with NARGS
224 gimple_build_call_1 (tree fn
, unsigned nargs
)
226 gimple s
= gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
, nargs
+ 3);
227 if (TREE_CODE (fn
) == FUNCTION_DECL
)
228 fn
= build_fold_addr_expr (fn
);
229 gimple_set_op (s
, 1, fn
);
230 gimple_call_set_fntype (s
, TREE_TYPE (TREE_TYPE (fn
)));
231 gimple_call_reset_alias_info (s
);
236 /* Build a GIMPLE_CALL statement to function FN with the arguments
237 specified in vector ARGS. */
240 gimple_build_call_vec (tree fn
, vec
<tree
> args
)
243 unsigned nargs
= args
.length ();
244 gimple call
= gimple_build_call_1 (fn
, nargs
);
246 for (i
= 0; i
< nargs
; i
++)
247 gimple_call_set_arg (call
, i
, args
[i
]);
253 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
254 arguments. The ... are the arguments. */
257 gimple_build_call (tree fn
, unsigned nargs
, ...)
263 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
265 call
= gimple_build_call_1 (fn
, nargs
);
267 va_start (ap
, nargs
);
268 for (i
= 0; i
< nargs
; i
++)
269 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
276 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
277 arguments. AP contains the arguments. */
280 gimple_build_call_valist (tree fn
, unsigned nargs
, va_list ap
)
285 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
287 call
= gimple_build_call_1 (fn
, nargs
);
289 for (i
= 0; i
< nargs
; i
++)
290 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
296 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
297 Build the basic components of a GIMPLE_CALL statement to internal
298 function FN with NARGS arguments. */
301 gimple_build_call_internal_1 (enum internal_fn fn
, unsigned nargs
)
303 gimple s
= gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
, nargs
+ 3);
304 s
->subcode
|= GF_CALL_INTERNAL
;
305 gimple_call_set_internal_fn (s
, fn
);
306 gimple_call_reset_alias_info (s
);
311 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
312 the number of arguments. The ... are the arguments. */
315 gimple_build_call_internal (enum internal_fn fn
, unsigned nargs
, ...)
321 call
= gimple_build_call_internal_1 (fn
, nargs
);
322 va_start (ap
, nargs
);
323 for (i
= 0; i
< nargs
; i
++)
324 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
331 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
332 specified in vector ARGS. */
335 gimple_build_call_internal_vec (enum internal_fn fn
, vec
<tree
> args
)
340 nargs
= args
.length ();
341 call
= gimple_build_call_internal_1 (fn
, nargs
);
342 for (i
= 0; i
< nargs
; i
++)
343 gimple_call_set_arg (call
, i
, args
[i
]);
349 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
350 assumed to be in GIMPLE form already. Minimal checking is done of
354 gimple_build_call_from_tree (tree t
)
358 tree fndecl
= get_callee_fndecl (t
);
360 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
362 nargs
= call_expr_nargs (t
);
363 call
= gimple_build_call_1 (fndecl
? fndecl
: CALL_EXPR_FN (t
), nargs
);
365 for (i
= 0; i
< nargs
; i
++)
366 gimple_call_set_arg (call
, i
, CALL_EXPR_ARG (t
, i
));
368 gimple_set_block (call
, TREE_BLOCK (t
));
370 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
371 gimple_call_set_chain (call
, CALL_EXPR_STATIC_CHAIN (t
));
372 gimple_call_set_tail (call
, CALL_EXPR_TAILCALL (t
));
373 gimple_call_set_return_slot_opt (call
, CALL_EXPR_RETURN_SLOT_OPT (t
));
375 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
376 && (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA
377 || DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
378 gimple_call_set_alloca_for_var (call
, CALL_ALLOCA_FOR_VAR_P (t
));
380 gimple_call_set_from_thunk (call
, CALL_FROM_THUNK_P (t
));
381 gimple_call_set_va_arg_pack (call
, CALL_EXPR_VA_ARG_PACK (t
));
382 gimple_call_set_nothrow (call
, TREE_NOTHROW (t
));
383 gimple_set_no_warning (call
, TREE_NO_WARNING (t
));
384 gimple_call_set_with_bounds (call
, CALL_WITH_BOUNDS_P (t
));
390 /* Build a GIMPLE_ASSIGN statement.
392 LHS of the assignment.
393 RHS of the assignment which can be unary or binary. */
396 gimple_build_assign_stat (tree lhs
, tree rhs MEM_STAT_DECL
)
398 enum tree_code subcode
;
401 extract_ops_from_tree_1 (rhs
, &subcode
, &op1
, &op2
, &op3
);
402 return gimple_build_assign_with_ops (subcode
, lhs
, op1
, op2
, op3
407 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
408 OP1 and OP2. If OP2 is NULL then SUBCODE must be of class
409 GIMPLE_UNARY_RHS or GIMPLE_SINGLE_RHS. */
412 gimple_build_assign_with_ops (enum tree_code subcode
, tree lhs
, tree op1
,
413 tree op2
, tree op3 MEM_STAT_DECL
)
418 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
420 num_ops
= get_gimple_rhs_num_ops (subcode
) + 1;
422 p
= gimple_build_with_ops_stat (GIMPLE_ASSIGN
, (unsigned)subcode
, num_ops
424 gimple_assign_set_lhs (p
, lhs
);
425 gimple_assign_set_rhs1 (p
, op1
);
428 gcc_assert (num_ops
> 2);
429 gimple_assign_set_rhs2 (p
, op2
);
434 gcc_assert (num_ops
> 3);
435 gimple_assign_set_rhs3 (p
, op3
);
442 gimple_build_assign_with_ops (enum tree_code subcode
, tree lhs
, tree op1
,
443 tree op2 MEM_STAT_DECL
)
445 return gimple_build_assign_with_ops (subcode
, lhs
, op1
, op2
, NULL_TREE
450 gimple_build_assign_with_ops (enum tree_code subcode
, tree lhs
, tree op1
453 return gimple_build_assign_with_ops (subcode
, lhs
, op1
, NULL_TREE
, NULL_TREE
458 /* Build a GIMPLE_COND statement.
460 PRED is the condition used to compare LHS and the RHS.
461 T_LABEL is the label to jump to if the condition is true.
462 F_LABEL is the label to jump to otherwise. */
465 gimple_build_cond (enum tree_code pred_code
, tree lhs
, tree rhs
,
466 tree t_label
, tree f_label
)
470 gcc_assert (TREE_CODE_CLASS (pred_code
) == tcc_comparison
);
471 p
= gimple_build_with_ops (GIMPLE_COND
, pred_code
, 4);
472 gimple_cond_set_lhs (p
, lhs
);
473 gimple_cond_set_rhs (p
, rhs
);
474 gimple_cond_set_true_label (p
, t_label
);
475 gimple_cond_set_false_label (p
, f_label
);
479 /* Build a GIMPLE_COND statement from the conditional expression tree
480 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
483 gimple_build_cond_from_tree (tree cond
, tree t_label
, tree f_label
)
488 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
489 return gimple_build_cond (code
, lhs
, rhs
, t_label
, f_label
);
492 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
493 boolean expression tree COND. */
496 gimple_cond_set_condition_from_tree (gimple stmt
, tree cond
)
501 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
502 gimple_cond_set_condition (stmt
, code
, lhs
, rhs
);
505 /* Build a GIMPLE_LABEL statement for LABEL. */
508 gimple_build_label (tree label
)
510 gimple p
= gimple_build_with_ops (GIMPLE_LABEL
, ERROR_MARK
, 1);
511 gimple_label_set_label (p
, label
);
515 /* Build a GIMPLE_GOTO statement to label DEST. */
518 gimple_build_goto (tree dest
)
520 gimple p
= gimple_build_with_ops (GIMPLE_GOTO
, ERROR_MARK
, 1);
521 gimple_goto_set_dest (p
, dest
);
526 /* Build a GIMPLE_NOP statement. */
529 gimple_build_nop (void)
531 return gimple_alloc (GIMPLE_NOP
, 0);
535 /* Build a GIMPLE_BIND statement.
536 VARS are the variables in BODY.
537 BLOCK is the containing block. */
540 gimple_build_bind (tree vars
, gimple_seq body
, tree block
)
542 gimple p
= gimple_alloc (GIMPLE_BIND
, 0);
543 gimple_bind_set_vars (p
, vars
);
545 gimple_bind_set_body (p
, body
);
547 gimple_bind_set_block (p
, block
);
551 /* Helper function to set the simple fields of a asm stmt.
553 STRING is a pointer to a string that is the asm blocks assembly code.
554 NINPUT is the number of register inputs.
555 NOUTPUT is the number of register outputs.
556 NCLOBBERS is the number of clobbered registers.
560 gimple_build_asm_1 (const char *string
, unsigned ninputs
, unsigned noutputs
,
561 unsigned nclobbers
, unsigned nlabels
)
563 gimple_statement_asm
*p
;
564 int size
= strlen (string
);
566 /* ASMs with labels cannot have outputs. This should have been
567 enforced by the front end. */
568 gcc_assert (nlabels
== 0 || noutputs
== 0);
570 p
= as_a
<gimple_statement_asm
*> (
571 gimple_build_with_ops (GIMPLE_ASM
, ERROR_MARK
,
572 ninputs
+ noutputs
+ nclobbers
+ nlabels
));
578 p
->string
= ggc_alloc_string (string
, size
);
580 if (GATHER_STATISTICS
)
581 gimple_alloc_sizes
[(int) gimple_alloc_kind (GIMPLE_ASM
)] += size
;
586 /* Build a GIMPLE_ASM statement.
588 STRING is the assembly code.
589 NINPUT is the number of register inputs.
590 NOUTPUT is the number of register outputs.
591 NCLOBBERS is the number of clobbered registers.
592 INPUTS is a vector of the input register parameters.
593 OUTPUTS is a vector of the output register parameters.
594 CLOBBERS is a vector of the clobbered register parameters.
595 LABELS is a vector of destination labels. */
598 gimple_build_asm_vec (const char *string
, vec
<tree
, va_gc
> *inputs
,
599 vec
<tree
, va_gc
> *outputs
, vec
<tree
, va_gc
> *clobbers
,
600 vec
<tree
, va_gc
> *labels
)
605 p
= gimple_build_asm_1 (string
,
606 vec_safe_length (inputs
),
607 vec_safe_length (outputs
),
608 vec_safe_length (clobbers
),
609 vec_safe_length (labels
));
611 for (i
= 0; i
< vec_safe_length (inputs
); i
++)
612 gimple_asm_set_input_op (p
, i
, (*inputs
)[i
]);
614 for (i
= 0; i
< vec_safe_length (outputs
); i
++)
615 gimple_asm_set_output_op (p
, i
, (*outputs
)[i
]);
617 for (i
= 0; i
< vec_safe_length (clobbers
); i
++)
618 gimple_asm_set_clobber_op (p
, i
, (*clobbers
)[i
]);
620 for (i
= 0; i
< vec_safe_length (labels
); i
++)
621 gimple_asm_set_label_op (p
, i
, (*labels
)[i
]);
626 /* Build a GIMPLE_CATCH statement.
628 TYPES are the catch types.
629 HANDLER is the exception handler. */
632 gimple_build_catch (tree types
, gimple_seq handler
)
634 gimple p
= gimple_alloc (GIMPLE_CATCH
, 0);
635 gimple_catch_set_types (p
, types
);
637 gimple_catch_set_handler (p
, handler
);
642 /* Build a GIMPLE_EH_FILTER statement.
644 TYPES are the filter's types.
645 FAILURE is the filter's failure action. */
648 gimple_build_eh_filter (tree types
, gimple_seq failure
)
650 gimple p
= gimple_alloc (GIMPLE_EH_FILTER
, 0);
651 gimple_eh_filter_set_types (p
, types
);
653 gimple_eh_filter_set_failure (p
, failure
);
658 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
661 gimple_build_eh_must_not_throw (tree decl
)
663 gimple p
= gimple_alloc (GIMPLE_EH_MUST_NOT_THROW
, 0);
665 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
666 gcc_assert (flags_from_decl_or_type (decl
) & ECF_NORETURN
);
667 gimple_eh_must_not_throw_set_fndecl (p
, decl
);
672 /* Build a GIMPLE_EH_ELSE statement. */
675 gimple_build_eh_else (gimple_seq n_body
, gimple_seq e_body
)
677 gimple p
= gimple_alloc (GIMPLE_EH_ELSE
, 0);
678 gimple_eh_else_set_n_body (p
, n_body
);
679 gimple_eh_else_set_e_body (p
, e_body
);
683 /* Build a GIMPLE_TRY statement.
685 EVAL is the expression to evaluate.
686 CLEANUP is the cleanup expression.
687 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
688 whether this is a try/catch or a try/finally respectively. */
690 gimple_statement_try
*
691 gimple_build_try (gimple_seq eval
, gimple_seq cleanup
,
692 enum gimple_try_flags kind
)
694 gimple_statement_try
*p
;
696 gcc_assert (kind
== GIMPLE_TRY_CATCH
|| kind
== GIMPLE_TRY_FINALLY
);
697 p
= as_a
<gimple_statement_try
*> (gimple_alloc (GIMPLE_TRY
, 0));
698 gimple_set_subcode (p
, kind
);
700 gimple_try_set_eval (p
, eval
);
702 gimple_try_set_cleanup (p
, cleanup
);
707 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
709 CLEANUP is the cleanup expression. */
712 gimple_build_wce (gimple_seq cleanup
)
714 gimple p
= gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR
, 0);
716 gimple_wce_set_cleanup (p
, cleanup
);
722 /* Build a GIMPLE_RESX statement. */
725 gimple_build_resx (int region
)
727 gimple_statement_resx
*p
=
728 as_a
<gimple_statement_resx
*> (
729 gimple_build_with_ops (GIMPLE_RESX
, ERROR_MARK
, 0));
735 /* The helper for constructing a gimple switch statement.
736 INDEX is the switch's index.
737 NLABELS is the number of labels in the switch excluding the default.
738 DEFAULT_LABEL is the default label for the switch statement. */
741 gimple_build_switch_nlabels (unsigned nlabels
, tree index
, tree default_label
)
743 /* nlabels + 1 default label + 1 index. */
744 gcc_checking_assert (default_label
);
745 gimple p
= gimple_build_with_ops (GIMPLE_SWITCH
, ERROR_MARK
,
747 gimple_switch_set_index (p
, index
);
748 gimple_switch_set_default_label (p
, default_label
);
752 /* Build a GIMPLE_SWITCH statement.
754 INDEX is the switch's index.
755 DEFAULT_LABEL is the default label
756 ARGS is a vector of labels excluding the default. */
759 gimple_build_switch (tree index
, tree default_label
, vec
<tree
> args
)
761 unsigned i
, nlabels
= args
.length ();
763 gimple p
= gimple_build_switch_nlabels (nlabels
, index
, default_label
);
765 /* Copy the labels from the vector to the switch statement. */
766 for (i
= 0; i
< nlabels
; i
++)
767 gimple_switch_set_label (p
, i
+ 1, args
[i
]);
772 /* Build a GIMPLE_EH_DISPATCH statement. */
775 gimple_build_eh_dispatch (int region
)
777 gimple_statement_eh_dispatch
*p
=
778 as_a
<gimple_statement_eh_dispatch
*> (
779 gimple_build_with_ops (GIMPLE_EH_DISPATCH
, ERROR_MARK
, 0));
784 /* Build a new GIMPLE_DEBUG_BIND statement.
786 VAR is bound to VALUE; block and location are taken from STMT. */
789 gimple_build_debug_bind_stat (tree var
, tree value
, gimple stmt MEM_STAT_DECL
)
791 gimple p
= gimple_build_with_ops_stat (GIMPLE_DEBUG
,
792 (unsigned)GIMPLE_DEBUG_BIND
, 2
795 gimple_debug_bind_set_var (p
, var
);
796 gimple_debug_bind_set_value (p
, value
);
798 gimple_set_location (p
, gimple_location (stmt
));
804 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
806 VAR is bound to VALUE; block and location are taken from STMT. */
809 gimple_build_debug_source_bind_stat (tree var
, tree value
,
810 gimple stmt MEM_STAT_DECL
)
812 gimple p
= gimple_build_with_ops_stat (GIMPLE_DEBUG
,
813 (unsigned)GIMPLE_DEBUG_SOURCE_BIND
, 2
816 gimple_debug_source_bind_set_var (p
, var
);
817 gimple_debug_source_bind_set_value (p
, value
);
819 gimple_set_location (p
, gimple_location (stmt
));
825 /* Build a GIMPLE_OMP_CRITICAL statement.
827 BODY is the sequence of statements for which only one thread can execute.
828 NAME is optional identifier for this critical block. */
831 gimple_build_omp_critical (gimple_seq body
, tree name
)
833 gimple p
= gimple_alloc (GIMPLE_OMP_CRITICAL
, 0);
834 gimple_omp_critical_set_name (p
, name
);
836 gimple_omp_set_body (p
, body
);
841 /* Build a GIMPLE_OMP_FOR statement.
843 BODY is sequence of statements inside the for loop.
844 KIND is the `for' variant.
845 CLAUSES, are any of the OMP loop construct's clauses: private, firstprivate,
846 lastprivate, reductions, ordered, schedule, and nowait.
847 COLLAPSE is the collapse count.
848 PRE_BODY is the sequence of statements that are loop invariant. */
851 gimple_build_omp_for (gimple_seq body
, int kind
, tree clauses
, size_t collapse
,
854 gimple_statement_omp_for
*p
=
855 as_a
<gimple_statement_omp_for
*> (gimple_alloc (GIMPLE_OMP_FOR
, 0));
857 gimple_omp_set_body (p
, body
);
858 gimple_omp_for_set_clauses (p
, clauses
);
859 gimple_omp_for_set_kind (p
, kind
);
860 p
->collapse
= collapse
;
861 p
->iter
= ggc_cleared_vec_alloc
<gimple_omp_for_iter
> (collapse
);
864 gimple_omp_for_set_pre_body (p
, pre_body
);
870 /* Build a GIMPLE_OMP_PARALLEL statement.
872 BODY is sequence of statements which are executed in parallel.
873 CLAUSES, are the OMP parallel construct's clauses.
874 CHILD_FN is the function created for the parallel threads to execute.
875 DATA_ARG are the shared data argument(s). */
878 gimple_build_omp_parallel (gimple_seq body
, tree clauses
, tree child_fn
,
881 gimple p
= gimple_alloc (GIMPLE_OMP_PARALLEL
, 0);
883 gimple_omp_set_body (p
, body
);
884 gimple_omp_parallel_set_clauses (p
, clauses
);
885 gimple_omp_parallel_set_child_fn (p
, child_fn
);
886 gimple_omp_parallel_set_data_arg (p
, data_arg
);
892 /* Build a GIMPLE_OMP_TASK statement.
894 BODY is sequence of statements which are executed by the explicit task.
895 CLAUSES, are the OMP parallel construct's clauses.
896 CHILD_FN is the function created for the parallel threads to execute.
897 DATA_ARG are the shared data argument(s).
898 COPY_FN is the optional function for firstprivate initialization.
899 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
902 gimple_build_omp_task (gimple_seq body
, tree clauses
, tree child_fn
,
903 tree data_arg
, tree copy_fn
, tree arg_size
,
906 gimple p
= gimple_alloc (GIMPLE_OMP_TASK
, 0);
908 gimple_omp_set_body (p
, body
);
909 gimple_omp_task_set_clauses (p
, clauses
);
910 gimple_omp_task_set_child_fn (p
, child_fn
);
911 gimple_omp_task_set_data_arg (p
, data_arg
);
912 gimple_omp_task_set_copy_fn (p
, copy_fn
);
913 gimple_omp_task_set_arg_size (p
, arg_size
);
914 gimple_omp_task_set_arg_align (p
, arg_align
);
920 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
922 BODY is the sequence of statements in the section. */
925 gimple_build_omp_section (gimple_seq body
)
927 gimple p
= gimple_alloc (GIMPLE_OMP_SECTION
, 0);
929 gimple_omp_set_body (p
, body
);
935 /* Build a GIMPLE_OMP_MASTER statement.
937 BODY is the sequence of statements to be executed by just the master. */
940 gimple_build_omp_master (gimple_seq body
)
942 gimple p
= gimple_alloc (GIMPLE_OMP_MASTER
, 0);
944 gimple_omp_set_body (p
, body
);
950 /* Build a GIMPLE_OMP_TASKGROUP statement.
952 BODY is the sequence of statements to be executed by the taskgroup
956 gimple_build_omp_taskgroup (gimple_seq body
)
958 gimple p
= gimple_alloc (GIMPLE_OMP_TASKGROUP
, 0);
960 gimple_omp_set_body (p
, body
);
966 /* Build a GIMPLE_OMP_CONTINUE statement.
968 CONTROL_DEF is the definition of the control variable.
969 CONTROL_USE is the use of the control variable. */
972 gimple_build_omp_continue (tree control_def
, tree control_use
)
974 gimple p
= gimple_alloc (GIMPLE_OMP_CONTINUE
, 0);
975 gimple_omp_continue_set_control_def (p
, control_def
);
976 gimple_omp_continue_set_control_use (p
, control_use
);
980 /* Build a GIMPLE_OMP_ORDERED statement.
982 BODY is the sequence of statements inside a loop that will executed in
986 gimple_build_omp_ordered (gimple_seq body
)
988 gimple p
= gimple_alloc (GIMPLE_OMP_ORDERED
, 0);
990 gimple_omp_set_body (p
, body
);
996 /* Build a GIMPLE_OMP_RETURN statement.
997 WAIT_P is true if this is a non-waiting return. */
1000 gimple_build_omp_return (bool wait_p
)
1002 gimple p
= gimple_alloc (GIMPLE_OMP_RETURN
, 0);
1004 gimple_omp_return_set_nowait (p
);
1010 /* Build a GIMPLE_OMP_SECTIONS statement.
1012 BODY is a sequence of section statements.
1013 CLAUSES are any of the OMP sections contsruct's clauses: private,
1014 firstprivate, lastprivate, reduction, and nowait. */
1017 gimple_build_omp_sections (gimple_seq body
, tree clauses
)
1019 gimple p
= gimple_alloc (GIMPLE_OMP_SECTIONS
, 0);
1021 gimple_omp_set_body (p
, body
);
1022 gimple_omp_sections_set_clauses (p
, clauses
);
1028 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1031 gimple_build_omp_sections_switch (void)
1033 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH
, 0);
1037 /* Build a GIMPLE_OMP_SINGLE statement.
1039 BODY is the sequence of statements that will be executed once.
1040 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1041 copyprivate, nowait. */
1044 gimple_build_omp_single (gimple_seq body
, tree clauses
)
1046 gimple p
= gimple_alloc (GIMPLE_OMP_SINGLE
, 0);
1048 gimple_omp_set_body (p
, body
);
1049 gimple_omp_single_set_clauses (p
, clauses
);
1055 /* Build a GIMPLE_OMP_TARGET statement.
1057 BODY is the sequence of statements that will be executed.
1058 CLAUSES are any of the OMP target construct's clauses. */
1061 gimple_build_omp_target (gimple_seq body
, int kind
, tree clauses
)
1063 gimple p
= gimple_alloc (GIMPLE_OMP_TARGET
, 0);
1065 gimple_omp_set_body (p
, body
);
1066 gimple_omp_target_set_clauses (p
, clauses
);
1067 gimple_omp_target_set_kind (p
, kind
);
1073 /* Build a GIMPLE_OMP_TEAMS statement.
1075 BODY is the sequence of statements that will be executed.
1076 CLAUSES are any of the OMP teams construct's clauses. */
1079 gimple_build_omp_teams (gimple_seq body
, tree clauses
)
1081 gimple p
= gimple_alloc (GIMPLE_OMP_TEAMS
, 0);
1083 gimple_omp_set_body (p
, body
);
1084 gimple_omp_teams_set_clauses (p
, clauses
);
1090 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1093 gimple_build_omp_atomic_load (tree lhs
, tree rhs
)
1095 gimple p
= gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD
, 0);
1096 gimple_omp_atomic_load_set_lhs (p
, lhs
);
1097 gimple_omp_atomic_load_set_rhs (p
, rhs
);
1101 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1103 VAL is the value we are storing. */
1106 gimple_build_omp_atomic_store (tree val
)
1108 gimple p
= gimple_alloc (GIMPLE_OMP_ATOMIC_STORE
, 0);
1109 gimple_omp_atomic_store_set_val (p
, val
);
1113 /* Build a GIMPLE_TRANSACTION statement. */
1116 gimple_build_transaction (gimple_seq body
, tree label
)
1118 gimple p
= gimple_alloc (GIMPLE_TRANSACTION
, 0);
1119 gimple_transaction_set_body (p
, body
);
1120 gimple_transaction_set_label (p
, label
);
1124 /* Build a GIMPLE_PREDICT statement. PREDICT is one of the predictors from
1125 predict.def, OUTCOME is NOT_TAKEN or TAKEN. */
1128 gimple_build_predict (enum br_predictor predictor
, enum prediction outcome
)
1130 gimple p
= gimple_alloc (GIMPLE_PREDICT
, 0);
1131 /* Ensure all the predictors fit into the lower bits of the subcode. */
1132 gcc_assert ((int) END_PREDICTORS
<= GF_PREDICT_TAKEN
);
1133 gimple_predict_set_predictor (p
, predictor
);
1134 gimple_predict_set_outcome (p
, outcome
);
1138 #if defined ENABLE_GIMPLE_CHECKING
1139 /* Complain of a gimple type mismatch and die. */
1142 gimple_check_failed (const_gimple gs
, const char *file
, int line
,
1143 const char *function
, enum gimple_code code
,
1144 enum tree_code subcode
)
1146 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1147 gimple_code_name
[code
],
1148 get_tree_code_name (subcode
),
1149 gimple_code_name
[gimple_code (gs
)],
1151 ? get_tree_code_name ((enum tree_code
) gs
->subcode
)
1153 function
, trim_filename (file
), line
);
1155 #endif /* ENABLE_GIMPLE_CHECKING */
1158 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1159 *SEQ_P is NULL, a new sequence is allocated. */
1162 gimple_seq_add_stmt (gimple_seq
*seq_p
, gimple gs
)
1164 gimple_stmt_iterator si
;
1168 si
= gsi_last (*seq_p
);
1169 gsi_insert_after (&si
, gs
, GSI_NEW_STMT
);
1172 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1173 *SEQ_P is NULL, a new sequence is allocated. This function is
1174 similar to gimple_seq_add_stmt, but does not scan the operands.
1175 During gimplification, we need to manipulate statement sequences
1176 before the def/use vectors have been constructed. */
1179 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple gs
)
1181 gimple_stmt_iterator si
;
1186 si
= gsi_last (*seq_p
);
1187 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
1190 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1191 NULL, a new sequence is allocated. */
1194 gimple_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
1196 gimple_stmt_iterator si
;
1200 si
= gsi_last (*dst_p
);
1201 gsi_insert_seq_after (&si
, src
, GSI_NEW_STMT
);
1204 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1205 NULL, a new sequence is allocated. This function is
1206 similar to gimple_seq_add_seq, but does not scan the operands. */
1209 gimple_seq_add_seq_without_update (gimple_seq
*dst_p
, gimple_seq src
)
1211 gimple_stmt_iterator si
;
1215 si
= gsi_last (*dst_p
);
1216 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
1219 /* Determine whether to assign a location to the statement GS. */
1222 should_carry_location_p (gimple gs
)
1224 /* Don't emit a line note for a label. We particularly don't want to
1225 emit one for the break label, since it doesn't actually correspond
1226 to the beginning of the loop/switch. */
1227 if (gimple_code (gs
) == GIMPLE_LABEL
)
1233 /* Set the location for gimple statement GS to LOCATION. */
1236 annotate_one_with_location (gimple gs
, location_t location
)
1238 if (!gimple_has_location (gs
)
1239 && !gimple_do_not_emit_location_p (gs
)
1240 && should_carry_location_p (gs
))
1241 gimple_set_location (gs
, location
);
1244 /* Set LOCATION for all the statements after iterator GSI in sequence
1245 SEQ. If GSI is pointing to the end of the sequence, start with the
1246 first statement in SEQ. */
1249 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
1250 location_t location
)
1252 if (gsi_end_p (gsi
))
1253 gsi
= gsi_start (seq
);
1257 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
1258 annotate_one_with_location (gsi_stmt (gsi
), location
);
1261 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1264 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
1266 gimple_stmt_iterator i
;
1268 if (gimple_seq_empty_p (stmt_p
))
1271 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
1273 gimple gs
= gsi_stmt (i
);
1274 annotate_one_with_location (gs
, location
);
1278 /* Helper function of empty_body_p. Return true if STMT is an empty
1282 empty_stmt_p (gimple stmt
)
1284 if (gimple_code (stmt
) == GIMPLE_NOP
)
1286 if (gimple_code (stmt
) == GIMPLE_BIND
)
1287 return empty_body_p (gimple_bind_body (stmt
));
1292 /* Return true if BODY contains nothing but empty statements. */
1295 empty_body_p (gimple_seq body
)
1297 gimple_stmt_iterator i
;
1299 if (gimple_seq_empty_p (body
))
1301 for (i
= gsi_start (body
); !gsi_end_p (i
); gsi_next (&i
))
1302 if (!empty_stmt_p (gsi_stmt (i
))
1303 && !is_gimple_debug (gsi_stmt (i
)))
1310 /* Perform a deep copy of sequence SRC and return the result. */
1313 gimple_seq_copy (gimple_seq src
)
1315 gimple_stmt_iterator gsi
;
1316 gimple_seq new_seq
= NULL
;
1319 for (gsi
= gsi_start (src
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1321 stmt
= gimple_copy (gsi_stmt (gsi
));
1322 gimple_seq_add_stmt (&new_seq
, stmt
);
1330 /* Return true if calls C1 and C2 are known to go to the same function. */
1333 gimple_call_same_target_p (const_gimple c1
, const_gimple c2
)
1335 if (gimple_call_internal_p (c1
))
1336 return (gimple_call_internal_p (c2
)
1337 && gimple_call_internal_fn (c1
) == gimple_call_internal_fn (c2
));
1339 return (gimple_call_fn (c1
) == gimple_call_fn (c2
)
1340 || (gimple_call_fndecl (c1
)
1341 && gimple_call_fndecl (c1
) == gimple_call_fndecl (c2
)));
1344 /* Detect flags from a GIMPLE_CALL. This is just like
1345 call_expr_flags, but for gimple tuples. */
1348 gimple_call_flags (const_gimple stmt
)
1351 tree decl
= gimple_call_fndecl (stmt
);
1354 flags
= flags_from_decl_or_type (decl
);
1355 else if (gimple_call_internal_p (stmt
))
1356 flags
= internal_fn_flags (gimple_call_internal_fn (stmt
));
1358 flags
= flags_from_decl_or_type (gimple_call_fntype (stmt
));
1360 if (stmt
->subcode
& GF_CALL_NOTHROW
)
1361 flags
|= ECF_NOTHROW
;
1366 /* Return the "fn spec" string for call STMT. */
1369 gimple_call_fnspec (const_gimple stmt
)
1373 if (gimple_call_internal_p (stmt
))
1374 return internal_fn_fnspec (gimple_call_internal_fn (stmt
));
1376 type
= gimple_call_fntype (stmt
);
1380 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
1384 return TREE_VALUE (TREE_VALUE (attr
));
1387 /* Detects argument flags for argument number ARG on call STMT. */
1390 gimple_call_arg_flags (const_gimple stmt
, unsigned arg
)
1392 const_tree attr
= gimple_call_fnspec (stmt
);
1394 if (!attr
|| 1 + arg
>= (unsigned) TREE_STRING_LENGTH (attr
))
1397 switch (TREE_STRING_POINTER (attr
)[1 + arg
])
1404 return EAF_DIRECT
| EAF_NOCLOBBER
| EAF_NOESCAPE
;
1407 return EAF_NOCLOBBER
| EAF_NOESCAPE
;
1410 return EAF_DIRECT
| EAF_NOESCAPE
;
1413 return EAF_NOESCAPE
;
1421 /* Detects return flags for the call STMT. */
1424 gimple_call_return_flags (const_gimple stmt
)
1428 if (gimple_call_flags (stmt
) & ECF_MALLOC
)
1431 attr
= gimple_call_fnspec (stmt
);
1432 if (!attr
|| TREE_STRING_LENGTH (attr
) < 1)
1435 switch (TREE_STRING_POINTER (attr
)[0])
1441 return ERF_RETURNS_ARG
| (TREE_STRING_POINTER (attr
)[0] - '1');
1453 /* Return true if GS is a copy assignment. */
1456 gimple_assign_copy_p (gimple gs
)
1458 return (gimple_assign_single_p (gs
)
1459 && is_gimple_val (gimple_op (gs
, 1)));
1463 /* Return true if GS is a SSA_NAME copy assignment. */
1466 gimple_assign_ssa_name_copy_p (gimple gs
)
1468 return (gimple_assign_single_p (gs
)
1469 && TREE_CODE (gimple_assign_lhs (gs
)) == SSA_NAME
1470 && TREE_CODE (gimple_assign_rhs1 (gs
)) == SSA_NAME
);
1474 /* Return true if GS is an assignment with a unary RHS, but the
1475 operator has no effect on the assigned value. The logic is adapted
1476 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1477 instances in which STRIP_NOPS was previously applied to the RHS of
1480 NOTE: In the use cases that led to the creation of this function
1481 and of gimple_assign_single_p, it is typical to test for either
1482 condition and to proceed in the same manner. In each case, the
1483 assigned value is represented by the single RHS operand of the
1484 assignment. I suspect there may be cases where gimple_assign_copy_p,
1485 gimple_assign_single_p, or equivalent logic is used where a similar
1486 treatment of unary NOPs is appropriate. */
1489 gimple_assign_unary_nop_p (gimple gs
)
1491 return (is_gimple_assign (gs
)
1492 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs
))
1493 || gimple_assign_rhs_code (gs
) == NON_LVALUE_EXPR
)
1494 && gimple_assign_rhs1 (gs
) != error_mark_node
1495 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs
)))
1496 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs
)))));
1499 /* Set BB to be the basic block holding G. */
1502 gimple_set_bb (gimple stmt
, basic_block bb
)
1506 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1509 /* If the statement is a label, add the label to block-to-labels map
1510 so that we can speed up edge creation for GIMPLE_GOTOs. */
1516 t
= gimple_label_label (stmt
);
1517 uid
= LABEL_DECL_UID (t
);
1521 vec_safe_length (label_to_block_map_for_fn (cfun
));
1522 LABEL_DECL_UID (t
) = uid
= cfun
->cfg
->last_label_uid
++;
1523 if (old_len
<= (unsigned) uid
)
1525 unsigned new_len
= 3 * uid
/ 2 + 1;
1527 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun
),
1532 (*label_to_block_map_for_fn (cfun
))[uid
] = bb
;
1537 /* Modify the RHS of the assignment pointed-to by GSI using the
1538 operands in the expression tree EXPR.
1540 NOTE: The statement pointed-to by GSI may be reallocated if it
1541 did not have enough operand slots.
1543 This function is useful to convert an existing tree expression into
1544 the flat representation used for the RHS of a GIMPLE assignment.
1545 It will reallocate memory as needed to expand or shrink the number
1546 of operand slots needed to represent EXPR.
1548 NOTE: If you find yourself building a tree and then calling this
1549 function, you are most certainly doing it the slow way. It is much
1550 better to build a new assignment or to use the function
1551 gimple_assign_set_rhs_with_ops, which does not require an
1552 expression tree to be built. */
1555 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*gsi
, tree expr
)
1557 enum tree_code subcode
;
1560 extract_ops_from_tree_1 (expr
, &subcode
, &op1
, &op2
, &op3
);
1561 gimple_assign_set_rhs_with_ops (gsi
, subcode
, op1
, op2
, op3
);
1565 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1566 operands OP1, OP2 and OP3.
1568 NOTE: The statement pointed-to by GSI may be reallocated if it
1569 did not have enough operand slots. */
1572 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*gsi
, enum tree_code code
,
1573 tree op1
, tree op2
, tree op3
)
1575 unsigned new_rhs_ops
= get_gimple_rhs_num_ops (code
);
1576 gimple stmt
= gsi_stmt (*gsi
);
1578 /* If the new CODE needs more operands, allocate a new statement. */
1579 if (gimple_num_ops (stmt
) < new_rhs_ops
+ 1)
1581 tree lhs
= gimple_assign_lhs (stmt
);
1582 gimple new_stmt
= gimple_alloc (gimple_code (stmt
), new_rhs_ops
+ 1);
1583 memcpy (new_stmt
, stmt
, gimple_size (gimple_code (stmt
)));
1584 gimple_init_singleton (new_stmt
);
1585 gsi_replace (gsi
, new_stmt
, true);
1588 /* The LHS needs to be reset as this also changes the SSA name
1590 gimple_assign_set_lhs (stmt
, lhs
);
1593 gimple_set_num_ops (stmt
, new_rhs_ops
+ 1);
1594 gimple_set_subcode (stmt
, code
);
1595 gimple_assign_set_rhs1 (stmt
, op1
);
1596 if (new_rhs_ops
> 1)
1597 gimple_assign_set_rhs2 (stmt
, op2
);
1598 if (new_rhs_ops
> 2)
1599 gimple_assign_set_rhs3 (stmt
, op3
);
1603 /* Return the LHS of a statement that performs an assignment,
1604 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1605 for a call to a function that returns no value, or for a
1606 statement other than an assignment or a call. */
1609 gimple_get_lhs (const_gimple stmt
)
1611 enum gimple_code code
= gimple_code (stmt
);
1613 if (code
== GIMPLE_ASSIGN
)
1614 return gimple_assign_lhs (stmt
);
1615 else if (code
== GIMPLE_CALL
)
1616 return gimple_call_lhs (stmt
);
1622 /* Set the LHS of a statement that performs an assignment,
1623 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1626 gimple_set_lhs (gimple stmt
, tree lhs
)
1628 enum gimple_code code
= gimple_code (stmt
);
1630 if (code
== GIMPLE_ASSIGN
)
1631 gimple_assign_set_lhs (stmt
, lhs
);
1632 else if (code
== GIMPLE_CALL
)
1633 gimple_call_set_lhs (stmt
, lhs
);
1639 /* Return a deep copy of statement STMT. All the operands from STMT
1640 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1641 and VUSE operand arrays are set to empty in the new copy. The new
1642 copy isn't part of any sequence. */
1645 gimple_copy (gimple stmt
)
1647 enum gimple_code code
= gimple_code (stmt
);
1648 unsigned num_ops
= gimple_num_ops (stmt
);
1649 gimple copy
= gimple_alloc (code
, num_ops
);
1652 /* Shallow copy all the fields from STMT. */
1653 memcpy (copy
, stmt
, gimple_size (code
));
1654 gimple_init_singleton (copy
);
1656 /* If STMT has sub-statements, deep-copy them as well. */
1657 if (gimple_has_substatements (stmt
))
1662 switch (gimple_code (stmt
))
1665 new_seq
= gimple_seq_copy (gimple_bind_body (stmt
));
1666 gimple_bind_set_body (copy
, new_seq
);
1667 gimple_bind_set_vars (copy
, unshare_expr (gimple_bind_vars (stmt
)));
1668 gimple_bind_set_block (copy
, gimple_bind_block (stmt
));
1672 new_seq
= gimple_seq_copy (gimple_catch_handler (stmt
));
1673 gimple_catch_set_handler (copy
, new_seq
);
1674 t
= unshare_expr (gimple_catch_types (stmt
));
1675 gimple_catch_set_types (copy
, t
);
1678 case GIMPLE_EH_FILTER
:
1679 new_seq
= gimple_seq_copy (gimple_eh_filter_failure (stmt
));
1680 gimple_eh_filter_set_failure (copy
, new_seq
);
1681 t
= unshare_expr (gimple_eh_filter_types (stmt
));
1682 gimple_eh_filter_set_types (copy
, t
);
1685 case GIMPLE_EH_ELSE
:
1686 new_seq
= gimple_seq_copy (gimple_eh_else_n_body (stmt
));
1687 gimple_eh_else_set_n_body (copy
, new_seq
);
1688 new_seq
= gimple_seq_copy (gimple_eh_else_e_body (stmt
));
1689 gimple_eh_else_set_e_body (copy
, new_seq
);
1693 new_seq
= gimple_seq_copy (gimple_try_eval (stmt
));
1694 gimple_try_set_eval (copy
, new_seq
);
1695 new_seq
= gimple_seq_copy (gimple_try_cleanup (stmt
));
1696 gimple_try_set_cleanup (copy
, new_seq
);
1699 case GIMPLE_OMP_FOR
:
1700 new_seq
= gimple_seq_copy (gimple_omp_for_pre_body (stmt
));
1701 gimple_omp_for_set_pre_body (copy
, new_seq
);
1702 t
= unshare_expr (gimple_omp_for_clauses (stmt
));
1703 gimple_omp_for_set_clauses (copy
, t
);
1705 gimple_statement_omp_for
*omp_for_copy
=
1706 as_a
<gimple_statement_omp_for
*> (copy
);
1707 omp_for_copy
->iter
= ggc_vec_alloc
<gimple_omp_for_iter
>
1708 ( gimple_omp_for_collapse (stmt
));
1710 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1712 gimple_omp_for_set_cond (copy
, i
,
1713 gimple_omp_for_cond (stmt
, i
));
1714 gimple_omp_for_set_index (copy
, i
,
1715 gimple_omp_for_index (stmt
, i
));
1716 t
= unshare_expr (gimple_omp_for_initial (stmt
, i
));
1717 gimple_omp_for_set_initial (copy
, i
, t
);
1718 t
= unshare_expr (gimple_omp_for_final (stmt
, i
));
1719 gimple_omp_for_set_final (copy
, i
, t
);
1720 t
= unshare_expr (gimple_omp_for_incr (stmt
, i
));
1721 gimple_omp_for_set_incr (copy
, i
, t
);
1725 case GIMPLE_OMP_PARALLEL
:
1726 t
= unshare_expr (gimple_omp_parallel_clauses (stmt
));
1727 gimple_omp_parallel_set_clauses (copy
, t
);
1728 t
= unshare_expr (gimple_omp_parallel_child_fn (stmt
));
1729 gimple_omp_parallel_set_child_fn (copy
, t
);
1730 t
= unshare_expr (gimple_omp_parallel_data_arg (stmt
));
1731 gimple_omp_parallel_set_data_arg (copy
, t
);
1734 case GIMPLE_OMP_TASK
:
1735 t
= unshare_expr (gimple_omp_task_clauses (stmt
));
1736 gimple_omp_task_set_clauses (copy
, t
);
1737 t
= unshare_expr (gimple_omp_task_child_fn (stmt
));
1738 gimple_omp_task_set_child_fn (copy
, t
);
1739 t
= unshare_expr (gimple_omp_task_data_arg (stmt
));
1740 gimple_omp_task_set_data_arg (copy
, t
);
1741 t
= unshare_expr (gimple_omp_task_copy_fn (stmt
));
1742 gimple_omp_task_set_copy_fn (copy
, t
);
1743 t
= unshare_expr (gimple_omp_task_arg_size (stmt
));
1744 gimple_omp_task_set_arg_size (copy
, t
);
1745 t
= unshare_expr (gimple_omp_task_arg_align (stmt
));
1746 gimple_omp_task_set_arg_align (copy
, t
);
1749 case GIMPLE_OMP_CRITICAL
:
1750 t
= unshare_expr (gimple_omp_critical_name (stmt
));
1751 gimple_omp_critical_set_name (copy
, t
);
1754 case GIMPLE_OMP_SECTIONS
:
1755 t
= unshare_expr (gimple_omp_sections_clauses (stmt
));
1756 gimple_omp_sections_set_clauses (copy
, t
);
1757 t
= unshare_expr (gimple_omp_sections_control (stmt
));
1758 gimple_omp_sections_set_control (copy
, t
);
1761 case GIMPLE_OMP_SINGLE
:
1762 case GIMPLE_OMP_TARGET
:
1763 case GIMPLE_OMP_TEAMS
:
1764 case GIMPLE_OMP_SECTION
:
1765 case GIMPLE_OMP_MASTER
:
1766 case GIMPLE_OMP_TASKGROUP
:
1767 case GIMPLE_OMP_ORDERED
:
1769 new_seq
= gimple_seq_copy (gimple_omp_body (stmt
));
1770 gimple_omp_set_body (copy
, new_seq
);
1773 case GIMPLE_TRANSACTION
:
1774 new_seq
= gimple_seq_copy (gimple_transaction_body (stmt
));
1775 gimple_transaction_set_body (copy
, new_seq
);
1778 case GIMPLE_WITH_CLEANUP_EXPR
:
1779 new_seq
= gimple_seq_copy (gimple_wce_cleanup (stmt
));
1780 gimple_wce_set_cleanup (copy
, new_seq
);
1788 /* Make copy of operands. */
1789 for (i
= 0; i
< num_ops
; i
++)
1790 gimple_set_op (copy
, i
, unshare_expr (gimple_op (stmt
, i
)));
1792 if (gimple_has_mem_ops (stmt
))
1794 gimple_set_vdef (copy
, gimple_vdef (stmt
));
1795 gimple_set_vuse (copy
, gimple_vuse (stmt
));
1798 /* Clear out SSA operand vectors on COPY. */
1799 if (gimple_has_ops (stmt
))
1801 gimple_set_use_ops (copy
, NULL
);
1803 /* SSA operands need to be updated. */
1804 gimple_set_modified (copy
, true);
1811 /* Return true if statement S has side-effects. We consider a
1812 statement to have side effects if:
1814 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
1815 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
1818 gimple_has_side_effects (const_gimple s
)
1820 if (is_gimple_debug (s
))
1823 /* We don't have to scan the arguments to check for
1824 volatile arguments, though, at present, we still
1825 do a scan to check for TREE_SIDE_EFFECTS. */
1826 if (gimple_has_volatile_ops (s
))
1829 if (gimple_code (s
) == GIMPLE_ASM
1830 && gimple_asm_volatile_p (s
))
1833 if (is_gimple_call (s
))
1835 int flags
= gimple_call_flags (s
);
1837 /* An infinite loop is considered a side effect. */
1838 if (!(flags
& (ECF_CONST
| ECF_PURE
))
1839 || (flags
& ECF_LOOPING_CONST_OR_PURE
))
1848 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
1849 Return true if S can trap. When INCLUDE_MEM is true, check whether
1850 the memory operations could trap. When INCLUDE_STORES is true and
1851 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
1854 gimple_could_trap_p_1 (gimple s
, bool include_mem
, bool include_stores
)
1856 tree t
, div
= NULL_TREE
;
1861 unsigned i
, start
= (is_gimple_assign (s
) && !include_stores
) ? 1 : 0;
1863 for (i
= start
; i
< gimple_num_ops (s
); i
++)
1864 if (tree_could_trap_p (gimple_op (s
, i
)))
1868 switch (gimple_code (s
))
1871 return gimple_asm_volatile_p (s
);
1874 t
= gimple_call_fndecl (s
);
1875 /* Assume that calls to weak functions may trap. */
1876 if (!t
|| !DECL_P (t
) || DECL_WEAK (t
))
1881 t
= gimple_expr_type (s
);
1882 op
= gimple_assign_rhs_code (s
);
1883 if (get_gimple_rhs_class (op
) == GIMPLE_BINARY_RHS
)
1884 div
= gimple_assign_rhs2 (s
);
1885 return (operation_could_trap_p (op
, FLOAT_TYPE_P (t
),
1886 (INTEGRAL_TYPE_P (t
)
1887 && TYPE_OVERFLOW_TRAPS (t
)),
1897 /* Return true if statement S can trap. */
1900 gimple_could_trap_p (gimple s
)
1902 return gimple_could_trap_p_1 (s
, true, true);
1905 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
1908 gimple_assign_rhs_could_trap_p (gimple s
)
1910 gcc_assert (is_gimple_assign (s
));
1911 return gimple_could_trap_p_1 (s
, true, false);
1915 /* Print debugging information for gimple stmts generated. */
1918 dump_gimple_statistics (void)
1920 int i
, total_tuples
= 0, total_bytes
= 0;
1922 if (! GATHER_STATISTICS
)
1924 fprintf (stderr
, "No gimple statistics\n");
1928 fprintf (stderr
, "\nGIMPLE statements\n");
1929 fprintf (stderr
, "Kind Stmts Bytes\n");
1930 fprintf (stderr
, "---------------------------------------\n");
1931 for (i
= 0; i
< (int) gimple_alloc_kind_all
; ++i
)
1933 fprintf (stderr
, "%-20s %7d %10d\n", gimple_alloc_kind_names
[i
],
1934 gimple_alloc_counts
[i
], gimple_alloc_sizes
[i
]);
1935 total_tuples
+= gimple_alloc_counts
[i
];
1936 total_bytes
+= gimple_alloc_sizes
[i
];
1938 fprintf (stderr
, "---------------------------------------\n");
1939 fprintf (stderr
, "%-20s %7d %10d\n", "Total", total_tuples
, total_bytes
);
1940 fprintf (stderr
, "---------------------------------------\n");
1944 /* Return the number of operands needed on the RHS of a GIMPLE
1945 assignment for an expression with tree code CODE. */
1948 get_gimple_rhs_num_ops (enum tree_code code
)
1950 enum gimple_rhs_class rhs_class
= get_gimple_rhs_class (code
);
1952 if (rhs_class
== GIMPLE_UNARY_RHS
|| rhs_class
== GIMPLE_SINGLE_RHS
)
1954 else if (rhs_class
== GIMPLE_BINARY_RHS
)
1956 else if (rhs_class
== GIMPLE_TERNARY_RHS
)
1962 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
1964 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
1965 : ((TYPE) == tcc_binary \
1966 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
1967 : ((TYPE) == tcc_constant \
1968 || (TYPE) == tcc_declaration \
1969 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
1970 : ((SYM) == TRUTH_AND_EXPR \
1971 || (SYM) == TRUTH_OR_EXPR \
1972 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
1973 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
1974 : ((SYM) == COND_EXPR \
1975 || (SYM) == WIDEN_MULT_PLUS_EXPR \
1976 || (SYM) == WIDEN_MULT_MINUS_EXPR \
1977 || (SYM) == DOT_PROD_EXPR \
1978 || (SYM) == SAD_EXPR \
1979 || (SYM) == REALIGN_LOAD_EXPR \
1980 || (SYM) == VEC_COND_EXPR \
1981 || (SYM) == VEC_PERM_EXPR \
1982 || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS \
1983 : ((SYM) == CONSTRUCTOR \
1984 || (SYM) == OBJ_TYPE_REF \
1985 || (SYM) == ASSERT_EXPR \
1986 || (SYM) == ADDR_EXPR \
1987 || (SYM) == WITH_SIZE_EXPR \
1988 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
1989 : GIMPLE_INVALID_RHS),
1990 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
1992 const unsigned char gimple_rhs_class_table
[] = {
1993 #include "all-tree.def"
1997 #undef END_OF_BASE_TREE_CODES
1999 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2000 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2001 we failed to create one. */
2004 canonicalize_cond_expr_cond (tree t
)
2006 /* Strip conversions around boolean operations. */
2007 if (CONVERT_EXPR_P (t
)
2008 && (truth_value_p (TREE_CODE (TREE_OPERAND (t
, 0)))
2009 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
2011 t
= TREE_OPERAND (t
, 0);
2013 /* For !x use x == 0. */
2014 if (TREE_CODE (t
) == TRUTH_NOT_EXPR
)
2016 tree top0
= TREE_OPERAND (t
, 0);
2017 t
= build2 (EQ_EXPR
, TREE_TYPE (t
),
2018 top0
, build_int_cst (TREE_TYPE (top0
), 0));
2020 /* For cmp ? 1 : 0 use cmp. */
2021 else if (TREE_CODE (t
) == COND_EXPR
2022 && COMPARISON_CLASS_P (TREE_OPERAND (t
, 0))
2023 && integer_onep (TREE_OPERAND (t
, 1))
2024 && integer_zerop (TREE_OPERAND (t
, 2)))
2026 tree top0
= TREE_OPERAND (t
, 0);
2027 t
= build2 (TREE_CODE (top0
), TREE_TYPE (t
),
2028 TREE_OPERAND (top0
, 0), TREE_OPERAND (top0
, 1));
2030 /* For x ^ y use x != y. */
2031 else if (TREE_CODE (t
) == BIT_XOR_EXPR
)
2032 t
= build2 (NE_EXPR
, TREE_TYPE (t
),
2033 TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1));
2035 if (is_gimple_condexpr (t
))
2041 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2042 the positions marked by the set ARGS_TO_SKIP. */
2045 gimple_call_copy_skip_args (gimple stmt
, bitmap args_to_skip
)
2048 int nargs
= gimple_call_num_args (stmt
);
2049 auto_vec
<tree
> vargs (nargs
);
2052 for (i
= 0; i
< nargs
; i
++)
2053 if (!bitmap_bit_p (args_to_skip
, i
))
2054 vargs
.quick_push (gimple_call_arg (stmt
, i
));
2056 if (gimple_call_internal_p (stmt
))
2057 new_stmt
= gimple_build_call_internal_vec (gimple_call_internal_fn (stmt
),
2060 new_stmt
= gimple_build_call_vec (gimple_call_fn (stmt
), vargs
);
2062 if (gimple_call_lhs (stmt
))
2063 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2065 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2066 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
2068 if (gimple_has_location (stmt
))
2069 gimple_set_location (new_stmt
, gimple_location (stmt
));
2070 gimple_call_copy_flags (new_stmt
, stmt
);
2071 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2073 gimple_set_modified (new_stmt
, true);
2080 /* Return true if the field decls F1 and F2 are at the same offset.
2082 This is intended to be used on GIMPLE types only. */
2085 gimple_compare_field_offset (tree f1
, tree f2
)
2087 if (DECL_OFFSET_ALIGN (f1
) == DECL_OFFSET_ALIGN (f2
))
2089 tree offset1
= DECL_FIELD_OFFSET (f1
);
2090 tree offset2
= DECL_FIELD_OFFSET (f2
);
2091 return ((offset1
== offset2
2092 /* Once gimplification is done, self-referential offsets are
2093 instantiated as operand #2 of the COMPONENT_REF built for
2094 each access and reset. Therefore, they are not relevant
2095 anymore and fields are interchangeable provided that they
2096 represent the same access. */
2097 || (TREE_CODE (offset1
) == PLACEHOLDER_EXPR
2098 && TREE_CODE (offset2
) == PLACEHOLDER_EXPR
2099 && (DECL_SIZE (f1
) == DECL_SIZE (f2
)
2100 || (TREE_CODE (DECL_SIZE (f1
)) == PLACEHOLDER_EXPR
2101 && TREE_CODE (DECL_SIZE (f2
)) == PLACEHOLDER_EXPR
)
2102 || operand_equal_p (DECL_SIZE (f1
), DECL_SIZE (f2
), 0))
2103 && DECL_ALIGN (f1
) == DECL_ALIGN (f2
))
2104 || operand_equal_p (offset1
, offset2
, 0))
2105 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1
),
2106 DECL_FIELD_BIT_OFFSET (f2
)));
2109 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2110 should be, so handle differing ones specially by decomposing
2111 the offset into a byte and bit offset manually. */
2112 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1
))
2113 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2
)))
2115 unsigned HOST_WIDE_INT byte_offset1
, byte_offset2
;
2116 unsigned HOST_WIDE_INT bit_offset1
, bit_offset2
;
2117 bit_offset1
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1
));
2118 byte_offset1
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1
))
2119 + bit_offset1
/ BITS_PER_UNIT
);
2120 bit_offset2
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2
));
2121 byte_offset2
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2
))
2122 + bit_offset2
/ BITS_PER_UNIT
);
2123 if (byte_offset1
!= byte_offset2
)
2125 return bit_offset1
% BITS_PER_UNIT
== bit_offset2
% BITS_PER_UNIT
;
2132 /* Return a type the same as TYPE except unsigned or
2133 signed according to UNSIGNEDP. */
2136 gimple_signed_or_unsigned_type (bool unsignedp
, tree type
)
2141 type1
= TYPE_MAIN_VARIANT (type
);
2142 if (type1
== signed_char_type_node
2143 || type1
== char_type_node
2144 || type1
== unsigned_char_type_node
)
2145 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2146 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2147 return unsignedp
? unsigned_type_node
: integer_type_node
;
2148 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2149 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2150 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2151 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2152 if (type1
== long_long_integer_type_node
2153 || type1
== long_long_unsigned_type_node
)
2155 ? long_long_unsigned_type_node
2156 : long_long_integer_type_node
;
2158 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2159 if (int_n_enabled_p
[i
]
2160 && (type1
== int_n_trees
[i
].unsigned_type
2161 || type1
== int_n_trees
[i
].signed_type
))
2163 ? int_n_trees
[i
].unsigned_type
2164 : int_n_trees
[i
].signed_type
;
2166 #if HOST_BITS_PER_WIDE_INT >= 64
2167 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2168 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2170 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2171 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2172 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2173 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2174 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2175 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2176 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2177 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2179 #define GIMPLE_FIXED_TYPES(NAME) \
2180 if (type1 == short_ ## NAME ## _type_node \
2181 || type1 == unsigned_short_ ## NAME ## _type_node) \
2182 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2183 : short_ ## NAME ## _type_node; \
2184 if (type1 == NAME ## _type_node \
2185 || type1 == unsigned_ ## NAME ## _type_node) \
2186 return unsignedp ? unsigned_ ## NAME ## _type_node \
2187 : NAME ## _type_node; \
2188 if (type1 == long_ ## NAME ## _type_node \
2189 || type1 == unsigned_long_ ## NAME ## _type_node) \
2190 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2191 : long_ ## NAME ## _type_node; \
2192 if (type1 == long_long_ ## NAME ## _type_node \
2193 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2194 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2195 : long_long_ ## NAME ## _type_node;
2197 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2198 if (type1 == NAME ## _type_node \
2199 || type1 == u ## NAME ## _type_node) \
2200 return unsignedp ? u ## NAME ## _type_node \
2201 : NAME ## _type_node;
2203 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2204 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2205 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2206 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2207 : sat_ ## short_ ## NAME ## _type_node; \
2208 if (type1 == sat_ ## NAME ## _type_node \
2209 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2210 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2211 : sat_ ## NAME ## _type_node; \
2212 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2213 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2214 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2215 : sat_ ## long_ ## NAME ## _type_node; \
2216 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2217 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2218 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2219 : sat_ ## long_long_ ## NAME ## _type_node;
2221 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2222 if (type1 == sat_ ## NAME ## _type_node \
2223 || type1 == sat_ ## u ## NAME ## _type_node) \
2224 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2225 : sat_ ## NAME ## _type_node;
2227 GIMPLE_FIXED_TYPES (fract
);
2228 GIMPLE_FIXED_TYPES_SAT (fract
);
2229 GIMPLE_FIXED_TYPES (accum
);
2230 GIMPLE_FIXED_TYPES_SAT (accum
);
2232 GIMPLE_FIXED_MODE_TYPES (qq
);
2233 GIMPLE_FIXED_MODE_TYPES (hq
);
2234 GIMPLE_FIXED_MODE_TYPES (sq
);
2235 GIMPLE_FIXED_MODE_TYPES (dq
);
2236 GIMPLE_FIXED_MODE_TYPES (tq
);
2237 GIMPLE_FIXED_MODE_TYPES_SAT (qq
);
2238 GIMPLE_FIXED_MODE_TYPES_SAT (hq
);
2239 GIMPLE_FIXED_MODE_TYPES_SAT (sq
);
2240 GIMPLE_FIXED_MODE_TYPES_SAT (dq
);
2241 GIMPLE_FIXED_MODE_TYPES_SAT (tq
);
2242 GIMPLE_FIXED_MODE_TYPES (ha
);
2243 GIMPLE_FIXED_MODE_TYPES (sa
);
2244 GIMPLE_FIXED_MODE_TYPES (da
);
2245 GIMPLE_FIXED_MODE_TYPES (ta
);
2246 GIMPLE_FIXED_MODE_TYPES_SAT (ha
);
2247 GIMPLE_FIXED_MODE_TYPES_SAT (sa
);
2248 GIMPLE_FIXED_MODE_TYPES_SAT (da
);
2249 GIMPLE_FIXED_MODE_TYPES_SAT (ta
);
2251 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2252 the precision; they have precision set to match their range, but
2253 may use a wider mode to match an ABI. If we change modes, we may
2254 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2255 the precision as well, so as to yield correct results for
2256 bit-field types. C++ does not have these separate bit-field
2257 types, and producing a signed or unsigned variant of an
2258 ENUMERAL_TYPE may cause other problems as well. */
2259 if (!INTEGRAL_TYPE_P (type
)
2260 || TYPE_UNSIGNED (type
) == unsignedp
)
2263 #define TYPE_OK(node) \
2264 (TYPE_MODE (type) == TYPE_MODE (node) \
2265 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2266 if (TYPE_OK (signed_char_type_node
))
2267 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2268 if (TYPE_OK (integer_type_node
))
2269 return unsignedp
? unsigned_type_node
: integer_type_node
;
2270 if (TYPE_OK (short_integer_type_node
))
2271 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2272 if (TYPE_OK (long_integer_type_node
))
2273 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2274 if (TYPE_OK (long_long_integer_type_node
))
2276 ? long_long_unsigned_type_node
2277 : long_long_integer_type_node
);
2279 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2280 if (int_n_enabled_p
[i
]
2281 && TYPE_MODE (type
) == int_n_data
[i
].m
2282 && TYPE_PRECISION (type
) == int_n_data
[i
].bitsize
)
2284 ? int_n_trees
[i
].unsigned_type
2285 : int_n_trees
[i
].signed_type
;
2287 #if HOST_BITS_PER_WIDE_INT >= 64
2288 if (TYPE_OK (intTI_type_node
))
2289 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2291 if (TYPE_OK (intDI_type_node
))
2292 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2293 if (TYPE_OK (intSI_type_node
))
2294 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2295 if (TYPE_OK (intHI_type_node
))
2296 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2297 if (TYPE_OK (intQI_type_node
))
2298 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2300 #undef GIMPLE_FIXED_TYPES
2301 #undef GIMPLE_FIXED_MODE_TYPES
2302 #undef GIMPLE_FIXED_TYPES_SAT
2303 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2306 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2310 /* Return an unsigned type the same as TYPE in other respects. */
2313 gimple_unsigned_type (tree type
)
2315 return gimple_signed_or_unsigned_type (true, type
);
2319 /* Return a signed type the same as TYPE in other respects. */
2322 gimple_signed_type (tree type
)
2324 return gimple_signed_or_unsigned_type (false, type
);
2328 /* Return the typed-based alias set for T, which may be an expression
2329 or a type. Return -1 if we don't do anything special. */
2332 gimple_get_alias_set (tree t
)
2336 /* Permit type-punning when accessing a union, provided the access
2337 is directly through the union. For example, this code does not
2338 permit taking the address of a union member and then storing
2339 through it. Even the type-punning allowed here is a GCC
2340 extension, albeit a common and useful one; the C standard says
2341 that such accesses have implementation-defined behavior. */
2343 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2344 u
= TREE_OPERAND (u
, 0))
2345 if (TREE_CODE (u
) == COMPONENT_REF
2346 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2349 /* That's all the expressions we handle specially. */
2353 /* For convenience, follow the C standard when dealing with
2354 character types. Any object may be accessed via an lvalue that
2355 has character type. */
2356 if (t
== char_type_node
2357 || t
== signed_char_type_node
2358 || t
== unsigned_char_type_node
)
2361 /* Allow aliasing between signed and unsigned variants of the same
2362 type. We treat the signed variant as canonical. */
2363 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2365 tree t1
= gimple_signed_type (t
);
2367 /* t1 == t can happen for boolean nodes which are always unsigned. */
2369 return get_alias_set (t1
);
2376 /* Helper for gimple_ior_addresses_taken_1. */
2379 gimple_ior_addresses_taken_1 (gimple
, tree addr
, tree
, void *data
)
2381 bitmap addresses_taken
= (bitmap
)data
;
2382 addr
= get_base_address (addr
);
2386 bitmap_set_bit (addresses_taken
, DECL_UID (addr
));
2392 /* Set the bit for the uid of all decls that have their address taken
2393 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2394 were any in this stmt. */
2397 gimple_ior_addresses_taken (bitmap addresses_taken
, gimple stmt
)
2399 return walk_stmt_load_store_addr_ops (stmt
, addresses_taken
, NULL
, NULL
,
2400 gimple_ior_addresses_taken_1
);
2404 /* Return true if TYPE1 and TYPE2 are compatible enough for builtin
2408 validate_type (tree type1
, tree type2
)
2410 if (INTEGRAL_TYPE_P (type1
)
2411 && INTEGRAL_TYPE_P (type2
))
2413 else if (POINTER_TYPE_P (type1
)
2414 && POINTER_TYPE_P (type2
))
2416 else if (TREE_CODE (type1
)
2417 != TREE_CODE (type2
))
2422 /* Return true when STMTs arguments and return value match those of FNDECL,
2423 a decl of a builtin function. */
2426 gimple_builtin_call_types_compatible_p (const_gimple stmt
, tree fndecl
)
2428 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
);
2430 tree ret
= gimple_call_lhs (stmt
);
2432 && !validate_type (TREE_TYPE (ret
), TREE_TYPE (TREE_TYPE (fndecl
))))
2435 tree targs
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2436 unsigned nargs
= gimple_call_num_args (stmt
);
2437 for (unsigned i
= 0; i
< nargs
; ++i
)
2439 /* Variadic args follow. */
2442 tree arg
= gimple_call_arg (stmt
, i
);
2443 if (!validate_type (TREE_TYPE (arg
), TREE_VALUE (targs
)))
2445 targs
= TREE_CHAIN (targs
);
2447 if (targs
&& !VOID_TYPE_P (TREE_VALUE (targs
)))
2452 /* Return true when STMT is builtins call. */
2455 gimple_call_builtin_p (const_gimple stmt
)
2458 if (is_gimple_call (stmt
)
2459 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2460 && DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
)
2461 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2465 /* Return true when STMT is builtins call to CLASS. */
2468 gimple_call_builtin_p (const_gimple stmt
, enum built_in_class klass
)
2471 if (is_gimple_call (stmt
)
2472 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2473 && DECL_BUILT_IN_CLASS (fndecl
) == klass
)
2474 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2478 /* Return true when STMT is builtins call to CODE of CLASS. */
2481 gimple_call_builtin_p (const_gimple stmt
, enum built_in_function code
)
2484 if (is_gimple_call (stmt
)
2485 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2486 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
2487 && DECL_FUNCTION_CODE (fndecl
) == code
)
2488 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2492 /* Return true if STMT clobbers memory. STMT is required to be a
2496 gimple_asm_clobbers_memory_p (const_gimple stmt
)
2500 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
2502 tree op
= gimple_asm_clobber_op (stmt
, i
);
2503 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op
)), "memory") == 0)
2510 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2513 dump_decl_set (FILE *file
, bitmap set
)
2520 fprintf (file
, "{ ");
2522 EXECUTE_IF_SET_IN_BITMAP (set
, 0, i
, bi
)
2524 fprintf (file
, "D.%u", i
);
2525 fprintf (file
, " ");
2528 fprintf (file
, "}");
2531 fprintf (file
, "NIL");
2534 /* Return true when CALL is a call stmt that definitely doesn't
2535 free any memory or makes it unavailable otherwise. */
2537 nonfreeing_call_p (gimple call
)
2539 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2540 && gimple_call_flags (call
) & ECF_LEAF
)
2541 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call
)))
2543 /* Just in case these become ECF_LEAF in the future. */
2545 case BUILT_IN_TM_FREE
:
2546 case BUILT_IN_REALLOC
:
2547 case BUILT_IN_STACK_RESTORE
:
2552 else if (gimple_call_internal_p (call
))
2553 switch (gimple_call_internal_fn (call
))
2555 case IFN_ABNORMAL_DISPATCHER
:
2558 if (gimple_call_flags (call
) & ECF_LEAF
)
2563 tree fndecl
= gimple_call_fndecl (call
);
2566 struct cgraph_node
*n
= cgraph_node::get (fndecl
);
2569 enum availability availability
;
2570 n
= n
->function_symbol (&availability
);
2571 if (!n
|| availability
<= AVAIL_INTERPOSABLE
)
2573 return n
->nonfreeing_fn
;
2576 /* Callback for walk_stmt_load_store_ops.
2578 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2581 This routine only makes a superficial check for a dereference. Thus
2582 it must only be used if it is safe to return a false negative. */
2584 check_loadstore (gimple
, tree op
, tree
, void *data
)
2586 if ((TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
2587 && operand_equal_p (TREE_OPERAND (op
, 0), (tree
)data
, 0))
2592 /* If OP can be inferred to be non-NULL after STMT executes, return true.
2594 DEREFERENCE is TRUE if we can use a pointer dereference to infer a
2595 non-NULL range, FALSE otherwise.
2597 ATTRIBUTE is TRUE if we can use attributes to infer a non-NULL range
2598 for function arguments and return values. FALSE otherwise. */
2601 infer_nonnull_range (gimple stmt
, tree op
, bool dereference
, bool attribute
)
2603 /* We can only assume that a pointer dereference will yield
2604 non-NULL if -fdelete-null-pointer-checks is enabled. */
2605 if (!flag_delete_null_pointer_checks
2606 || !POINTER_TYPE_P (TREE_TYPE (op
))
2607 || gimple_code (stmt
) == GIMPLE_ASM
)
2611 && walk_stmt_load_store_ops (stmt
, (void *)op
,
2612 check_loadstore
, check_loadstore
))
2616 && is_gimple_call (stmt
) && !gimple_call_internal_p (stmt
))
2618 tree fntype
= gimple_call_fntype (stmt
);
2619 tree attrs
= TYPE_ATTRIBUTES (fntype
);
2620 for (; attrs
; attrs
= TREE_CHAIN (attrs
))
2622 attrs
= lookup_attribute ("nonnull", attrs
);
2624 /* If "nonnull" wasn't specified, we know nothing about
2626 if (attrs
== NULL_TREE
)
2629 /* If "nonnull" applies to all the arguments, then ARG
2630 is non-null if it's in the argument list. */
2631 if (TREE_VALUE (attrs
) == NULL_TREE
)
2633 for (unsigned int i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2635 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt
, i
)))
2636 && operand_equal_p (op
, gimple_call_arg (stmt
, i
), 0))
2642 /* Now see if op appears in the nonnull list. */
2643 for (tree t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
2645 int idx
= TREE_INT_CST_LOW (TREE_VALUE (t
)) - 1;
2646 tree arg
= gimple_call_arg (stmt
, idx
);
2647 if (operand_equal_p (op
, arg
, 0))
2653 /* If this function is marked as returning non-null, then we can
2654 infer OP is non-null if it is used in the return statement. */
2656 && gimple_code (stmt
) == GIMPLE_RETURN
2657 && gimple_return_retval (stmt
)
2658 && operand_equal_p (gimple_return_retval (stmt
), op
, 0)
2659 && lookup_attribute ("returns_nonnull",
2660 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
))))
2666 /* Compare two case labels. Because the front end should already have
2667 made sure that case ranges do not overlap, it is enough to only compare
2668 the CASE_LOW values of each case label. */
2671 compare_case_labels (const void *p1
, const void *p2
)
2673 const_tree
const case1
= *(const_tree
const*)p1
;
2674 const_tree
const case2
= *(const_tree
const*)p2
;
2676 /* The 'default' case label always goes first. */
2677 if (!CASE_LOW (case1
))
2679 else if (!CASE_LOW (case2
))
2682 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
2685 /* Sort the case labels in LABEL_VEC in place in ascending order. */
2688 sort_case_labels (vec
<tree
> label_vec
)
2690 label_vec
.qsort (compare_case_labels
);
2693 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2695 LABELS is a vector that contains all case labels to look at.
2697 INDEX_TYPE is the type of the switch index expression. Case labels
2698 in LABELS are discarded if their values are not in the value range
2699 covered by INDEX_TYPE. The remaining case label values are folded
2702 If a default case exists in LABELS, it is removed from LABELS and
2703 returned in DEFAULT_CASEP. If no default case exists, but the
2704 case labels already cover the whole range of INDEX_TYPE, a default
2705 case is returned pointing to one of the existing case labels.
2706 Otherwise DEFAULT_CASEP is set to NULL_TREE.
2708 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2709 apply and no action is taken regardless of whether a default case is
2713 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
2715 tree
*default_casep
)
2717 tree min_value
, max_value
;
2718 tree default_case
= NULL_TREE
;
2722 min_value
= TYPE_MIN_VALUE (index_type
);
2723 max_value
= TYPE_MAX_VALUE (index_type
);
2724 while (i
< labels
.length ())
2726 tree elt
= labels
[i
];
2727 tree low
= CASE_LOW (elt
);
2728 tree high
= CASE_HIGH (elt
);
2729 bool remove_element
= FALSE
;
2733 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
2734 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
2736 /* This is a non-default case label, i.e. it has a value.
2738 See if the case label is reachable within the range of
2739 the index type. Remove out-of-range case values. Turn
2740 case ranges into a canonical form (high > low strictly)
2741 and convert the case label values to the index type.
2743 NB: The type of gimple_switch_index() may be the promoted
2744 type, but the case labels retain the original type. */
2748 /* This is a case range. Discard empty ranges.
2749 If the bounds or the range are equal, turn this
2750 into a simple (one-value) case. */
2751 int cmp
= tree_int_cst_compare (high
, low
);
2753 remove_element
= TRUE
;
2760 /* If the simple case value is unreachable, ignore it. */
2761 if ((TREE_CODE (min_value
) == INTEGER_CST
2762 && tree_int_cst_compare (low
, min_value
) < 0)
2763 || (TREE_CODE (max_value
) == INTEGER_CST
2764 && tree_int_cst_compare (low
, max_value
) > 0))
2765 remove_element
= TRUE
;
2767 low
= fold_convert (index_type
, low
);
2771 /* If the entire case range is unreachable, ignore it. */
2772 if ((TREE_CODE (min_value
) == INTEGER_CST
2773 && tree_int_cst_compare (high
, min_value
) < 0)
2774 || (TREE_CODE (max_value
) == INTEGER_CST
2775 && tree_int_cst_compare (low
, max_value
) > 0))
2776 remove_element
= TRUE
;
2779 /* If the lower bound is less than the index type's
2780 minimum value, truncate the range bounds. */
2781 if (TREE_CODE (min_value
) == INTEGER_CST
2782 && tree_int_cst_compare (low
, min_value
) < 0)
2784 low
= fold_convert (index_type
, low
);
2786 /* If the upper bound is greater than the index type's
2787 maximum value, truncate the range bounds. */
2788 if (TREE_CODE (max_value
) == INTEGER_CST
2789 && tree_int_cst_compare (high
, max_value
) > 0)
2791 high
= fold_convert (index_type
, high
);
2793 /* We may have folded a case range to a one-value case. */
2794 if (tree_int_cst_equal (low
, high
))
2799 CASE_LOW (elt
) = low
;
2800 CASE_HIGH (elt
) = high
;
2804 gcc_assert (!default_case
);
2806 /* The default case must be passed separately to the
2807 gimple_build_switch routine. But if DEFAULT_CASEP
2808 is NULL, we do not remove the default case (it would
2809 be completely lost). */
2811 remove_element
= TRUE
;
2815 labels
.ordered_remove (i
);
2821 if (!labels
.is_empty ())
2822 sort_case_labels (labels
);
2824 if (default_casep
&& !default_case
)
2826 /* If the switch has no default label, add one, so that we jump
2827 around the switch body. If the labels already cover the whole
2828 range of the switch index_type, add the default label pointing
2829 to one of the existing labels. */
2831 && TYPE_MIN_VALUE (index_type
)
2832 && TYPE_MAX_VALUE (index_type
)
2833 && tree_int_cst_equal (CASE_LOW (labels
[0]),
2834 TYPE_MIN_VALUE (index_type
)))
2836 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
2838 high
= CASE_LOW (labels
[len
- 1]);
2839 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
2841 for (i
= 1; i
< len
; i
++)
2843 high
= CASE_LOW (labels
[i
]);
2844 low
= CASE_HIGH (labels
[i
- 1]);
2846 low
= CASE_LOW (labels
[i
- 1]);
2847 if (wi::add (low
, 1) != high
)
2852 tree label
= CASE_LABEL (labels
[0]);
2853 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
2861 *default_casep
= default_case
;
2864 /* Set the location of all statements in SEQ to LOC. */
2867 gimple_seq_set_location (gimple_seq seq
, location_t loc
)
2869 for (gimple_stmt_iterator i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
2870 gimple_set_location (gsi_stmt (i
), loc
);
2873 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
2876 gimple_seq_discard (gimple_seq seq
)
2878 gimple_stmt_iterator gsi
;
2880 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); )
2882 gimple stmt
= gsi_stmt (gsi
);
2883 gsi_remove (&gsi
, true);
2884 release_defs (stmt
);