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
, 1);
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
));
386 /* Build a GIMPLE_ASSIGN statement.
388 LHS of the assignment.
389 RHS of the assignment which can be unary or binary. */
392 gimple_build_assign_stat (tree lhs
, tree rhs MEM_STAT_DECL
)
394 enum tree_code subcode
;
397 extract_ops_from_tree_1 (rhs
, &subcode
, &op1
, &op2
, &op3
);
398 return gimple_build_assign_with_ops (subcode
, lhs
, op1
, op2
, op3
403 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
404 OP1 and OP2. If OP2 is NULL then SUBCODE must be of class
405 GIMPLE_UNARY_RHS or GIMPLE_SINGLE_RHS. */
408 gimple_build_assign_with_ops (enum tree_code subcode
, tree lhs
, tree op1
,
409 tree op2
, tree op3 MEM_STAT_DECL
)
414 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
416 num_ops
= get_gimple_rhs_num_ops (subcode
) + 1;
418 p
= gimple_build_with_ops_stat (GIMPLE_ASSIGN
, (unsigned)subcode
, num_ops
420 gimple_assign_set_lhs (p
, lhs
);
421 gimple_assign_set_rhs1 (p
, op1
);
424 gcc_assert (num_ops
> 2);
425 gimple_assign_set_rhs2 (p
, op2
);
430 gcc_assert (num_ops
> 3);
431 gimple_assign_set_rhs3 (p
, op3
);
438 gimple_build_assign_with_ops (enum tree_code subcode
, tree lhs
, tree op1
,
439 tree op2 MEM_STAT_DECL
)
441 return gimple_build_assign_with_ops (subcode
, lhs
, op1
, op2
, NULL_TREE
446 /* Build a GIMPLE_COND statement.
448 PRED is the condition used to compare LHS and the RHS.
449 T_LABEL is the label to jump to if the condition is true.
450 F_LABEL is the label to jump to otherwise. */
453 gimple_build_cond (enum tree_code pred_code
, tree lhs
, tree rhs
,
454 tree t_label
, tree f_label
)
458 gcc_assert (TREE_CODE_CLASS (pred_code
) == tcc_comparison
);
459 p
= gimple_build_with_ops (GIMPLE_COND
, pred_code
, 4);
460 gimple_cond_set_lhs (p
, lhs
);
461 gimple_cond_set_rhs (p
, rhs
);
462 gimple_cond_set_true_label (p
, t_label
);
463 gimple_cond_set_false_label (p
, f_label
);
467 /* Build a GIMPLE_COND statement from the conditional expression tree
468 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
471 gimple_build_cond_from_tree (tree cond
, tree t_label
, tree f_label
)
476 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
477 return gimple_build_cond (code
, lhs
, rhs
, t_label
, f_label
);
480 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
481 boolean expression tree COND. */
484 gimple_cond_set_condition_from_tree (gimple stmt
, tree cond
)
489 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
490 gimple_cond_set_condition (stmt
, code
, lhs
, rhs
);
493 /* Build a GIMPLE_LABEL statement for LABEL. */
496 gimple_build_label (tree label
)
498 gimple p
= gimple_build_with_ops (GIMPLE_LABEL
, ERROR_MARK
, 1);
499 gimple_label_set_label (p
, label
);
503 /* Build a GIMPLE_GOTO statement to label DEST. */
506 gimple_build_goto (tree dest
)
508 gimple p
= gimple_build_with_ops (GIMPLE_GOTO
, ERROR_MARK
, 1);
509 gimple_goto_set_dest (p
, dest
);
514 /* Build a GIMPLE_NOP statement. */
517 gimple_build_nop (void)
519 return gimple_alloc (GIMPLE_NOP
, 0);
523 /* Build a GIMPLE_BIND statement.
524 VARS are the variables in BODY.
525 BLOCK is the containing block. */
528 gimple_build_bind (tree vars
, gimple_seq body
, tree block
)
530 gimple p
= gimple_alloc (GIMPLE_BIND
, 0);
531 gimple_bind_set_vars (p
, vars
);
533 gimple_bind_set_body (p
, body
);
535 gimple_bind_set_block (p
, block
);
539 /* Helper function to set the simple fields of a asm stmt.
541 STRING is a pointer to a string that is the asm blocks assembly code.
542 NINPUT is the number of register inputs.
543 NOUTPUT is the number of register outputs.
544 NCLOBBERS is the number of clobbered registers.
548 gimple_build_asm_1 (const char *string
, unsigned ninputs
, unsigned noutputs
,
549 unsigned nclobbers
, unsigned nlabels
)
551 gimple_statement_asm
*p
;
552 int size
= strlen (string
);
554 /* ASMs with labels cannot have outputs. This should have been
555 enforced by the front end. */
556 gcc_assert (nlabels
== 0 || noutputs
== 0);
558 p
= as_a
<gimple_statement_asm
*> (
559 gimple_build_with_ops (GIMPLE_ASM
, ERROR_MARK
,
560 ninputs
+ noutputs
+ nclobbers
+ nlabels
));
566 p
->string
= ggc_alloc_string (string
, size
);
568 if (GATHER_STATISTICS
)
569 gimple_alloc_sizes
[(int) gimple_alloc_kind (GIMPLE_ASM
)] += size
;
574 /* Build a GIMPLE_ASM statement.
576 STRING is the assembly code.
577 NINPUT is the number of register inputs.
578 NOUTPUT is the number of register outputs.
579 NCLOBBERS is the number of clobbered registers.
580 INPUTS is a vector of the input register parameters.
581 OUTPUTS is a vector of the output register parameters.
582 CLOBBERS is a vector of the clobbered register parameters.
583 LABELS is a vector of destination labels. */
586 gimple_build_asm_vec (const char *string
, vec
<tree
, va_gc
> *inputs
,
587 vec
<tree
, va_gc
> *outputs
, vec
<tree
, va_gc
> *clobbers
,
588 vec
<tree
, va_gc
> *labels
)
593 p
= gimple_build_asm_1 (string
,
594 vec_safe_length (inputs
),
595 vec_safe_length (outputs
),
596 vec_safe_length (clobbers
),
597 vec_safe_length (labels
));
599 for (i
= 0; i
< vec_safe_length (inputs
); i
++)
600 gimple_asm_set_input_op (p
, i
, (*inputs
)[i
]);
602 for (i
= 0; i
< vec_safe_length (outputs
); i
++)
603 gimple_asm_set_output_op (p
, i
, (*outputs
)[i
]);
605 for (i
= 0; i
< vec_safe_length (clobbers
); i
++)
606 gimple_asm_set_clobber_op (p
, i
, (*clobbers
)[i
]);
608 for (i
= 0; i
< vec_safe_length (labels
); i
++)
609 gimple_asm_set_label_op (p
, i
, (*labels
)[i
]);
614 /* Build a GIMPLE_CATCH statement.
616 TYPES are the catch types.
617 HANDLER is the exception handler. */
620 gimple_build_catch (tree types
, gimple_seq handler
)
622 gimple p
= gimple_alloc (GIMPLE_CATCH
, 0);
623 gimple_catch_set_types (p
, types
);
625 gimple_catch_set_handler (p
, handler
);
630 /* Build a GIMPLE_EH_FILTER statement.
632 TYPES are the filter's types.
633 FAILURE is the filter's failure action. */
636 gimple_build_eh_filter (tree types
, gimple_seq failure
)
638 gimple p
= gimple_alloc (GIMPLE_EH_FILTER
, 0);
639 gimple_eh_filter_set_types (p
, types
);
641 gimple_eh_filter_set_failure (p
, failure
);
646 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
649 gimple_build_eh_must_not_throw (tree decl
)
651 gimple p
= gimple_alloc (GIMPLE_EH_MUST_NOT_THROW
, 0);
653 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
654 gcc_assert (flags_from_decl_or_type (decl
) & ECF_NORETURN
);
655 gimple_eh_must_not_throw_set_fndecl (p
, decl
);
660 /* Build a GIMPLE_EH_ELSE statement. */
663 gimple_build_eh_else (gimple_seq n_body
, gimple_seq e_body
)
665 gimple p
= gimple_alloc (GIMPLE_EH_ELSE
, 0);
666 gimple_eh_else_set_n_body (p
, n_body
);
667 gimple_eh_else_set_e_body (p
, e_body
);
671 /* Build a GIMPLE_TRY statement.
673 EVAL is the expression to evaluate.
674 CLEANUP is the cleanup expression.
675 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
676 whether this is a try/catch or a try/finally respectively. */
678 gimple_statement_try
*
679 gimple_build_try (gimple_seq eval
, gimple_seq cleanup
,
680 enum gimple_try_flags kind
)
682 gimple_statement_try
*p
;
684 gcc_assert (kind
== GIMPLE_TRY_CATCH
|| kind
== GIMPLE_TRY_FINALLY
);
685 p
= as_a
<gimple_statement_try
*> (gimple_alloc (GIMPLE_TRY
, 0));
686 gimple_set_subcode (p
, kind
);
688 gimple_try_set_eval (p
, eval
);
690 gimple_try_set_cleanup (p
, cleanup
);
695 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
697 CLEANUP is the cleanup expression. */
700 gimple_build_wce (gimple_seq cleanup
)
702 gimple p
= gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR
, 0);
704 gimple_wce_set_cleanup (p
, cleanup
);
710 /* Build a GIMPLE_RESX statement. */
713 gimple_build_resx (int region
)
715 gimple_statement_resx
*p
=
716 as_a
<gimple_statement_resx
*> (
717 gimple_build_with_ops (GIMPLE_RESX
, ERROR_MARK
, 0));
723 /* The helper for constructing a gimple switch statement.
724 INDEX is the switch's index.
725 NLABELS is the number of labels in the switch excluding the default.
726 DEFAULT_LABEL is the default label for the switch statement. */
729 gimple_build_switch_nlabels (unsigned nlabels
, tree index
, tree default_label
)
731 /* nlabels + 1 default label + 1 index. */
732 gcc_checking_assert (default_label
);
733 gimple p
= gimple_build_with_ops (GIMPLE_SWITCH
, ERROR_MARK
,
735 gimple_switch_set_index (p
, index
);
736 gimple_switch_set_default_label (p
, default_label
);
740 /* Build a GIMPLE_SWITCH statement.
742 INDEX is the switch's index.
743 DEFAULT_LABEL is the default label
744 ARGS is a vector of labels excluding the default. */
747 gimple_build_switch (tree index
, tree default_label
, vec
<tree
> args
)
749 unsigned i
, nlabels
= args
.length ();
751 gimple p
= gimple_build_switch_nlabels (nlabels
, index
, default_label
);
753 /* Copy the labels from the vector to the switch statement. */
754 for (i
= 0; i
< nlabels
; i
++)
755 gimple_switch_set_label (p
, i
+ 1, args
[i
]);
760 /* Build a GIMPLE_EH_DISPATCH statement. */
763 gimple_build_eh_dispatch (int region
)
765 gimple_statement_eh_dispatch
*p
=
766 as_a
<gimple_statement_eh_dispatch
*> (
767 gimple_build_with_ops (GIMPLE_EH_DISPATCH
, ERROR_MARK
, 0));
772 /* Build a new GIMPLE_DEBUG_BIND statement.
774 VAR is bound to VALUE; block and location are taken from STMT. */
777 gimple_build_debug_bind_stat (tree var
, tree value
, gimple stmt MEM_STAT_DECL
)
779 gimple p
= gimple_build_with_ops_stat (GIMPLE_DEBUG
,
780 (unsigned)GIMPLE_DEBUG_BIND
, 2
783 gimple_debug_bind_set_var (p
, var
);
784 gimple_debug_bind_set_value (p
, value
);
786 gimple_set_location (p
, gimple_location (stmt
));
792 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
794 VAR is bound to VALUE; block and location are taken from STMT. */
797 gimple_build_debug_source_bind_stat (tree var
, tree value
,
798 gimple stmt MEM_STAT_DECL
)
800 gimple p
= gimple_build_with_ops_stat (GIMPLE_DEBUG
,
801 (unsigned)GIMPLE_DEBUG_SOURCE_BIND
, 2
804 gimple_debug_source_bind_set_var (p
, var
);
805 gimple_debug_source_bind_set_value (p
, value
);
807 gimple_set_location (p
, gimple_location (stmt
));
813 /* Build a GIMPLE_OACC_KERNELS statement.
815 BODY is sequence of statements which are executed as kernels.
816 CLAUSES are the OpenACC kernels construct's clauses. */
819 gimple_build_oacc_kernels (gimple_seq body
, tree clauses
)
821 gimple p
= gimple_alloc (GIMPLE_OACC_KERNELS
, 0);
823 gimple_omp_set_body (p
, body
);
824 gimple_oacc_kernels_set_clauses (p
, clauses
);
830 /* Build a GIMPLE_OACC_PARALLEL statement.
832 BODY is sequence of statements which are executed in parallel.
833 CLAUSES are the OpenACC parallel construct's clauses. */
836 gimple_build_oacc_parallel (gimple_seq body
, tree clauses
)
838 gimple p
= gimple_alloc (GIMPLE_OACC_PARALLEL
, 0);
840 gimple_omp_set_body (p
, body
);
841 gimple_oacc_parallel_set_clauses (p
, clauses
);
847 /* Build a GIMPLE_OMP_CRITICAL statement.
849 BODY is the sequence of statements for which only one thread can execute.
850 NAME is optional identifier for this critical block. */
853 gimple_build_omp_critical (gimple_seq body
, tree name
)
855 gimple p
= gimple_alloc (GIMPLE_OMP_CRITICAL
, 0);
856 gimple_omp_critical_set_name (p
, name
);
858 gimple_omp_set_body (p
, body
);
863 /* Build a GIMPLE_OMP_FOR statement.
865 BODY is sequence of statements inside the for loop.
866 KIND is the `for' variant.
867 CLAUSES, are any of the loop construct's clauses.
868 COLLAPSE is the collapse count.
869 PRE_BODY is the sequence of statements that are loop invariant. */
872 gimple_build_omp_for (gimple_seq body
, int kind
, tree clauses
, size_t collapse
,
875 gimple_statement_omp_for
*p
=
876 as_a
<gimple_statement_omp_for
*> (gimple_alloc (GIMPLE_OMP_FOR
, 0));
878 gimple_omp_set_body (p
, body
);
879 gimple_omp_for_set_clauses (p
, clauses
);
880 gimple_omp_for_set_kind (p
, kind
);
881 p
->collapse
= collapse
;
882 p
->iter
= ggc_cleared_vec_alloc
<gimple_omp_for_iter
> (collapse
);
885 gimple_omp_for_set_pre_body (p
, pre_body
);
891 /* Build a GIMPLE_OMP_PARALLEL statement.
893 BODY is sequence of statements which are executed in parallel.
894 CLAUSES, are the OMP parallel construct's clauses.
895 CHILD_FN is the function created for the parallel threads to execute.
896 DATA_ARG are the shared data argument(s). */
899 gimple_build_omp_parallel (gimple_seq body
, tree clauses
, tree child_fn
,
902 gimple p
= gimple_alloc (GIMPLE_OMP_PARALLEL
, 0);
904 gimple_omp_set_body (p
, body
);
905 gimple_omp_parallel_set_clauses (p
, clauses
);
906 gimple_omp_parallel_set_child_fn (p
, child_fn
);
907 gimple_omp_parallel_set_data_arg (p
, data_arg
);
913 /* Build a GIMPLE_OMP_TASK statement.
915 BODY is sequence of statements which are executed by the explicit task.
916 CLAUSES, are the OMP parallel construct's clauses.
917 CHILD_FN is the function created for the parallel threads to execute.
918 DATA_ARG are the shared data argument(s).
919 COPY_FN is the optional function for firstprivate initialization.
920 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
923 gimple_build_omp_task (gimple_seq body
, tree clauses
, tree child_fn
,
924 tree data_arg
, tree copy_fn
, tree arg_size
,
927 gimple p
= gimple_alloc (GIMPLE_OMP_TASK
, 0);
929 gimple_omp_set_body (p
, body
);
930 gimple_omp_task_set_clauses (p
, clauses
);
931 gimple_omp_task_set_child_fn (p
, child_fn
);
932 gimple_omp_task_set_data_arg (p
, data_arg
);
933 gimple_omp_task_set_copy_fn (p
, copy_fn
);
934 gimple_omp_task_set_arg_size (p
, arg_size
);
935 gimple_omp_task_set_arg_align (p
, arg_align
);
941 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
943 BODY is the sequence of statements in the section. */
946 gimple_build_omp_section (gimple_seq body
)
948 gimple p
= gimple_alloc (GIMPLE_OMP_SECTION
, 0);
950 gimple_omp_set_body (p
, body
);
956 /* Build a GIMPLE_OMP_MASTER statement.
958 BODY is the sequence of statements to be executed by just the master. */
961 gimple_build_omp_master (gimple_seq body
)
963 gimple p
= gimple_alloc (GIMPLE_OMP_MASTER
, 0);
965 gimple_omp_set_body (p
, body
);
971 /* Build a GIMPLE_OMP_TASKGROUP statement.
973 BODY is the sequence of statements to be executed by the taskgroup
977 gimple_build_omp_taskgroup (gimple_seq body
)
979 gimple p
= gimple_alloc (GIMPLE_OMP_TASKGROUP
, 0);
981 gimple_omp_set_body (p
, body
);
987 /* Build a GIMPLE_OMP_CONTINUE statement.
989 CONTROL_DEF is the definition of the control variable.
990 CONTROL_USE is the use of the control variable. */
993 gimple_build_omp_continue (tree control_def
, tree control_use
)
995 gimple p
= gimple_alloc (GIMPLE_OMP_CONTINUE
, 0);
996 gimple_omp_continue_set_control_def (p
, control_def
);
997 gimple_omp_continue_set_control_use (p
, control_use
);
1001 /* Build a GIMPLE_OMP_ORDERED statement.
1003 BODY is the sequence of statements inside a loop that will executed in
1007 gimple_build_omp_ordered (gimple_seq body
)
1009 gimple p
= gimple_alloc (GIMPLE_OMP_ORDERED
, 0);
1011 gimple_omp_set_body (p
, body
);
1017 /* Build a GIMPLE_OMP_RETURN statement.
1018 WAIT_P is true if this is a non-waiting return. */
1021 gimple_build_omp_return (bool wait_p
)
1023 gimple p
= gimple_alloc (GIMPLE_OMP_RETURN
, 0);
1025 gimple_omp_return_set_nowait (p
);
1031 /* Build a GIMPLE_OMP_SECTIONS statement.
1033 BODY is a sequence of section statements.
1034 CLAUSES are any of the OMP sections contsruct's clauses: private,
1035 firstprivate, lastprivate, reduction, and nowait. */
1038 gimple_build_omp_sections (gimple_seq body
, tree clauses
)
1040 gimple p
= gimple_alloc (GIMPLE_OMP_SECTIONS
, 0);
1042 gimple_omp_set_body (p
, body
);
1043 gimple_omp_sections_set_clauses (p
, clauses
);
1049 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1052 gimple_build_omp_sections_switch (void)
1054 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH
, 0);
1058 /* Build a GIMPLE_OMP_SINGLE statement.
1060 BODY is the sequence of statements that will be executed once.
1061 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1062 copyprivate, nowait. */
1065 gimple_build_omp_single (gimple_seq body
, tree clauses
)
1067 gimple p
= gimple_alloc (GIMPLE_OMP_SINGLE
, 0);
1069 gimple_omp_set_body (p
, body
);
1070 gimple_omp_single_set_clauses (p
, clauses
);
1076 /* Build a GIMPLE_OMP_TARGET statement.
1078 BODY is the sequence of statements that will be executed.
1079 KIND is the kind of target region.
1080 CLAUSES are any of the construct's clauses. */
1083 gimple_build_omp_target (gimple_seq body
, int kind
, tree clauses
)
1085 gimple p
= gimple_alloc (GIMPLE_OMP_TARGET
, 0);
1087 gimple_omp_set_body (p
, body
);
1088 gimple_omp_target_set_clauses (p
, clauses
);
1089 gimple_omp_target_set_kind (p
, kind
);
1095 /* Build a GIMPLE_OMP_TEAMS statement.
1097 BODY is the sequence of statements that will be executed.
1098 CLAUSES are any of the OMP teams construct's clauses. */
1101 gimple_build_omp_teams (gimple_seq body
, tree clauses
)
1103 gimple p
= gimple_alloc (GIMPLE_OMP_TEAMS
, 0);
1105 gimple_omp_set_body (p
, body
);
1106 gimple_omp_teams_set_clauses (p
, clauses
);
1112 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1115 gimple_build_omp_atomic_load (tree lhs
, tree rhs
)
1117 gimple p
= gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD
, 0);
1118 gimple_omp_atomic_load_set_lhs (p
, lhs
);
1119 gimple_omp_atomic_load_set_rhs (p
, rhs
);
1123 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1125 VAL is the value we are storing. */
1128 gimple_build_omp_atomic_store (tree val
)
1130 gimple p
= gimple_alloc (GIMPLE_OMP_ATOMIC_STORE
, 0);
1131 gimple_omp_atomic_store_set_val (p
, val
);
1135 /* Build a GIMPLE_TRANSACTION statement. */
1138 gimple_build_transaction (gimple_seq body
, tree label
)
1140 gimple p
= gimple_alloc (GIMPLE_TRANSACTION
, 0);
1141 gimple_transaction_set_body (p
, body
);
1142 gimple_transaction_set_label (p
, label
);
1146 /* Build a GIMPLE_PREDICT statement. PREDICT is one of the predictors from
1147 predict.def, OUTCOME is NOT_TAKEN or TAKEN. */
1150 gimple_build_predict (enum br_predictor predictor
, enum prediction outcome
)
1152 gimple p
= gimple_alloc (GIMPLE_PREDICT
, 0);
1153 /* Ensure all the predictors fit into the lower bits of the subcode. */
1154 gcc_assert ((int) END_PREDICTORS
<= GF_PREDICT_TAKEN
);
1155 gimple_predict_set_predictor (p
, predictor
);
1156 gimple_predict_set_outcome (p
, outcome
);
1160 #if defined ENABLE_GIMPLE_CHECKING
1161 /* Complain of a gimple type mismatch and die. */
1164 gimple_check_failed (const_gimple gs
, const char *file
, int line
,
1165 const char *function
, enum gimple_code code
,
1166 enum tree_code subcode
)
1168 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1169 gimple_code_name
[code
],
1170 get_tree_code_name (subcode
),
1171 gimple_code_name
[gimple_code (gs
)],
1173 ? get_tree_code_name ((enum tree_code
) gs
->subcode
)
1175 function
, trim_filename (file
), line
);
1177 #endif /* ENABLE_GIMPLE_CHECKING */
1180 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1181 *SEQ_P is NULL, a new sequence is allocated. */
1184 gimple_seq_add_stmt (gimple_seq
*seq_p
, gimple gs
)
1186 gimple_stmt_iterator si
;
1190 si
= gsi_last (*seq_p
);
1191 gsi_insert_after (&si
, gs
, GSI_NEW_STMT
);
1194 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1195 *SEQ_P is NULL, a new sequence is allocated. This function is
1196 similar to gimple_seq_add_stmt, but does not scan the operands.
1197 During gimplification, we need to manipulate statement sequences
1198 before the def/use vectors have been constructed. */
1201 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple gs
)
1203 gimple_stmt_iterator si
;
1208 si
= gsi_last (*seq_p
);
1209 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
1212 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1213 NULL, a new sequence is allocated. */
1216 gimple_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
1218 gimple_stmt_iterator si
;
1222 si
= gsi_last (*dst_p
);
1223 gsi_insert_seq_after (&si
, src
, GSI_NEW_STMT
);
1226 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1227 NULL, a new sequence is allocated. This function is
1228 similar to gimple_seq_add_seq, but does not scan the operands. */
1231 gimple_seq_add_seq_without_update (gimple_seq
*dst_p
, gimple_seq src
)
1233 gimple_stmt_iterator si
;
1237 si
= gsi_last (*dst_p
);
1238 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
1241 /* Determine whether to assign a location to the statement GS. */
1244 should_carry_location_p (gimple gs
)
1246 /* Don't emit a line note for a label. We particularly don't want to
1247 emit one for the break label, since it doesn't actually correspond
1248 to the beginning of the loop/switch. */
1249 if (gimple_code (gs
) == GIMPLE_LABEL
)
1255 /* Set the location for gimple statement GS to LOCATION. */
1258 annotate_one_with_location (gimple gs
, location_t location
)
1260 if (!gimple_has_location (gs
)
1261 && !gimple_do_not_emit_location_p (gs
)
1262 && should_carry_location_p (gs
))
1263 gimple_set_location (gs
, location
);
1266 /* Set LOCATION for all the statements after iterator GSI in sequence
1267 SEQ. If GSI is pointing to the end of the sequence, start with the
1268 first statement in SEQ. */
1271 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
1272 location_t location
)
1274 if (gsi_end_p (gsi
))
1275 gsi
= gsi_start (seq
);
1279 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
1280 annotate_one_with_location (gsi_stmt (gsi
), location
);
1283 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1286 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
1288 gimple_stmt_iterator i
;
1290 if (gimple_seq_empty_p (stmt_p
))
1293 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
1295 gimple gs
= gsi_stmt (i
);
1296 annotate_one_with_location (gs
, location
);
1300 /* Helper function of empty_body_p. Return true if STMT is an empty
1304 empty_stmt_p (gimple stmt
)
1306 if (gimple_code (stmt
) == GIMPLE_NOP
)
1308 if (gimple_code (stmt
) == GIMPLE_BIND
)
1309 return empty_body_p (gimple_bind_body (stmt
));
1314 /* Return true if BODY contains nothing but empty statements. */
1317 empty_body_p (gimple_seq body
)
1319 gimple_stmt_iterator i
;
1321 if (gimple_seq_empty_p (body
))
1323 for (i
= gsi_start (body
); !gsi_end_p (i
); gsi_next (&i
))
1324 if (!empty_stmt_p (gsi_stmt (i
))
1325 && !is_gimple_debug (gsi_stmt (i
)))
1332 /* Perform a deep copy of sequence SRC and return the result. */
1335 gimple_seq_copy (gimple_seq src
)
1337 gimple_stmt_iterator gsi
;
1338 gimple_seq new_seq
= NULL
;
1341 for (gsi
= gsi_start (src
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1343 stmt
= gimple_copy (gsi_stmt (gsi
));
1344 gimple_seq_add_stmt (&new_seq
, stmt
);
1352 /* Return true if calls C1 and C2 are known to go to the same function. */
1355 gimple_call_same_target_p (const_gimple c1
, const_gimple c2
)
1357 if (gimple_call_internal_p (c1
))
1358 return (gimple_call_internal_p (c2
)
1359 && gimple_call_internal_fn (c1
) == gimple_call_internal_fn (c2
));
1361 return (gimple_call_fn (c1
) == gimple_call_fn (c2
)
1362 || (gimple_call_fndecl (c1
)
1363 && gimple_call_fndecl (c1
) == gimple_call_fndecl (c2
)));
1366 /* Detect flags from a GIMPLE_CALL. This is just like
1367 call_expr_flags, but for gimple tuples. */
1370 gimple_call_flags (const_gimple stmt
)
1373 tree decl
= gimple_call_fndecl (stmt
);
1376 flags
= flags_from_decl_or_type (decl
);
1377 else if (gimple_call_internal_p (stmt
))
1378 flags
= internal_fn_flags (gimple_call_internal_fn (stmt
));
1380 flags
= flags_from_decl_or_type (gimple_call_fntype (stmt
));
1382 if (stmt
->subcode
& GF_CALL_NOTHROW
)
1383 flags
|= ECF_NOTHROW
;
1388 /* Return the "fn spec" string for call STMT. */
1391 gimple_call_fnspec (const_gimple stmt
)
1395 if (gimple_call_internal_p (stmt
))
1396 return internal_fn_fnspec (gimple_call_internal_fn (stmt
));
1398 type
= gimple_call_fntype (stmt
);
1402 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
1406 return TREE_VALUE (TREE_VALUE (attr
));
1409 /* Detects argument flags for argument number ARG on call STMT. */
1412 gimple_call_arg_flags (const_gimple stmt
, unsigned arg
)
1414 const_tree attr
= gimple_call_fnspec (stmt
);
1416 if (!attr
|| 1 + arg
>= (unsigned) TREE_STRING_LENGTH (attr
))
1419 switch (TREE_STRING_POINTER (attr
)[1 + arg
])
1426 return EAF_DIRECT
| EAF_NOCLOBBER
| EAF_NOESCAPE
;
1429 return EAF_NOCLOBBER
| EAF_NOESCAPE
;
1432 return EAF_DIRECT
| EAF_NOESCAPE
;
1435 return EAF_NOESCAPE
;
1443 /* Detects return flags for the call STMT. */
1446 gimple_call_return_flags (const_gimple stmt
)
1450 if (gimple_call_flags (stmt
) & ECF_MALLOC
)
1453 attr
= gimple_call_fnspec (stmt
);
1454 if (!attr
|| TREE_STRING_LENGTH (attr
) < 1)
1457 switch (TREE_STRING_POINTER (attr
)[0])
1463 return ERF_RETURNS_ARG
| (TREE_STRING_POINTER (attr
)[0] - '1');
1475 /* Return true if GS is a copy assignment. */
1478 gimple_assign_copy_p (gimple gs
)
1480 return (gimple_assign_single_p (gs
)
1481 && is_gimple_val (gimple_op (gs
, 1)));
1485 /* Return true if GS is a SSA_NAME copy assignment. */
1488 gimple_assign_ssa_name_copy_p (gimple gs
)
1490 return (gimple_assign_single_p (gs
)
1491 && TREE_CODE (gimple_assign_lhs (gs
)) == SSA_NAME
1492 && TREE_CODE (gimple_assign_rhs1 (gs
)) == SSA_NAME
);
1496 /* Return true if GS is an assignment with a unary RHS, but the
1497 operator has no effect on the assigned value. The logic is adapted
1498 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1499 instances in which STRIP_NOPS was previously applied to the RHS of
1502 NOTE: In the use cases that led to the creation of this function
1503 and of gimple_assign_single_p, it is typical to test for either
1504 condition and to proceed in the same manner. In each case, the
1505 assigned value is represented by the single RHS operand of the
1506 assignment. I suspect there may be cases where gimple_assign_copy_p,
1507 gimple_assign_single_p, or equivalent logic is used where a similar
1508 treatment of unary NOPs is appropriate. */
1511 gimple_assign_unary_nop_p (gimple gs
)
1513 return (is_gimple_assign (gs
)
1514 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs
))
1515 || gimple_assign_rhs_code (gs
) == NON_LVALUE_EXPR
)
1516 && gimple_assign_rhs1 (gs
) != error_mark_node
1517 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs
)))
1518 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs
)))));
1521 /* Set BB to be the basic block holding G. */
1524 gimple_set_bb (gimple stmt
, basic_block bb
)
1528 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1531 /* If the statement is a label, add the label to block-to-labels map
1532 so that we can speed up edge creation for GIMPLE_GOTOs. */
1538 t
= gimple_label_label (stmt
);
1539 uid
= LABEL_DECL_UID (t
);
1543 vec_safe_length (label_to_block_map_for_fn (cfun
));
1544 LABEL_DECL_UID (t
) = uid
= cfun
->cfg
->last_label_uid
++;
1545 if (old_len
<= (unsigned) uid
)
1547 unsigned new_len
= 3 * uid
/ 2 + 1;
1549 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun
),
1554 (*label_to_block_map_for_fn (cfun
))[uid
] = bb
;
1559 /* Modify the RHS of the assignment pointed-to by GSI using the
1560 operands in the expression tree EXPR.
1562 NOTE: The statement pointed-to by GSI may be reallocated if it
1563 did not have enough operand slots.
1565 This function is useful to convert an existing tree expression into
1566 the flat representation used for the RHS of a GIMPLE assignment.
1567 It will reallocate memory as needed to expand or shrink the number
1568 of operand slots needed to represent EXPR.
1570 NOTE: If you find yourself building a tree and then calling this
1571 function, you are most certainly doing it the slow way. It is much
1572 better to build a new assignment or to use the function
1573 gimple_assign_set_rhs_with_ops, which does not require an
1574 expression tree to be built. */
1577 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*gsi
, tree expr
)
1579 enum tree_code subcode
;
1582 extract_ops_from_tree_1 (expr
, &subcode
, &op1
, &op2
, &op3
);
1583 gimple_assign_set_rhs_with_ops_1 (gsi
, subcode
, op1
, op2
, op3
);
1587 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1588 operands OP1, OP2 and OP3.
1590 NOTE: The statement pointed-to by GSI may be reallocated if it
1591 did not have enough operand slots. */
1594 gimple_assign_set_rhs_with_ops_1 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
1595 tree op1
, tree op2
, tree op3
)
1597 unsigned new_rhs_ops
= get_gimple_rhs_num_ops (code
);
1598 gimple stmt
= gsi_stmt (*gsi
);
1600 /* If the new CODE needs more operands, allocate a new statement. */
1601 if (gimple_num_ops (stmt
) < new_rhs_ops
+ 1)
1603 tree lhs
= gimple_assign_lhs (stmt
);
1604 gimple new_stmt
= gimple_alloc (gimple_code (stmt
), new_rhs_ops
+ 1);
1605 memcpy (new_stmt
, stmt
, gimple_size (gimple_code (stmt
)));
1606 gimple_init_singleton (new_stmt
);
1607 gsi_replace (gsi
, new_stmt
, true);
1610 /* The LHS needs to be reset as this also changes the SSA name
1612 gimple_assign_set_lhs (stmt
, lhs
);
1615 gimple_set_num_ops (stmt
, new_rhs_ops
+ 1);
1616 gimple_set_subcode (stmt
, code
);
1617 gimple_assign_set_rhs1 (stmt
, op1
);
1618 if (new_rhs_ops
> 1)
1619 gimple_assign_set_rhs2 (stmt
, op2
);
1620 if (new_rhs_ops
> 2)
1621 gimple_assign_set_rhs3 (stmt
, op3
);
1625 /* Return the LHS of a statement that performs an assignment,
1626 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1627 for a call to a function that returns no value, or for a
1628 statement other than an assignment or a call. */
1631 gimple_get_lhs (const_gimple stmt
)
1633 enum gimple_code code
= gimple_code (stmt
);
1635 if (code
== GIMPLE_ASSIGN
)
1636 return gimple_assign_lhs (stmt
);
1637 else if (code
== GIMPLE_CALL
)
1638 return gimple_call_lhs (stmt
);
1644 /* Set the LHS of a statement that performs an assignment,
1645 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1648 gimple_set_lhs (gimple stmt
, tree lhs
)
1650 enum gimple_code code
= gimple_code (stmt
);
1652 if (code
== GIMPLE_ASSIGN
)
1653 gimple_assign_set_lhs (stmt
, lhs
);
1654 else if (code
== GIMPLE_CALL
)
1655 gimple_call_set_lhs (stmt
, lhs
);
1661 /* Return a deep copy of statement STMT. All the operands from STMT
1662 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1663 and VUSE operand arrays are set to empty in the new copy. The new
1664 copy isn't part of any sequence. */
1667 gimple_copy (gimple stmt
)
1669 enum gimple_code code
= gimple_code (stmt
);
1670 unsigned num_ops
= gimple_num_ops (stmt
);
1671 gimple copy
= gimple_alloc (code
, num_ops
);
1674 /* Shallow copy all the fields from STMT. */
1675 memcpy (copy
, stmt
, gimple_size (code
));
1676 gimple_init_singleton (copy
);
1678 /* If STMT has sub-statements, deep-copy them as well. */
1679 if (gimple_has_substatements (stmt
))
1684 switch (gimple_code (stmt
))
1687 new_seq
= gimple_seq_copy (gimple_bind_body (stmt
));
1688 gimple_bind_set_body (copy
, new_seq
);
1689 gimple_bind_set_vars (copy
, unshare_expr (gimple_bind_vars (stmt
)));
1690 gimple_bind_set_block (copy
, gimple_bind_block (stmt
));
1694 new_seq
= gimple_seq_copy (gimple_catch_handler (stmt
));
1695 gimple_catch_set_handler (copy
, new_seq
);
1696 t
= unshare_expr (gimple_catch_types (stmt
));
1697 gimple_catch_set_types (copy
, t
);
1700 case GIMPLE_EH_FILTER
:
1701 new_seq
= gimple_seq_copy (gimple_eh_filter_failure (stmt
));
1702 gimple_eh_filter_set_failure (copy
, new_seq
);
1703 t
= unshare_expr (gimple_eh_filter_types (stmt
));
1704 gimple_eh_filter_set_types (copy
, t
);
1707 case GIMPLE_EH_ELSE
:
1708 new_seq
= gimple_seq_copy (gimple_eh_else_n_body (stmt
));
1709 gimple_eh_else_set_n_body (copy
, new_seq
);
1710 new_seq
= gimple_seq_copy (gimple_eh_else_e_body (stmt
));
1711 gimple_eh_else_set_e_body (copy
, new_seq
);
1715 new_seq
= gimple_seq_copy (gimple_try_eval (stmt
));
1716 gimple_try_set_eval (copy
, new_seq
);
1717 new_seq
= gimple_seq_copy (gimple_try_cleanup (stmt
));
1718 gimple_try_set_cleanup (copy
, new_seq
);
1721 case GIMPLE_OACC_KERNELS
:
1722 case GIMPLE_OACC_PARALLEL
:
1725 case GIMPLE_OMP_FOR
:
1726 gcc_assert (!is_gimple_omp_oacc_specifically (stmt
));
1727 new_seq
= gimple_seq_copy (gimple_omp_for_pre_body (stmt
));
1728 gimple_omp_for_set_pre_body (copy
, new_seq
);
1729 t
= unshare_expr (gimple_omp_for_clauses (stmt
));
1730 gimple_omp_for_set_clauses (copy
, t
);
1732 gimple_statement_omp_for
*omp_for_copy
=
1733 as_a
<gimple_statement_omp_for
*> (copy
);
1734 omp_for_copy
->iter
= ggc_vec_alloc
<gimple_omp_for_iter
>
1735 ( gimple_omp_for_collapse (stmt
));
1737 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1739 gimple_omp_for_set_cond (copy
, i
,
1740 gimple_omp_for_cond (stmt
, i
));
1741 gimple_omp_for_set_index (copy
, i
,
1742 gimple_omp_for_index (stmt
, i
));
1743 t
= unshare_expr (gimple_omp_for_initial (stmt
, i
));
1744 gimple_omp_for_set_initial (copy
, i
, t
);
1745 t
= unshare_expr (gimple_omp_for_final (stmt
, i
));
1746 gimple_omp_for_set_final (copy
, i
, t
);
1747 t
= unshare_expr (gimple_omp_for_incr (stmt
, i
));
1748 gimple_omp_for_set_incr (copy
, i
, t
);
1752 case GIMPLE_OMP_PARALLEL
:
1753 t
= unshare_expr (gimple_omp_parallel_clauses (stmt
));
1754 gimple_omp_parallel_set_clauses (copy
, t
);
1755 t
= unshare_expr (gimple_omp_parallel_child_fn (stmt
));
1756 gimple_omp_parallel_set_child_fn (copy
, t
);
1757 t
= unshare_expr (gimple_omp_parallel_data_arg (stmt
));
1758 gimple_omp_parallel_set_data_arg (copy
, t
);
1761 case GIMPLE_OMP_TASK
:
1762 t
= unshare_expr (gimple_omp_task_clauses (stmt
));
1763 gimple_omp_task_set_clauses (copy
, t
);
1764 t
= unshare_expr (gimple_omp_task_child_fn (stmt
));
1765 gimple_omp_task_set_child_fn (copy
, t
);
1766 t
= unshare_expr (gimple_omp_task_data_arg (stmt
));
1767 gimple_omp_task_set_data_arg (copy
, t
);
1768 t
= unshare_expr (gimple_omp_task_copy_fn (stmt
));
1769 gimple_omp_task_set_copy_fn (copy
, t
);
1770 t
= unshare_expr (gimple_omp_task_arg_size (stmt
));
1771 gimple_omp_task_set_arg_size (copy
, t
);
1772 t
= unshare_expr (gimple_omp_task_arg_align (stmt
));
1773 gimple_omp_task_set_arg_align (copy
, t
);
1776 case GIMPLE_OMP_CRITICAL
:
1777 t
= unshare_expr (gimple_omp_critical_name (stmt
));
1778 gimple_omp_critical_set_name (copy
, t
);
1781 case GIMPLE_OMP_SECTIONS
:
1782 t
= unshare_expr (gimple_omp_sections_clauses (stmt
));
1783 gimple_omp_sections_set_clauses (copy
, t
);
1784 t
= unshare_expr (gimple_omp_sections_control (stmt
));
1785 gimple_omp_sections_set_control (copy
, t
);
1788 case GIMPLE_OMP_SINGLE
:
1789 case GIMPLE_OMP_TARGET
:
1790 case GIMPLE_OMP_TEAMS
:
1791 case GIMPLE_OMP_SECTION
:
1792 case GIMPLE_OMP_MASTER
:
1793 case GIMPLE_OMP_TASKGROUP
:
1794 case GIMPLE_OMP_ORDERED
:
1796 gcc_assert (!is_gimple_omp_oacc_specifically (stmt
));
1797 new_seq
= gimple_seq_copy (gimple_omp_body (stmt
));
1798 gimple_omp_set_body (copy
, new_seq
);
1801 case GIMPLE_TRANSACTION
:
1802 new_seq
= gimple_seq_copy (gimple_transaction_body (stmt
));
1803 gimple_transaction_set_body (copy
, new_seq
);
1806 case GIMPLE_WITH_CLEANUP_EXPR
:
1807 new_seq
= gimple_seq_copy (gimple_wce_cleanup (stmt
));
1808 gimple_wce_set_cleanup (copy
, new_seq
);
1816 /* Make copy of operands. */
1817 for (i
= 0; i
< num_ops
; i
++)
1818 gimple_set_op (copy
, i
, unshare_expr (gimple_op (stmt
, i
)));
1820 if (gimple_has_mem_ops (stmt
))
1822 gimple_set_vdef (copy
, gimple_vdef (stmt
));
1823 gimple_set_vuse (copy
, gimple_vuse (stmt
));
1826 /* Clear out SSA operand vectors on COPY. */
1827 if (gimple_has_ops (stmt
))
1829 gimple_set_use_ops (copy
, NULL
);
1831 /* SSA operands need to be updated. */
1832 gimple_set_modified (copy
, true);
1839 /* Return true if statement S has side-effects. We consider a
1840 statement to have side effects if:
1842 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
1843 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
1846 gimple_has_side_effects (const_gimple s
)
1848 if (is_gimple_debug (s
))
1851 /* We don't have to scan the arguments to check for
1852 volatile arguments, though, at present, we still
1853 do a scan to check for TREE_SIDE_EFFECTS. */
1854 if (gimple_has_volatile_ops (s
))
1857 if (gimple_code (s
) == GIMPLE_ASM
1858 && gimple_asm_volatile_p (s
))
1861 if (is_gimple_call (s
))
1863 int flags
= gimple_call_flags (s
);
1865 /* An infinite loop is considered a side effect. */
1866 if (!(flags
& (ECF_CONST
| ECF_PURE
))
1867 || (flags
& ECF_LOOPING_CONST_OR_PURE
))
1876 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
1877 Return true if S can trap. When INCLUDE_MEM is true, check whether
1878 the memory operations could trap. When INCLUDE_STORES is true and
1879 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
1882 gimple_could_trap_p_1 (gimple s
, bool include_mem
, bool include_stores
)
1884 tree t
, div
= NULL_TREE
;
1889 unsigned i
, start
= (is_gimple_assign (s
) && !include_stores
) ? 1 : 0;
1891 for (i
= start
; i
< gimple_num_ops (s
); i
++)
1892 if (tree_could_trap_p (gimple_op (s
, i
)))
1896 switch (gimple_code (s
))
1899 return gimple_asm_volatile_p (s
);
1902 t
= gimple_call_fndecl (s
);
1903 /* Assume that calls to weak functions may trap. */
1904 if (!t
|| !DECL_P (t
) || DECL_WEAK (t
))
1909 t
= gimple_expr_type (s
);
1910 op
= gimple_assign_rhs_code (s
);
1911 if (get_gimple_rhs_class (op
) == GIMPLE_BINARY_RHS
)
1912 div
= gimple_assign_rhs2 (s
);
1913 return (operation_could_trap_p (op
, FLOAT_TYPE_P (t
),
1914 (INTEGRAL_TYPE_P (t
)
1915 && TYPE_OVERFLOW_TRAPS (t
)),
1925 /* Return true if statement S can trap. */
1928 gimple_could_trap_p (gimple s
)
1930 return gimple_could_trap_p_1 (s
, true, true);
1933 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
1936 gimple_assign_rhs_could_trap_p (gimple s
)
1938 gcc_assert (is_gimple_assign (s
));
1939 return gimple_could_trap_p_1 (s
, true, false);
1943 /* Print debugging information for gimple stmts generated. */
1946 dump_gimple_statistics (void)
1948 int i
, total_tuples
= 0, total_bytes
= 0;
1950 if (! GATHER_STATISTICS
)
1952 fprintf (stderr
, "No gimple statistics\n");
1956 fprintf (stderr
, "\nGIMPLE statements\n");
1957 fprintf (stderr
, "Kind Stmts Bytes\n");
1958 fprintf (stderr
, "---------------------------------------\n");
1959 for (i
= 0; i
< (int) gimple_alloc_kind_all
; ++i
)
1961 fprintf (stderr
, "%-20s %7d %10d\n", gimple_alloc_kind_names
[i
],
1962 gimple_alloc_counts
[i
], gimple_alloc_sizes
[i
]);
1963 total_tuples
+= gimple_alloc_counts
[i
];
1964 total_bytes
+= gimple_alloc_sizes
[i
];
1966 fprintf (stderr
, "---------------------------------------\n");
1967 fprintf (stderr
, "%-20s %7d %10d\n", "Total", total_tuples
, total_bytes
);
1968 fprintf (stderr
, "---------------------------------------\n");
1972 /* Return the number of operands needed on the RHS of a GIMPLE
1973 assignment for an expression with tree code CODE. */
1976 get_gimple_rhs_num_ops (enum tree_code code
)
1978 enum gimple_rhs_class rhs_class
= get_gimple_rhs_class (code
);
1980 if (rhs_class
== GIMPLE_UNARY_RHS
|| rhs_class
== GIMPLE_SINGLE_RHS
)
1982 else if (rhs_class
== GIMPLE_BINARY_RHS
)
1984 else if (rhs_class
== GIMPLE_TERNARY_RHS
)
1990 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
1992 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
1993 : ((TYPE) == tcc_binary \
1994 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
1995 : ((TYPE) == tcc_constant \
1996 || (TYPE) == tcc_declaration \
1997 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
1998 : ((SYM) == TRUTH_AND_EXPR \
1999 || (SYM) == TRUTH_OR_EXPR \
2000 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2001 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2002 : ((SYM) == COND_EXPR \
2003 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2004 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2005 || (SYM) == DOT_PROD_EXPR \
2006 || (SYM) == SAD_EXPR \
2007 || (SYM) == REALIGN_LOAD_EXPR \
2008 || (SYM) == VEC_COND_EXPR \
2009 || (SYM) == VEC_PERM_EXPR \
2010 || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS \
2011 : ((SYM) == CONSTRUCTOR \
2012 || (SYM) == OBJ_TYPE_REF \
2013 || (SYM) == ASSERT_EXPR \
2014 || (SYM) == ADDR_EXPR \
2015 || (SYM) == WITH_SIZE_EXPR \
2016 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2017 : GIMPLE_INVALID_RHS),
2018 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2020 const unsigned char gimple_rhs_class_table
[] = {
2021 #include "all-tree.def"
2025 #undef END_OF_BASE_TREE_CODES
2027 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2028 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2029 we failed to create one. */
2032 canonicalize_cond_expr_cond (tree t
)
2034 /* Strip conversions around boolean operations. */
2035 if (CONVERT_EXPR_P (t
)
2036 && (truth_value_p (TREE_CODE (TREE_OPERAND (t
, 0)))
2037 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
2039 t
= TREE_OPERAND (t
, 0);
2041 /* For !x use x == 0. */
2042 if (TREE_CODE (t
) == TRUTH_NOT_EXPR
)
2044 tree top0
= TREE_OPERAND (t
, 0);
2045 t
= build2 (EQ_EXPR
, TREE_TYPE (t
),
2046 top0
, build_int_cst (TREE_TYPE (top0
), 0));
2048 /* For cmp ? 1 : 0 use cmp. */
2049 else if (TREE_CODE (t
) == COND_EXPR
2050 && COMPARISON_CLASS_P (TREE_OPERAND (t
, 0))
2051 && integer_onep (TREE_OPERAND (t
, 1))
2052 && integer_zerop (TREE_OPERAND (t
, 2)))
2054 tree top0
= TREE_OPERAND (t
, 0);
2055 t
= build2 (TREE_CODE (top0
), TREE_TYPE (t
),
2056 TREE_OPERAND (top0
, 0), TREE_OPERAND (top0
, 1));
2058 /* For x ^ y use x != y. */
2059 else if (TREE_CODE (t
) == BIT_XOR_EXPR
)
2060 t
= build2 (NE_EXPR
, TREE_TYPE (t
),
2061 TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1));
2063 if (is_gimple_condexpr (t
))
2069 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2070 the positions marked by the set ARGS_TO_SKIP. */
2073 gimple_call_copy_skip_args (gimple stmt
, bitmap args_to_skip
)
2076 int nargs
= gimple_call_num_args (stmt
);
2077 auto_vec
<tree
> vargs (nargs
);
2080 for (i
= 0; i
< nargs
; i
++)
2081 if (!bitmap_bit_p (args_to_skip
, i
))
2082 vargs
.quick_push (gimple_call_arg (stmt
, i
));
2084 if (gimple_call_internal_p (stmt
))
2085 new_stmt
= gimple_build_call_internal_vec (gimple_call_internal_fn (stmt
),
2088 new_stmt
= gimple_build_call_vec (gimple_call_fn (stmt
), vargs
);
2090 if (gimple_call_lhs (stmt
))
2091 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2093 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2094 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
2096 if (gimple_has_location (stmt
))
2097 gimple_set_location (new_stmt
, gimple_location (stmt
));
2098 gimple_call_copy_flags (new_stmt
, stmt
);
2099 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2101 gimple_set_modified (new_stmt
, true);
2108 /* Return true if the field decls F1 and F2 are at the same offset.
2110 This is intended to be used on GIMPLE types only. */
2113 gimple_compare_field_offset (tree f1
, tree f2
)
2115 if (DECL_OFFSET_ALIGN (f1
) == DECL_OFFSET_ALIGN (f2
))
2117 tree offset1
= DECL_FIELD_OFFSET (f1
);
2118 tree offset2
= DECL_FIELD_OFFSET (f2
);
2119 return ((offset1
== offset2
2120 /* Once gimplification is done, self-referential offsets are
2121 instantiated as operand #2 of the COMPONENT_REF built for
2122 each access and reset. Therefore, they are not relevant
2123 anymore and fields are interchangeable provided that they
2124 represent the same access. */
2125 || (TREE_CODE (offset1
) == PLACEHOLDER_EXPR
2126 && TREE_CODE (offset2
) == PLACEHOLDER_EXPR
2127 && (DECL_SIZE (f1
) == DECL_SIZE (f2
)
2128 || (TREE_CODE (DECL_SIZE (f1
)) == PLACEHOLDER_EXPR
2129 && TREE_CODE (DECL_SIZE (f2
)) == PLACEHOLDER_EXPR
)
2130 || operand_equal_p (DECL_SIZE (f1
), DECL_SIZE (f2
), 0))
2131 && DECL_ALIGN (f1
) == DECL_ALIGN (f2
))
2132 || operand_equal_p (offset1
, offset2
, 0))
2133 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1
),
2134 DECL_FIELD_BIT_OFFSET (f2
)));
2137 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2138 should be, so handle differing ones specially by decomposing
2139 the offset into a byte and bit offset manually. */
2140 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1
))
2141 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2
)))
2143 unsigned HOST_WIDE_INT byte_offset1
, byte_offset2
;
2144 unsigned HOST_WIDE_INT bit_offset1
, bit_offset2
;
2145 bit_offset1
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1
));
2146 byte_offset1
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1
))
2147 + bit_offset1
/ BITS_PER_UNIT
);
2148 bit_offset2
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2
));
2149 byte_offset2
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2
))
2150 + bit_offset2
/ BITS_PER_UNIT
);
2151 if (byte_offset1
!= byte_offset2
)
2153 return bit_offset1
% BITS_PER_UNIT
== bit_offset2
% BITS_PER_UNIT
;
2160 /* Return a type the same as TYPE except unsigned or
2161 signed according to UNSIGNEDP. */
2164 gimple_signed_or_unsigned_type (bool unsignedp
, tree type
)
2169 type1
= TYPE_MAIN_VARIANT (type
);
2170 if (type1
== signed_char_type_node
2171 || type1
== char_type_node
2172 || type1
== unsigned_char_type_node
)
2173 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2174 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2175 return unsignedp
? unsigned_type_node
: integer_type_node
;
2176 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2177 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2178 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2179 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2180 if (type1
== long_long_integer_type_node
2181 || type1
== long_long_unsigned_type_node
)
2183 ? long_long_unsigned_type_node
2184 : long_long_integer_type_node
;
2186 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2187 if (int_n_enabled_p
[i
]
2188 && (type1
== int_n_trees
[i
].unsigned_type
2189 || type1
== int_n_trees
[i
].signed_type
))
2191 ? int_n_trees
[i
].unsigned_type
2192 : int_n_trees
[i
].signed_type
;
2194 #if HOST_BITS_PER_WIDE_INT >= 64
2195 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2196 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2198 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2199 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2200 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2201 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2202 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2203 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2204 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2205 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2207 #define GIMPLE_FIXED_TYPES(NAME) \
2208 if (type1 == short_ ## NAME ## _type_node \
2209 || type1 == unsigned_short_ ## NAME ## _type_node) \
2210 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2211 : short_ ## NAME ## _type_node; \
2212 if (type1 == NAME ## _type_node \
2213 || type1 == unsigned_ ## NAME ## _type_node) \
2214 return unsignedp ? unsigned_ ## NAME ## _type_node \
2215 : NAME ## _type_node; \
2216 if (type1 == long_ ## NAME ## _type_node \
2217 || type1 == unsigned_long_ ## NAME ## _type_node) \
2218 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2219 : long_ ## NAME ## _type_node; \
2220 if (type1 == long_long_ ## NAME ## _type_node \
2221 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2222 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2223 : long_long_ ## NAME ## _type_node;
2225 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2226 if (type1 == NAME ## _type_node \
2227 || type1 == u ## NAME ## _type_node) \
2228 return unsignedp ? u ## NAME ## _type_node \
2229 : NAME ## _type_node;
2231 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2232 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2233 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2234 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2235 : sat_ ## short_ ## NAME ## _type_node; \
2236 if (type1 == sat_ ## NAME ## _type_node \
2237 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2238 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2239 : sat_ ## NAME ## _type_node; \
2240 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2241 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2242 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2243 : sat_ ## long_ ## NAME ## _type_node; \
2244 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2245 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2246 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2247 : sat_ ## long_long_ ## NAME ## _type_node;
2249 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2250 if (type1 == sat_ ## NAME ## _type_node \
2251 || type1 == sat_ ## u ## NAME ## _type_node) \
2252 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2253 : sat_ ## NAME ## _type_node;
2255 GIMPLE_FIXED_TYPES (fract
);
2256 GIMPLE_FIXED_TYPES_SAT (fract
);
2257 GIMPLE_FIXED_TYPES (accum
);
2258 GIMPLE_FIXED_TYPES_SAT (accum
);
2260 GIMPLE_FIXED_MODE_TYPES (qq
);
2261 GIMPLE_FIXED_MODE_TYPES (hq
);
2262 GIMPLE_FIXED_MODE_TYPES (sq
);
2263 GIMPLE_FIXED_MODE_TYPES (dq
);
2264 GIMPLE_FIXED_MODE_TYPES (tq
);
2265 GIMPLE_FIXED_MODE_TYPES_SAT (qq
);
2266 GIMPLE_FIXED_MODE_TYPES_SAT (hq
);
2267 GIMPLE_FIXED_MODE_TYPES_SAT (sq
);
2268 GIMPLE_FIXED_MODE_TYPES_SAT (dq
);
2269 GIMPLE_FIXED_MODE_TYPES_SAT (tq
);
2270 GIMPLE_FIXED_MODE_TYPES (ha
);
2271 GIMPLE_FIXED_MODE_TYPES (sa
);
2272 GIMPLE_FIXED_MODE_TYPES (da
);
2273 GIMPLE_FIXED_MODE_TYPES (ta
);
2274 GIMPLE_FIXED_MODE_TYPES_SAT (ha
);
2275 GIMPLE_FIXED_MODE_TYPES_SAT (sa
);
2276 GIMPLE_FIXED_MODE_TYPES_SAT (da
);
2277 GIMPLE_FIXED_MODE_TYPES_SAT (ta
);
2279 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2280 the precision; they have precision set to match their range, but
2281 may use a wider mode to match an ABI. If we change modes, we may
2282 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2283 the precision as well, so as to yield correct results for
2284 bit-field types. C++ does not have these separate bit-field
2285 types, and producing a signed or unsigned variant of an
2286 ENUMERAL_TYPE may cause other problems as well. */
2287 if (!INTEGRAL_TYPE_P (type
)
2288 || TYPE_UNSIGNED (type
) == unsignedp
)
2291 #define TYPE_OK(node) \
2292 (TYPE_MODE (type) == TYPE_MODE (node) \
2293 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2294 if (TYPE_OK (signed_char_type_node
))
2295 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2296 if (TYPE_OK (integer_type_node
))
2297 return unsignedp
? unsigned_type_node
: integer_type_node
;
2298 if (TYPE_OK (short_integer_type_node
))
2299 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2300 if (TYPE_OK (long_integer_type_node
))
2301 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2302 if (TYPE_OK (long_long_integer_type_node
))
2304 ? long_long_unsigned_type_node
2305 : long_long_integer_type_node
);
2307 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2308 if (int_n_enabled_p
[i
]
2309 && TYPE_MODE (type
) == int_n_data
[i
].m
2310 && TYPE_PRECISION (type
) == int_n_data
[i
].bitsize
)
2312 ? int_n_trees
[i
].unsigned_type
2313 : int_n_trees
[i
].signed_type
;
2315 #if HOST_BITS_PER_WIDE_INT >= 64
2316 if (TYPE_OK (intTI_type_node
))
2317 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2319 if (TYPE_OK (intDI_type_node
))
2320 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2321 if (TYPE_OK (intSI_type_node
))
2322 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2323 if (TYPE_OK (intHI_type_node
))
2324 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2325 if (TYPE_OK (intQI_type_node
))
2326 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2328 #undef GIMPLE_FIXED_TYPES
2329 #undef GIMPLE_FIXED_MODE_TYPES
2330 #undef GIMPLE_FIXED_TYPES_SAT
2331 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2334 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2338 /* Return an unsigned type the same as TYPE in other respects. */
2341 gimple_unsigned_type (tree type
)
2343 return gimple_signed_or_unsigned_type (true, type
);
2347 /* Return a signed type the same as TYPE in other respects. */
2350 gimple_signed_type (tree type
)
2352 return gimple_signed_or_unsigned_type (false, type
);
2356 /* Return the typed-based alias set for T, which may be an expression
2357 or a type. Return -1 if we don't do anything special. */
2360 gimple_get_alias_set (tree t
)
2364 /* Permit type-punning when accessing a union, provided the access
2365 is directly through the union. For example, this code does not
2366 permit taking the address of a union member and then storing
2367 through it. Even the type-punning allowed here is a GCC
2368 extension, albeit a common and useful one; the C standard says
2369 that such accesses have implementation-defined behavior. */
2371 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2372 u
= TREE_OPERAND (u
, 0))
2373 if (TREE_CODE (u
) == COMPONENT_REF
2374 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2377 /* That's all the expressions we handle specially. */
2381 /* For convenience, follow the C standard when dealing with
2382 character types. Any object may be accessed via an lvalue that
2383 has character type. */
2384 if (t
== char_type_node
2385 || t
== signed_char_type_node
2386 || t
== unsigned_char_type_node
)
2389 /* Allow aliasing between signed and unsigned variants of the same
2390 type. We treat the signed variant as canonical. */
2391 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2393 tree t1
= gimple_signed_type (t
);
2395 /* t1 == t can happen for boolean nodes which are always unsigned. */
2397 return get_alias_set (t1
);
2404 /* Helper for gimple_ior_addresses_taken_1. */
2407 gimple_ior_addresses_taken_1 (gimple
, tree addr
, tree
, void *data
)
2409 bitmap addresses_taken
= (bitmap
)data
;
2410 addr
= get_base_address (addr
);
2414 bitmap_set_bit (addresses_taken
, DECL_UID (addr
));
2420 /* Set the bit for the uid of all decls that have their address taken
2421 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2422 were any in this stmt. */
2425 gimple_ior_addresses_taken (bitmap addresses_taken
, gimple stmt
)
2427 return walk_stmt_load_store_addr_ops (stmt
, addresses_taken
, NULL
, NULL
,
2428 gimple_ior_addresses_taken_1
);
2432 /* Return true if TYPE1 and TYPE2 are compatible enough for builtin
2436 validate_type (tree type1
, tree type2
)
2438 if (INTEGRAL_TYPE_P (type1
)
2439 && INTEGRAL_TYPE_P (type2
))
2441 else if (POINTER_TYPE_P (type1
)
2442 && POINTER_TYPE_P (type2
))
2444 else if (TREE_CODE (type1
)
2445 != TREE_CODE (type2
))
2450 /* Return true when STMTs arguments and return value match those of FNDECL,
2451 a decl of a builtin function. */
2454 gimple_builtin_call_types_compatible_p (const_gimple stmt
, tree fndecl
)
2456 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
);
2458 tree ret
= gimple_call_lhs (stmt
);
2460 && !validate_type (TREE_TYPE (ret
), TREE_TYPE (TREE_TYPE (fndecl
))))
2463 tree targs
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2464 unsigned nargs
= gimple_call_num_args (stmt
);
2465 for (unsigned i
= 0; i
< nargs
; ++i
)
2467 /* Variadic args follow. */
2470 tree arg
= gimple_call_arg (stmt
, i
);
2471 if (!validate_type (TREE_TYPE (arg
), TREE_VALUE (targs
)))
2473 targs
= TREE_CHAIN (targs
);
2475 if (targs
&& !VOID_TYPE_P (TREE_VALUE (targs
)))
2480 /* Return true when STMT is builtins call. */
2483 gimple_call_builtin_p (const_gimple stmt
)
2486 if (is_gimple_call (stmt
)
2487 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2488 && DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
)
2489 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2493 /* Return true when STMT is builtins call to CLASS. */
2496 gimple_call_builtin_p (const_gimple stmt
, enum built_in_class klass
)
2499 if (is_gimple_call (stmt
)
2500 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2501 && DECL_BUILT_IN_CLASS (fndecl
) == klass
)
2502 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2506 /* Return true when STMT is builtins call to CODE of CLASS. */
2509 gimple_call_builtin_p (const_gimple stmt
, enum built_in_function code
)
2512 if (is_gimple_call (stmt
)
2513 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2514 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
2515 && DECL_FUNCTION_CODE (fndecl
) == code
)
2516 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2520 /* Return true if STMT clobbers memory. STMT is required to be a
2524 gimple_asm_clobbers_memory_p (const_gimple stmt
)
2528 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
2530 tree op
= gimple_asm_clobber_op (stmt
, i
);
2531 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op
)), "memory") == 0)
2538 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2541 dump_decl_set (FILE *file
, bitmap set
)
2548 fprintf (file
, "{ ");
2550 EXECUTE_IF_SET_IN_BITMAP (set
, 0, i
, bi
)
2552 fprintf (file
, "D.%u", i
);
2553 fprintf (file
, " ");
2556 fprintf (file
, "}");
2559 fprintf (file
, "NIL");
2562 /* Return true when CALL is a call stmt that definitely doesn't
2563 free any memory or makes it unavailable otherwise. */
2565 nonfreeing_call_p (gimple call
)
2567 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2568 && gimple_call_flags (call
) & ECF_LEAF
)
2569 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call
)))
2571 /* Just in case these become ECF_LEAF in the future. */
2573 case BUILT_IN_TM_FREE
:
2574 case BUILT_IN_REALLOC
:
2575 case BUILT_IN_STACK_RESTORE
:
2584 /* Callback for walk_stmt_load_store_ops.
2586 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2589 This routine only makes a superficial check for a dereference. Thus
2590 it must only be used if it is safe to return a false negative. */
2592 check_loadstore (gimple
, tree op
, tree
, void *data
)
2594 if ((TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
2595 && operand_equal_p (TREE_OPERAND (op
, 0), (tree
)data
, 0))
2600 /* If OP can be inferred to be non-NULL after STMT executes, return true.
2602 DEREFERENCE is TRUE if we can use a pointer dereference to infer a
2603 non-NULL range, FALSE otherwise.
2605 ATTRIBUTE is TRUE if we can use attributes to infer a non-NULL range
2606 for function arguments and return values. FALSE otherwise. */
2609 infer_nonnull_range (gimple stmt
, tree op
, bool dereference
, bool attribute
)
2611 /* We can only assume that a pointer dereference will yield
2612 non-NULL if -fdelete-null-pointer-checks is enabled. */
2613 if (!flag_delete_null_pointer_checks
2614 || !POINTER_TYPE_P (TREE_TYPE (op
))
2615 || gimple_code (stmt
) == GIMPLE_ASM
)
2619 && walk_stmt_load_store_ops (stmt
, (void *)op
,
2620 check_loadstore
, check_loadstore
))
2624 && is_gimple_call (stmt
) && !gimple_call_internal_p (stmt
))
2626 tree fntype
= gimple_call_fntype (stmt
);
2627 tree attrs
= TYPE_ATTRIBUTES (fntype
);
2628 for (; attrs
; attrs
= TREE_CHAIN (attrs
))
2630 attrs
= lookup_attribute ("nonnull", attrs
);
2632 /* If "nonnull" wasn't specified, we know nothing about
2634 if (attrs
== NULL_TREE
)
2637 /* If "nonnull" applies to all the arguments, then ARG
2638 is non-null if it's in the argument list. */
2639 if (TREE_VALUE (attrs
) == NULL_TREE
)
2641 for (unsigned int i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2643 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt
, i
)))
2644 && operand_equal_p (op
, gimple_call_arg (stmt
, i
), 0))
2650 /* Now see if op appears in the nonnull list. */
2651 for (tree t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
2653 int idx
= TREE_INT_CST_LOW (TREE_VALUE (t
)) - 1;
2654 tree arg
= gimple_call_arg (stmt
, idx
);
2655 if (operand_equal_p (op
, arg
, 0))
2661 /* If this function is marked as returning non-null, then we can
2662 infer OP is non-null if it is used in the return statement. */
2664 && gimple_code (stmt
) == GIMPLE_RETURN
2665 && gimple_return_retval (stmt
)
2666 && operand_equal_p (gimple_return_retval (stmt
), op
, 0)
2667 && lookup_attribute ("returns_nonnull",
2668 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
))))
2674 /* Compare two case labels. Because the front end should already have
2675 made sure that case ranges do not overlap, it is enough to only compare
2676 the CASE_LOW values of each case label. */
2679 compare_case_labels (const void *p1
, const void *p2
)
2681 const_tree
const case1
= *(const_tree
const*)p1
;
2682 const_tree
const case2
= *(const_tree
const*)p2
;
2684 /* The 'default' case label always goes first. */
2685 if (!CASE_LOW (case1
))
2687 else if (!CASE_LOW (case2
))
2690 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
2693 /* Sort the case labels in LABEL_VEC in place in ascending order. */
2696 sort_case_labels (vec
<tree
> label_vec
)
2698 label_vec
.qsort (compare_case_labels
);
2701 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2703 LABELS is a vector that contains all case labels to look at.
2705 INDEX_TYPE is the type of the switch index expression. Case labels
2706 in LABELS are discarded if their values are not in the value range
2707 covered by INDEX_TYPE. The remaining case label values are folded
2710 If a default case exists in LABELS, it is removed from LABELS and
2711 returned in DEFAULT_CASEP. If no default case exists, but the
2712 case labels already cover the whole range of INDEX_TYPE, a default
2713 case is returned pointing to one of the existing case labels.
2714 Otherwise DEFAULT_CASEP is set to NULL_TREE.
2716 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2717 apply and no action is taken regardless of whether a default case is
2721 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
2723 tree
*default_casep
)
2725 tree min_value
, max_value
;
2726 tree default_case
= NULL_TREE
;
2730 min_value
= TYPE_MIN_VALUE (index_type
);
2731 max_value
= TYPE_MAX_VALUE (index_type
);
2732 while (i
< labels
.length ())
2734 tree elt
= labels
[i
];
2735 tree low
= CASE_LOW (elt
);
2736 tree high
= CASE_HIGH (elt
);
2737 bool remove_element
= FALSE
;
2741 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
2742 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
2744 /* This is a non-default case label, i.e. it has a value.
2746 See if the case label is reachable within the range of
2747 the index type. Remove out-of-range case values. Turn
2748 case ranges into a canonical form (high > low strictly)
2749 and convert the case label values to the index type.
2751 NB: The type of gimple_switch_index() may be the promoted
2752 type, but the case labels retain the original type. */
2756 /* This is a case range. Discard empty ranges.
2757 If the bounds or the range are equal, turn this
2758 into a simple (one-value) case. */
2759 int cmp
= tree_int_cst_compare (high
, low
);
2761 remove_element
= TRUE
;
2768 /* If the simple case value is unreachable, ignore it. */
2769 if ((TREE_CODE (min_value
) == INTEGER_CST
2770 && tree_int_cst_compare (low
, min_value
) < 0)
2771 || (TREE_CODE (max_value
) == INTEGER_CST
2772 && tree_int_cst_compare (low
, max_value
) > 0))
2773 remove_element
= TRUE
;
2775 low
= fold_convert (index_type
, low
);
2779 /* If the entire case range is unreachable, ignore it. */
2780 if ((TREE_CODE (min_value
) == INTEGER_CST
2781 && tree_int_cst_compare (high
, min_value
) < 0)
2782 || (TREE_CODE (max_value
) == INTEGER_CST
2783 && tree_int_cst_compare (low
, max_value
) > 0))
2784 remove_element
= TRUE
;
2787 /* If the lower bound is less than the index type's
2788 minimum value, truncate the range bounds. */
2789 if (TREE_CODE (min_value
) == INTEGER_CST
2790 && tree_int_cst_compare (low
, min_value
) < 0)
2792 low
= fold_convert (index_type
, low
);
2794 /* If the upper bound is greater than the index type's
2795 maximum value, truncate the range bounds. */
2796 if (TREE_CODE (max_value
) == INTEGER_CST
2797 && tree_int_cst_compare (high
, max_value
) > 0)
2799 high
= fold_convert (index_type
, high
);
2801 /* We may have folded a case range to a one-value case. */
2802 if (tree_int_cst_equal (low
, high
))
2807 CASE_LOW (elt
) = low
;
2808 CASE_HIGH (elt
) = high
;
2812 gcc_assert (!default_case
);
2814 /* The default case must be passed separately to the
2815 gimple_build_switch routine. But if DEFAULT_CASEP
2816 is NULL, we do not remove the default case (it would
2817 be completely lost). */
2819 remove_element
= TRUE
;
2823 labels
.ordered_remove (i
);
2829 if (!labels
.is_empty ())
2830 sort_case_labels (labels
);
2832 if (default_casep
&& !default_case
)
2834 /* If the switch has no default label, add one, so that we jump
2835 around the switch body. If the labels already cover the whole
2836 range of the switch index_type, add the default label pointing
2837 to one of the existing labels. */
2839 && TYPE_MIN_VALUE (index_type
)
2840 && TYPE_MAX_VALUE (index_type
)
2841 && tree_int_cst_equal (CASE_LOW (labels
[0]),
2842 TYPE_MIN_VALUE (index_type
)))
2844 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
2846 high
= CASE_LOW (labels
[len
- 1]);
2847 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
2849 for (i
= 1; i
< len
; i
++)
2851 high
= CASE_LOW (labels
[i
]);
2852 low
= CASE_HIGH (labels
[i
- 1]);
2854 low
= CASE_LOW (labels
[i
- 1]);
2855 if (wi::add (low
, 1) != high
)
2860 tree label
= CASE_LABEL (labels
[0]);
2861 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
2869 *default_casep
= default_case
;
2872 /* Set the location of all statements in SEQ to LOC. */
2875 gimple_seq_set_location (gimple_seq seq
, location_t loc
)
2877 for (gimple_stmt_iterator i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
2878 gimple_set_location (gsi_stmt (i
), loc
);
2881 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
2884 gimple_seq_discard (gimple_seq seq
)
2886 gimple_stmt_iterator gsi
;
2888 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); )
2890 gimple stmt
= gsi_stmt (gsi
);
2891 gsi_remove (&gsi
, true);
2892 release_defs (stmt
);