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"
32 #include "basic-block.h"
33 #include "tree-ssa-alias.h"
34 #include "internal-fn.h"
36 #include "gimple-expr.h"
39 #include "gimple-iterator.h"
40 #include "gimple-walk.h"
43 #include "diagnostic.h"
44 #include "value-prof.h"
48 #include "langhooks.h"
52 /* All the tuples have their operand vector (if present) at the very bottom
53 of the structure. Therefore, the offset required to find the
54 operands vector the size of the structure minus the size of the 1
55 element tree array at the end (see gimple_ops). */
56 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
57 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
58 EXPORTED_CONST
size_t gimple_ops_offset_
[] = {
59 #include "gsstruct.def"
63 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
64 static const size_t gsstruct_code_size
[] = {
65 #include "gsstruct.def"
69 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
70 const char *const gimple_code_name
[] = {
75 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
76 EXPORTED_CONST
enum gimple_statement_structure_enum gss_for_code_
[] = {
83 int gimple_alloc_counts
[(int) gimple_alloc_kind_all
];
84 int gimple_alloc_sizes
[(int) gimple_alloc_kind_all
];
86 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
87 static const char * const gimple_alloc_kind_names
[] = {
94 /* Gimple tuple constructors.
95 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
96 be passed a NULL to start with an empty sequence. */
98 /* Set the code for statement G to CODE. */
101 gimple_set_code (gimple g
, enum gimple_code code
)
106 /* Return the number of bytes needed to hold a GIMPLE statement with
110 gimple_size (enum gimple_code code
)
112 return gsstruct_code_size
[gss_for_code (code
)];
115 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
119 gimple_alloc_stat (enum gimple_code code
, unsigned num_ops MEM_STAT_DECL
)
124 size
= gimple_size (code
);
126 size
+= sizeof (tree
) * (num_ops
- 1);
128 if (GATHER_STATISTICS
)
130 enum gimple_alloc_kind kind
= gimple_alloc_kind (code
);
131 gimple_alloc_counts
[(int) kind
]++;
132 gimple_alloc_sizes
[(int) kind
] += size
;
135 stmt
= ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT
);
136 gimple_set_code (stmt
, code
);
137 gimple_set_num_ops (stmt
, num_ops
);
139 /* Do not call gimple_set_modified here as it has other side
140 effects and this tuple is still not completely built. */
142 gimple_init_singleton (stmt
);
147 /* Set SUBCODE to be the code of the expression computed by statement G. */
150 gimple_set_subcode (gimple g
, unsigned subcode
)
152 /* We only have 16 bits for the RHS code. Assert that we are not
154 gcc_assert (subcode
< (1 << 16));
155 g
->subcode
= subcode
;
160 /* Build a tuple with operands. CODE is the statement to build (which
161 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
162 for the new tuple. NUM_OPS is the number of operands to allocate. */
164 #define gimple_build_with_ops(c, s, n) \
165 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
168 gimple_build_with_ops_stat (enum gimple_code code
, unsigned subcode
,
169 unsigned num_ops MEM_STAT_DECL
)
171 gimple s
= gimple_alloc_stat (code
, num_ops PASS_MEM_STAT
);
172 gimple_set_subcode (s
, subcode
);
178 /* Build a GIMPLE_RETURN statement returning RETVAL. */
181 gimple_build_return (tree retval
)
183 gimple s
= gimple_build_with_ops (GIMPLE_RETURN
, ERROR_MARK
, 1);
185 gimple_return_set_retval (s
, retval
);
189 /* Reset alias information on call S. */
192 gimple_call_reset_alias_info (gimple_call s
)
194 if (gimple_call_flags (s
) & ECF_CONST
)
195 memset (gimple_call_use_set (s
), 0, sizeof (struct pt_solution
));
197 pt_solution_reset (gimple_call_use_set (s
));
198 if (gimple_call_flags (s
) & (ECF_CONST
|ECF_PURE
|ECF_NOVOPS
))
199 memset (gimple_call_clobber_set (s
), 0, sizeof (struct pt_solution
));
201 pt_solution_reset (gimple_call_clobber_set (s
));
204 /* Helper for gimple_build_call, gimple_build_call_valist,
205 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
206 components of a GIMPLE_CALL statement to function FN with NARGS
209 static inline gimple_call
210 gimple_build_call_1 (tree fn
, unsigned nargs
)
213 as_a
<gimple_call
> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
215 if (TREE_CODE (fn
) == FUNCTION_DECL
)
216 fn
= build_fold_addr_expr (fn
);
217 gimple_set_op (s
, 1, fn
);
218 gimple_call_set_fntype (s
, TREE_TYPE (TREE_TYPE (fn
)));
219 gimple_call_reset_alias_info (s
);
224 /* Build a GIMPLE_CALL statement to function FN with the arguments
225 specified in vector ARGS. */
228 gimple_build_call_vec (tree fn
, vec
<tree
> args
)
231 unsigned nargs
= args
.length ();
232 gimple_call call
= gimple_build_call_1 (fn
, nargs
);
234 for (i
= 0; i
< nargs
; i
++)
235 gimple_call_set_arg (call
, i
, args
[i
]);
241 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
242 arguments. The ... are the arguments. */
245 gimple_build_call (tree fn
, unsigned nargs
, ...)
251 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
253 call
= gimple_build_call_1 (fn
, nargs
);
255 va_start (ap
, nargs
);
256 for (i
= 0; i
< nargs
; i
++)
257 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
264 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
265 arguments. AP contains the arguments. */
268 gimple_build_call_valist (tree fn
, unsigned nargs
, va_list ap
)
273 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
275 call
= gimple_build_call_1 (fn
, nargs
);
277 for (i
= 0; i
< nargs
; i
++)
278 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
284 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
285 Build the basic components of a GIMPLE_CALL statement to internal
286 function FN with NARGS arguments. */
288 static inline gimple_call
289 gimple_build_call_internal_1 (enum internal_fn fn
, unsigned nargs
)
292 as_a
<gimple_call
> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
294 s
->subcode
|= GF_CALL_INTERNAL
;
295 gimple_call_set_internal_fn (s
, fn
);
296 gimple_call_reset_alias_info (s
);
301 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
302 the number of arguments. The ... are the arguments. */
305 gimple_build_call_internal (enum internal_fn fn
, unsigned nargs
, ...)
311 call
= gimple_build_call_internal_1 (fn
, nargs
);
312 va_start (ap
, nargs
);
313 for (i
= 0; i
< nargs
; i
++)
314 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
321 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
322 specified in vector ARGS. */
325 gimple_build_call_internal_vec (enum internal_fn fn
, vec
<tree
> args
)
330 nargs
= args
.length ();
331 call
= gimple_build_call_internal_1 (fn
, nargs
);
332 for (i
= 0; i
< nargs
; i
++)
333 gimple_call_set_arg (call
, i
, args
[i
]);
339 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
340 assumed to be in GIMPLE form already. Minimal checking is done of
344 gimple_build_call_from_tree (tree t
)
348 tree fndecl
= get_callee_fndecl (t
);
350 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
352 nargs
= call_expr_nargs (t
);
353 call
= gimple_build_call_1 (fndecl
? fndecl
: CALL_EXPR_FN (t
), nargs
);
355 for (i
= 0; i
< nargs
; i
++)
356 gimple_call_set_arg (call
, i
, CALL_EXPR_ARG (t
, i
));
358 gimple_set_block (call
, TREE_BLOCK (t
));
360 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
361 gimple_call_set_chain (call
, CALL_EXPR_STATIC_CHAIN (t
));
362 gimple_call_set_tail (call
, CALL_EXPR_TAILCALL (t
));
363 gimple_call_set_return_slot_opt (call
, CALL_EXPR_RETURN_SLOT_OPT (t
));
365 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
366 && (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA
367 || DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
368 gimple_call_set_alloca_for_var (call
, CALL_ALLOCA_FOR_VAR_P (t
));
370 gimple_call_set_from_thunk (call
, CALL_FROM_THUNK_P (t
));
371 gimple_call_set_va_arg_pack (call
, CALL_EXPR_VA_ARG_PACK (t
));
372 gimple_call_set_nothrow (call
, TREE_NOTHROW (t
));
373 gimple_set_no_warning (call
, TREE_NO_WARNING (t
));
379 /* Build a GIMPLE_ASSIGN statement.
381 LHS of the assignment.
382 RHS of the assignment which can be unary or binary. */
385 gimple_build_assign_stat (tree lhs
, tree rhs MEM_STAT_DECL
)
387 enum tree_code subcode
;
390 extract_ops_from_tree_1 (rhs
, &subcode
, &op1
, &op2
, &op3
);
391 return gimple_build_assign_with_ops (subcode
, lhs
, op1
, op2
, op3
396 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
397 OP1 and OP2. If OP2 is NULL then SUBCODE must be of class
398 GIMPLE_UNARY_RHS or GIMPLE_SINGLE_RHS. */
401 gimple_build_assign_with_ops (enum tree_code subcode
, tree lhs
, tree op1
,
402 tree op2
, tree op3 MEM_STAT_DECL
)
407 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
409 num_ops
= get_gimple_rhs_num_ops (subcode
) + 1;
411 p
= as_a
<gimple_assign
> (
412 gimple_build_with_ops_stat (GIMPLE_ASSIGN
, (unsigned)subcode
, num_ops
414 gimple_assign_set_lhs (p
, lhs
);
415 gimple_assign_set_rhs1 (p
, op1
);
418 gcc_assert (num_ops
> 2);
419 gimple_assign_set_rhs2 (p
, op2
);
424 gcc_assert (num_ops
> 3);
425 gimple_assign_set_rhs3 (p
, op3
);
432 gimple_build_assign_with_ops (enum tree_code subcode
, tree lhs
, tree op1
,
433 tree op2 MEM_STAT_DECL
)
435 return gimple_build_assign_with_ops (subcode
, lhs
, op1
, op2
, NULL_TREE
440 /* Build a GIMPLE_COND statement.
442 PRED is the condition used to compare LHS and the RHS.
443 T_LABEL is the label to jump to if the condition is true.
444 F_LABEL is the label to jump to otherwise. */
447 gimple_build_cond (enum tree_code pred_code
, tree lhs
, tree rhs
,
448 tree t_label
, tree f_label
)
452 gcc_assert (TREE_CODE_CLASS (pred_code
) == tcc_comparison
);
453 p
= as_a
<gimple_cond
> (gimple_build_with_ops (GIMPLE_COND
, pred_code
, 4));
454 gimple_cond_set_lhs (p
, lhs
);
455 gimple_cond_set_rhs (p
, rhs
);
456 gimple_cond_set_true_label (p
, t_label
);
457 gimple_cond_set_false_label (p
, f_label
);
461 /* Build a GIMPLE_COND statement from the conditional expression tree
462 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
465 gimple_build_cond_from_tree (tree cond
, tree t_label
, tree f_label
)
470 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
471 return gimple_build_cond (code
, lhs
, rhs
, t_label
, f_label
);
474 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
475 boolean expression tree COND. */
478 gimple_cond_set_condition_from_tree (gimple_cond stmt
, tree cond
)
483 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
484 gimple_cond_set_condition (stmt
, code
, lhs
, rhs
);
487 /* Build a GIMPLE_LABEL statement for LABEL. */
490 gimple_build_label (tree label
)
493 as_a
<gimple_label
> (gimple_build_with_ops (GIMPLE_LABEL
, ERROR_MARK
, 1));
494 gimple_label_set_label (p
, label
);
498 /* Build a GIMPLE_GOTO statement to label DEST. */
501 gimple_build_goto (tree dest
)
503 gimple p
= gimple_build_with_ops (GIMPLE_GOTO
, ERROR_MARK
, 1);
504 gimple_goto_set_dest (p
, dest
);
509 /* Build a GIMPLE_NOP statement. */
512 gimple_build_nop (void)
514 return gimple_alloc (GIMPLE_NOP
, 0);
518 /* Build a GIMPLE_BIND statement.
519 VARS are the variables in BODY.
520 BLOCK is the containing block. */
523 gimple_build_bind (tree vars
, gimple_seq body
, tree block
)
525 gimple_bind p
= as_a
<gimple_bind
> (gimple_alloc (GIMPLE_BIND
, 0));
526 gimple_bind_set_vars (p
, vars
);
528 gimple_bind_set_body (p
, body
);
530 gimple_bind_set_block (p
, block
);
534 /* Helper function to set the simple fields of a asm stmt.
536 STRING is a pointer to a string that is the asm blocks assembly code.
537 NINPUT is the number of register inputs.
538 NOUTPUT is the number of register outputs.
539 NCLOBBERS is the number of clobbered registers.
543 gimple_build_asm_1 (const char *string
, unsigned ninputs
, unsigned noutputs
,
544 unsigned nclobbers
, unsigned nlabels
)
546 gimple_statement_asm
*p
;
547 int size
= strlen (string
);
549 /* ASMs with labels cannot have outputs. This should have been
550 enforced by the front end. */
551 gcc_assert (nlabels
== 0 || noutputs
== 0);
553 p
= as_a
<gimple_statement_asm
*> (
554 gimple_build_with_ops (GIMPLE_ASM
, ERROR_MARK
,
555 ninputs
+ noutputs
+ nclobbers
+ nlabels
));
561 p
->string
= ggc_alloc_string (string
, size
);
563 if (GATHER_STATISTICS
)
564 gimple_alloc_sizes
[(int) gimple_alloc_kind (GIMPLE_ASM
)] += size
;
569 /* Build a GIMPLE_ASM statement.
571 STRING is the assembly code.
572 NINPUT is the number of register inputs.
573 NOUTPUT is the number of register outputs.
574 NCLOBBERS is the number of clobbered registers.
575 INPUTS is a vector of the input register parameters.
576 OUTPUTS is a vector of the output register parameters.
577 CLOBBERS is a vector of the clobbered register parameters.
578 LABELS is a vector of destination labels. */
581 gimple_build_asm_vec (const char *string
, vec
<tree
, va_gc
> *inputs
,
582 vec
<tree
, va_gc
> *outputs
, vec
<tree
, va_gc
> *clobbers
,
583 vec
<tree
, va_gc
> *labels
)
588 p
= gimple_build_asm_1 (string
,
589 vec_safe_length (inputs
),
590 vec_safe_length (outputs
),
591 vec_safe_length (clobbers
),
592 vec_safe_length (labels
));
594 for (i
= 0; i
< vec_safe_length (inputs
); i
++)
595 gimple_asm_set_input_op (p
, i
, (*inputs
)[i
]);
597 for (i
= 0; i
< vec_safe_length (outputs
); i
++)
598 gimple_asm_set_output_op (p
, i
, (*outputs
)[i
]);
600 for (i
= 0; i
< vec_safe_length (clobbers
); i
++)
601 gimple_asm_set_clobber_op (p
, i
, (*clobbers
)[i
]);
603 for (i
= 0; i
< vec_safe_length (labels
); i
++)
604 gimple_asm_set_label_op (p
, i
, (*labels
)[i
]);
609 /* Build a GIMPLE_CATCH statement.
611 TYPES are the catch types.
612 HANDLER is the exception handler. */
615 gimple_build_catch (tree types
, gimple_seq handler
)
617 gimple p
= gimple_alloc (GIMPLE_CATCH
, 0);
618 gimple_catch_set_types (p
, types
);
620 gimple_catch_set_handler (p
, handler
);
625 /* Build a GIMPLE_EH_FILTER statement.
627 TYPES are the filter's types.
628 FAILURE is the filter's failure action. */
631 gimple_build_eh_filter (tree types
, gimple_seq failure
)
633 gimple p
= gimple_alloc (GIMPLE_EH_FILTER
, 0);
634 gimple_eh_filter_set_types (p
, types
);
636 gimple_eh_filter_set_failure (p
, failure
);
641 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
644 gimple_build_eh_must_not_throw (tree decl
)
646 gimple p
= gimple_alloc (GIMPLE_EH_MUST_NOT_THROW
, 0);
648 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
649 gcc_assert (flags_from_decl_or_type (decl
) & ECF_NORETURN
);
650 gimple_eh_must_not_throw_set_fndecl (p
, decl
);
655 /* Build a GIMPLE_EH_ELSE statement. */
658 gimple_build_eh_else (gimple_seq n_body
, gimple_seq e_body
)
660 gimple p
= gimple_alloc (GIMPLE_EH_ELSE
, 0);
661 gimple_eh_else_set_n_body (p
, n_body
);
662 gimple_eh_else_set_e_body (p
, e_body
);
666 /* Build a GIMPLE_TRY statement.
668 EVAL is the expression to evaluate.
669 CLEANUP is the cleanup expression.
670 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
671 whether this is a try/catch or a try/finally respectively. */
673 gimple_statement_try
*
674 gimple_build_try (gimple_seq eval
, gimple_seq cleanup
,
675 enum gimple_try_flags kind
)
677 gimple_statement_try
*p
;
679 gcc_assert (kind
== GIMPLE_TRY_CATCH
|| kind
== GIMPLE_TRY_FINALLY
);
680 p
= as_a
<gimple_statement_try
*> (gimple_alloc (GIMPLE_TRY
, 0));
681 gimple_set_subcode (p
, kind
);
683 gimple_try_set_eval (p
, eval
);
685 gimple_try_set_cleanup (p
, cleanup
);
690 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
692 CLEANUP is the cleanup expression. */
695 gimple_build_wce (gimple_seq cleanup
)
697 gimple p
= gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR
, 0);
699 gimple_wce_set_cleanup (p
, cleanup
);
705 /* Build a GIMPLE_RESX statement. */
708 gimple_build_resx (int region
)
710 gimple_statement_resx
*p
=
711 as_a
<gimple_statement_resx
*> (
712 gimple_build_with_ops (GIMPLE_RESX
, ERROR_MARK
, 0));
718 /* The helper for constructing a gimple switch statement.
719 INDEX is the switch's index.
720 NLABELS is the number of labels in the switch excluding the default.
721 DEFAULT_LABEL is the default label for the switch statement. */
724 gimple_build_switch_nlabels (unsigned nlabels
, tree index
, tree default_label
)
726 /* nlabels + 1 default label + 1 index. */
727 gcc_checking_assert (default_label
);
729 as_a
<gimple_switch
> (gimple_build_with_ops (GIMPLE_SWITCH
, ERROR_MARK
,
731 gimple_switch_set_index (p
, index
);
732 gimple_switch_set_default_label (p
, default_label
);
736 /* Build a GIMPLE_SWITCH statement.
738 INDEX is the switch's index.
739 DEFAULT_LABEL is the default label
740 ARGS is a vector of labels excluding the default. */
743 gimple_build_switch (tree index
, tree default_label
, vec
<tree
> args
)
745 unsigned i
, nlabels
= args
.length ();
747 gimple_switch p
= gimple_build_switch_nlabels (nlabels
, index
, default_label
);
749 /* Copy the labels from the vector to the switch statement. */
750 for (i
= 0; i
< nlabels
; i
++)
751 gimple_switch_set_label (p
, i
+ 1, args
[i
]);
756 /* Build a GIMPLE_EH_DISPATCH statement. */
759 gimple_build_eh_dispatch (int region
)
761 gimple_statement_eh_dispatch
*p
=
762 as_a
<gimple_statement_eh_dispatch
*> (
763 gimple_build_with_ops (GIMPLE_EH_DISPATCH
, ERROR_MARK
, 0));
768 /* Build a new GIMPLE_DEBUG_BIND statement.
770 VAR is bound to VALUE; block and location are taken from STMT. */
773 gimple_build_debug_bind_stat (tree var
, tree value
, gimple stmt MEM_STAT_DECL
)
776 as_a
<gimple_debug
> (gimple_build_with_ops_stat (GIMPLE_DEBUG
,
777 (unsigned)GIMPLE_DEBUG_BIND
, 2
779 gimple_debug_bind_set_var (p
, var
);
780 gimple_debug_bind_set_value (p
, value
);
782 gimple_set_location (p
, gimple_location (stmt
));
788 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
790 VAR is bound to VALUE; block and location are taken from STMT. */
793 gimple_build_debug_source_bind_stat (tree var
, tree value
,
794 gimple stmt MEM_STAT_DECL
)
797 as_a
<gimple_debug
> (
798 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
799 (unsigned)GIMPLE_DEBUG_SOURCE_BIND
, 2
802 gimple_debug_source_bind_set_var (p
, var
);
803 gimple_debug_source_bind_set_value (p
, value
);
805 gimple_set_location (p
, gimple_location (stmt
));
811 /* Build a GIMPLE_OMP_CRITICAL statement.
813 BODY is the sequence of statements for which only one thread can execute.
814 NAME is optional identifier for this critical block. */
817 gimple_build_omp_critical (gimple_seq body
, tree name
)
819 gimple p
= gimple_alloc (GIMPLE_OMP_CRITICAL
, 0);
820 gimple_omp_critical_set_name (p
, name
);
822 gimple_omp_set_body (p
, body
);
827 /* Build a GIMPLE_OMP_FOR statement.
829 BODY is sequence of statements inside the for loop.
830 KIND is the `for' variant.
831 CLAUSES, are any of the OMP loop construct's clauses: private, firstprivate,
832 lastprivate, reductions, ordered, schedule, and nowait.
833 COLLAPSE is the collapse count.
834 PRE_BODY is the sequence of statements that are loop invariant. */
837 gimple_build_omp_for (gimple_seq body
, int kind
, tree clauses
, size_t collapse
,
840 gimple_statement_omp_for
*p
=
841 as_a
<gimple_statement_omp_for
*> (gimple_alloc (GIMPLE_OMP_FOR
, 0));
843 gimple_omp_set_body (p
, body
);
844 gimple_omp_for_set_clauses (p
, clauses
);
845 gimple_omp_for_set_kind (p
, kind
);
846 p
->collapse
= collapse
;
847 p
->iter
= ggc_cleared_vec_alloc
<gimple_omp_for_iter
> (collapse
);
850 gimple_omp_for_set_pre_body (p
, pre_body
);
856 /* Build a GIMPLE_OMP_PARALLEL statement.
858 BODY is sequence of statements which are executed in parallel.
859 CLAUSES, are the OMP parallel construct's clauses.
860 CHILD_FN is the function created for the parallel threads to execute.
861 DATA_ARG are the shared data argument(s). */
864 gimple_build_omp_parallel (gimple_seq body
, tree clauses
, tree child_fn
,
867 gimple p
= gimple_alloc (GIMPLE_OMP_PARALLEL
, 0);
869 gimple_omp_set_body (p
, body
);
870 gimple_omp_parallel_set_clauses (p
, clauses
);
871 gimple_omp_parallel_set_child_fn (p
, child_fn
);
872 gimple_omp_parallel_set_data_arg (p
, data_arg
);
878 /* Build a GIMPLE_OMP_TASK statement.
880 BODY is sequence of statements which are executed by the explicit task.
881 CLAUSES, are the OMP parallel construct's clauses.
882 CHILD_FN is the function created for the parallel threads to execute.
883 DATA_ARG are the shared data argument(s).
884 COPY_FN is the optional function for firstprivate initialization.
885 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
888 gimple_build_omp_task (gimple_seq body
, tree clauses
, tree child_fn
,
889 tree data_arg
, tree copy_fn
, tree arg_size
,
892 gimple p
= gimple_alloc (GIMPLE_OMP_TASK
, 0);
894 gimple_omp_set_body (p
, body
);
895 gimple_omp_task_set_clauses (p
, clauses
);
896 gimple_omp_task_set_child_fn (p
, child_fn
);
897 gimple_omp_task_set_data_arg (p
, data_arg
);
898 gimple_omp_task_set_copy_fn (p
, copy_fn
);
899 gimple_omp_task_set_arg_size (p
, arg_size
);
900 gimple_omp_task_set_arg_align (p
, arg_align
);
906 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
908 BODY is the sequence of statements in the section. */
911 gimple_build_omp_section (gimple_seq body
)
913 gimple p
= gimple_alloc (GIMPLE_OMP_SECTION
, 0);
915 gimple_omp_set_body (p
, body
);
921 /* Build a GIMPLE_OMP_MASTER statement.
923 BODY is the sequence of statements to be executed by just the master. */
926 gimple_build_omp_master (gimple_seq body
)
928 gimple p
= gimple_alloc (GIMPLE_OMP_MASTER
, 0);
930 gimple_omp_set_body (p
, body
);
936 /* Build a GIMPLE_OMP_TASKGROUP statement.
938 BODY is the sequence of statements to be executed by the taskgroup
942 gimple_build_omp_taskgroup (gimple_seq body
)
944 gimple p
= gimple_alloc (GIMPLE_OMP_TASKGROUP
, 0);
946 gimple_omp_set_body (p
, body
);
952 /* Build a GIMPLE_OMP_CONTINUE statement.
954 CONTROL_DEF is the definition of the control variable.
955 CONTROL_USE is the use of the control variable. */
958 gimple_build_omp_continue (tree control_def
, tree control_use
)
960 gimple p
= gimple_alloc (GIMPLE_OMP_CONTINUE
, 0);
961 gimple_omp_continue_set_control_def (p
, control_def
);
962 gimple_omp_continue_set_control_use (p
, control_use
);
966 /* Build a GIMPLE_OMP_ORDERED statement.
968 BODY is the sequence of statements inside a loop that will executed in
972 gimple_build_omp_ordered (gimple_seq body
)
974 gimple p
= gimple_alloc (GIMPLE_OMP_ORDERED
, 0);
976 gimple_omp_set_body (p
, body
);
982 /* Build a GIMPLE_OMP_RETURN statement.
983 WAIT_P is true if this is a non-waiting return. */
986 gimple_build_omp_return (bool wait_p
)
988 gimple p
= gimple_alloc (GIMPLE_OMP_RETURN
, 0);
990 gimple_omp_return_set_nowait (p
);
996 /* Build a GIMPLE_OMP_SECTIONS statement.
998 BODY is a sequence of section statements.
999 CLAUSES are any of the OMP sections contsruct's clauses: private,
1000 firstprivate, lastprivate, reduction, and nowait. */
1003 gimple_build_omp_sections (gimple_seq body
, tree clauses
)
1005 gimple p
= gimple_alloc (GIMPLE_OMP_SECTIONS
, 0);
1007 gimple_omp_set_body (p
, body
);
1008 gimple_omp_sections_set_clauses (p
, clauses
);
1014 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1017 gimple_build_omp_sections_switch (void)
1019 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH
, 0);
1023 /* Build a GIMPLE_OMP_SINGLE statement.
1025 BODY is the sequence of statements that will be executed once.
1026 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1027 copyprivate, nowait. */
1030 gimple_build_omp_single (gimple_seq body
, tree clauses
)
1032 gimple p
= gimple_alloc (GIMPLE_OMP_SINGLE
, 0);
1034 gimple_omp_set_body (p
, body
);
1035 gimple_omp_single_set_clauses (p
, clauses
);
1041 /* Build a GIMPLE_OMP_TARGET statement.
1043 BODY is the sequence of statements that will be executed.
1044 CLAUSES are any of the OMP target construct's clauses. */
1047 gimple_build_omp_target (gimple_seq body
, int kind
, tree clauses
)
1049 gimple p
= gimple_alloc (GIMPLE_OMP_TARGET
, 0);
1051 gimple_omp_set_body (p
, body
);
1052 gimple_omp_target_set_clauses (p
, clauses
);
1053 gimple_omp_target_set_kind (p
, kind
);
1059 /* Build a GIMPLE_OMP_TEAMS statement.
1061 BODY is the sequence of statements that will be executed.
1062 CLAUSES are any of the OMP teams construct's clauses. */
1065 gimple_build_omp_teams (gimple_seq body
, tree clauses
)
1067 gimple p
= gimple_alloc (GIMPLE_OMP_TEAMS
, 0);
1069 gimple_omp_set_body (p
, body
);
1070 gimple_omp_teams_set_clauses (p
, clauses
);
1076 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1079 gimple_build_omp_atomic_load (tree lhs
, tree rhs
)
1081 gimple p
= gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD
, 0);
1082 gimple_omp_atomic_load_set_lhs (p
, lhs
);
1083 gimple_omp_atomic_load_set_rhs (p
, rhs
);
1087 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1089 VAL is the value we are storing. */
1092 gimple_build_omp_atomic_store (tree val
)
1094 gimple p
= gimple_alloc (GIMPLE_OMP_ATOMIC_STORE
, 0);
1095 gimple_omp_atomic_store_set_val (p
, val
);
1099 /* Build a GIMPLE_TRANSACTION statement. */
1102 gimple_build_transaction (gimple_seq body
, tree label
)
1104 gimple p
= gimple_alloc (GIMPLE_TRANSACTION
, 0);
1105 gimple_transaction_set_body (p
, body
);
1106 gimple_transaction_set_label (p
, label
);
1110 /* Build a GIMPLE_PREDICT statement. PREDICT is one of the predictors from
1111 predict.def, OUTCOME is NOT_TAKEN or TAKEN. */
1114 gimple_build_predict (enum br_predictor predictor
, enum prediction outcome
)
1116 gimple p
= gimple_alloc (GIMPLE_PREDICT
, 0);
1117 /* Ensure all the predictors fit into the lower bits of the subcode. */
1118 gcc_assert ((int) END_PREDICTORS
<= GF_PREDICT_TAKEN
);
1119 gimple_predict_set_predictor (p
, predictor
);
1120 gimple_predict_set_outcome (p
, outcome
);
1124 #if defined ENABLE_GIMPLE_CHECKING
1125 /* Complain of a gimple type mismatch and die. */
1128 gimple_check_failed (const_gimple gs
, const char *file
, int line
,
1129 const char *function
, enum gimple_code code
,
1130 enum tree_code subcode
)
1132 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1133 gimple_code_name
[code
],
1134 get_tree_code_name (subcode
),
1135 gimple_code_name
[gimple_code (gs
)],
1137 ? get_tree_code_name ((enum tree_code
) gs
->subcode
)
1139 function
, trim_filename (file
), line
);
1141 #endif /* ENABLE_GIMPLE_CHECKING */
1144 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1145 *SEQ_P is NULL, a new sequence is allocated. */
1148 gimple_seq_add_stmt (gimple_seq
*seq_p
, gimple gs
)
1150 gimple_stmt_iterator si
;
1154 si
= gsi_last (*seq_p
);
1155 gsi_insert_after (&si
, gs
, GSI_NEW_STMT
);
1158 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1159 *SEQ_P is NULL, a new sequence is allocated. This function is
1160 similar to gimple_seq_add_stmt, but does not scan the operands.
1161 During gimplification, we need to manipulate statement sequences
1162 before the def/use vectors have been constructed. */
1165 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple gs
)
1167 gimple_stmt_iterator si
;
1172 si
= gsi_last (*seq_p
);
1173 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
1176 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1177 NULL, a new sequence is allocated. */
1180 gimple_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
1182 gimple_stmt_iterator si
;
1186 si
= gsi_last (*dst_p
);
1187 gsi_insert_seq_after (&si
, src
, 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. This function is
1192 similar to gimple_seq_add_seq, but does not scan the operands. */
1195 gimple_seq_add_seq_without_update (gimple_seq
*dst_p
, gimple_seq src
)
1197 gimple_stmt_iterator si
;
1201 si
= gsi_last (*dst_p
);
1202 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
1205 /* Determine whether to assign a location to the statement GS. */
1208 should_carry_location_p (gimple gs
)
1210 /* Don't emit a line note for a label. We particularly don't want to
1211 emit one for the break label, since it doesn't actually correspond
1212 to the beginning of the loop/switch. */
1213 if (gimple_code (gs
) == GIMPLE_LABEL
)
1219 /* Set the location for gimple statement GS to LOCATION. */
1222 annotate_one_with_location (gimple gs
, location_t location
)
1224 if (!gimple_has_location (gs
)
1225 && !gimple_do_not_emit_location_p (gs
)
1226 && should_carry_location_p (gs
))
1227 gimple_set_location (gs
, location
);
1230 /* Set LOCATION for all the statements after iterator GSI in sequence
1231 SEQ. If GSI is pointing to the end of the sequence, start with the
1232 first statement in SEQ. */
1235 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
1236 location_t location
)
1238 if (gsi_end_p (gsi
))
1239 gsi
= gsi_start (seq
);
1243 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
1244 annotate_one_with_location (gsi_stmt (gsi
), location
);
1247 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1250 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
1252 gimple_stmt_iterator i
;
1254 if (gimple_seq_empty_p (stmt_p
))
1257 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
1259 gimple gs
= gsi_stmt (i
);
1260 annotate_one_with_location (gs
, location
);
1264 /* Helper function of empty_body_p. Return true if STMT is an empty
1268 empty_stmt_p (gimple stmt
)
1270 if (gimple_code (stmt
) == GIMPLE_NOP
)
1272 if (gimple_bind bind_stmt
= dyn_cast
<gimple_bind
> (stmt
))
1273 return empty_body_p (gimple_bind_body (bind_stmt
));
1278 /* Return true if BODY contains nothing but empty statements. */
1281 empty_body_p (gimple_seq body
)
1283 gimple_stmt_iterator i
;
1285 if (gimple_seq_empty_p (body
))
1287 for (i
= gsi_start (body
); !gsi_end_p (i
); gsi_next (&i
))
1288 if (!empty_stmt_p (gsi_stmt (i
))
1289 && !is_gimple_debug (gsi_stmt (i
)))
1296 /* Perform a deep copy of sequence SRC and return the result. */
1299 gimple_seq_copy (gimple_seq src
)
1301 gimple_stmt_iterator gsi
;
1302 gimple_seq new_seq
= NULL
;
1305 for (gsi
= gsi_start (src
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1307 stmt
= gimple_copy (gsi_stmt (gsi
));
1308 gimple_seq_add_stmt (&new_seq
, stmt
);
1316 /* Return true if calls C1 and C2 are known to go to the same function. */
1319 gimple_call_same_target_p (const_gimple c1
, const_gimple c2
)
1321 if (gimple_call_internal_p (c1
))
1322 return (gimple_call_internal_p (c2
)
1323 && gimple_call_internal_fn (c1
) == gimple_call_internal_fn (c2
));
1325 return (gimple_call_fn (c1
) == gimple_call_fn (c2
)
1326 || (gimple_call_fndecl (c1
)
1327 && gimple_call_fndecl (c1
) == gimple_call_fndecl (c2
)));
1330 /* Detect flags from a GIMPLE_CALL. This is just like
1331 call_expr_flags, but for gimple tuples. */
1334 gimple_call_flags (const_gimple stmt
)
1337 tree decl
= gimple_call_fndecl (stmt
);
1340 flags
= flags_from_decl_or_type (decl
);
1341 else if (gimple_call_internal_p (stmt
))
1342 flags
= internal_fn_flags (gimple_call_internal_fn (stmt
));
1344 flags
= flags_from_decl_or_type (gimple_call_fntype (stmt
));
1346 if (stmt
->subcode
& GF_CALL_NOTHROW
)
1347 flags
|= ECF_NOTHROW
;
1352 /* Return the "fn spec" string for call STMT. */
1355 gimple_call_fnspec (const_gimple stmt
)
1359 if (gimple_call_internal_p (stmt
))
1360 return internal_fn_fnspec (gimple_call_internal_fn (stmt
));
1362 type
= gimple_call_fntype (stmt
);
1366 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
1370 return TREE_VALUE (TREE_VALUE (attr
));
1373 /* Detects argument flags for argument number ARG on call STMT. */
1376 gimple_call_arg_flags (const_gimple stmt
, unsigned arg
)
1378 const_tree attr
= gimple_call_fnspec (stmt
);
1380 if (!attr
|| 1 + arg
>= (unsigned) TREE_STRING_LENGTH (attr
))
1383 switch (TREE_STRING_POINTER (attr
)[1 + arg
])
1390 return EAF_DIRECT
| EAF_NOCLOBBER
| EAF_NOESCAPE
;
1393 return EAF_NOCLOBBER
| EAF_NOESCAPE
;
1396 return EAF_DIRECT
| EAF_NOESCAPE
;
1399 return EAF_NOESCAPE
;
1407 /* Detects return flags for the call STMT. */
1410 gimple_call_return_flags (const_gimple_call stmt
)
1414 if (gimple_call_flags (stmt
) & ECF_MALLOC
)
1417 attr
= gimple_call_fnspec (stmt
);
1418 if (!attr
|| TREE_STRING_LENGTH (attr
) < 1)
1421 switch (TREE_STRING_POINTER (attr
)[0])
1427 return ERF_RETURNS_ARG
| (TREE_STRING_POINTER (attr
)[0] - '1');
1439 /* Return true if GS is a copy assignment. */
1442 gimple_assign_copy_p (gimple gs
)
1444 return (gimple_assign_single_p (gs
)
1445 && is_gimple_val (gimple_op (gs
, 1)));
1449 /* Return true if GS is a SSA_NAME copy assignment. */
1452 gimple_assign_ssa_name_copy_p (gimple gs
)
1454 return (gimple_assign_single_p (gs
)
1455 && TREE_CODE (gimple_assign_lhs (gs
)) == SSA_NAME
1456 && TREE_CODE (gimple_assign_rhs1 (gs
)) == SSA_NAME
);
1460 /* Return true if GS is an assignment with a unary RHS, but the
1461 operator has no effect on the assigned value. The logic is adapted
1462 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1463 instances in which STRIP_NOPS was previously applied to the RHS of
1466 NOTE: In the use cases that led to the creation of this function
1467 and of gimple_assign_single_p, it is typical to test for either
1468 condition and to proceed in the same manner. In each case, the
1469 assigned value is represented by the single RHS operand of the
1470 assignment. I suspect there may be cases where gimple_assign_copy_p,
1471 gimple_assign_single_p, or equivalent logic is used where a similar
1472 treatment of unary NOPs is appropriate. */
1475 gimple_assign_unary_nop_p (gimple gs
)
1477 return (is_gimple_assign (gs
)
1478 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs
))
1479 || gimple_assign_rhs_code (gs
) == NON_LVALUE_EXPR
)
1480 && gimple_assign_rhs1 (gs
) != error_mark_node
1481 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs
)))
1482 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs
)))));
1485 /* Set BB to be the basic block holding G. */
1488 gimple_set_bb (gimple stmt
, basic_block bb
)
1492 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1495 /* If the statement is a label, add the label to block-to-labels map
1496 so that we can speed up edge creation for GIMPLE_GOTOs. */
1502 t
= gimple_label_label (stmt
);
1503 uid
= LABEL_DECL_UID (t
);
1507 vec_safe_length (label_to_block_map_for_fn (cfun
));
1508 LABEL_DECL_UID (t
) = uid
= cfun
->cfg
->last_label_uid
++;
1509 if (old_len
<= (unsigned) uid
)
1511 unsigned new_len
= 3 * uid
/ 2 + 1;
1513 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun
),
1518 (*label_to_block_map_for_fn (cfun
))[uid
] = bb
;
1523 /* Modify the RHS of the assignment pointed-to by GSI using the
1524 operands in the expression tree EXPR.
1526 NOTE: The statement pointed-to by GSI may be reallocated if it
1527 did not have enough operand slots.
1529 This function is useful to convert an existing tree expression into
1530 the flat representation used for the RHS of a GIMPLE assignment.
1531 It will reallocate memory as needed to expand or shrink the number
1532 of operand slots needed to represent EXPR.
1534 NOTE: If you find yourself building a tree and then calling this
1535 function, you are most certainly doing it the slow way. It is much
1536 better to build a new assignment or to use the function
1537 gimple_assign_set_rhs_with_ops, which does not require an
1538 expression tree to be built. */
1541 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*gsi
, tree expr
)
1543 enum tree_code subcode
;
1546 extract_ops_from_tree_1 (expr
, &subcode
, &op1
, &op2
, &op3
);
1547 gimple_assign_set_rhs_with_ops_1 (gsi
, subcode
, op1
, op2
, op3
);
1551 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1552 operands OP1, OP2 and OP3.
1554 NOTE: The statement pointed-to by GSI may be reallocated if it
1555 did not have enough operand slots. */
1558 gimple_assign_set_rhs_with_ops_1 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
1559 tree op1
, tree op2
, tree op3
)
1561 unsigned new_rhs_ops
= get_gimple_rhs_num_ops (code
);
1562 gimple stmt
= gsi_stmt (*gsi
);
1564 /* If the new CODE needs more operands, allocate a new statement. */
1565 if (gimple_num_ops (stmt
) < new_rhs_ops
+ 1)
1567 tree lhs
= gimple_assign_lhs (stmt
);
1568 gimple new_stmt
= gimple_alloc (gimple_code (stmt
), new_rhs_ops
+ 1);
1569 memcpy (new_stmt
, stmt
, gimple_size (gimple_code (stmt
)));
1570 gimple_init_singleton (new_stmt
);
1571 gsi_replace (gsi
, new_stmt
, true);
1574 /* The LHS needs to be reset as this also changes the SSA name
1576 gimple_assign_set_lhs (stmt
, lhs
);
1579 gimple_set_num_ops (stmt
, new_rhs_ops
+ 1);
1580 gimple_set_subcode (stmt
, code
);
1581 gimple_assign_set_rhs1 (stmt
, op1
);
1582 if (new_rhs_ops
> 1)
1583 gimple_assign_set_rhs2 (stmt
, op2
);
1584 if (new_rhs_ops
> 2)
1585 gimple_assign_set_rhs3 (stmt
, op3
);
1589 /* Return the LHS of a statement that performs an assignment,
1590 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1591 for a call to a function that returns no value, or for a
1592 statement other than an assignment or a call. */
1595 gimple_get_lhs (const_gimple stmt
)
1597 enum gimple_code code
= gimple_code (stmt
);
1599 if (code
== GIMPLE_ASSIGN
)
1600 return gimple_assign_lhs (stmt
);
1601 else if (code
== GIMPLE_CALL
)
1602 return gimple_call_lhs (stmt
);
1608 /* Set the LHS of a statement that performs an assignment,
1609 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1612 gimple_set_lhs (gimple stmt
, tree lhs
)
1614 enum gimple_code code
= gimple_code (stmt
);
1616 if (code
== GIMPLE_ASSIGN
)
1617 gimple_assign_set_lhs (stmt
, lhs
);
1618 else if (code
== GIMPLE_CALL
)
1619 gimple_call_set_lhs (stmt
, lhs
);
1625 /* Return a deep copy of statement STMT. All the operands from STMT
1626 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1627 and VUSE operand arrays are set to empty in the new copy. The new
1628 copy isn't part of any sequence. */
1631 gimple_copy (gimple stmt
)
1633 enum gimple_code code
= gimple_code (stmt
);
1634 unsigned num_ops
= gimple_num_ops (stmt
);
1635 gimple copy
= gimple_alloc (code
, num_ops
);
1638 /* Shallow copy all the fields from STMT. */
1639 memcpy (copy
, stmt
, gimple_size (code
));
1640 gimple_init_singleton (copy
);
1642 /* If STMT has sub-statements, deep-copy them as well. */
1643 if (gimple_has_substatements (stmt
))
1648 switch (gimple_code (stmt
))
1652 gimple_bind bind_stmt
= as_a
<gimple_bind
> (stmt
);
1653 gimple_bind bind_copy
= as_a
<gimple_bind
> (copy
);
1654 new_seq
= gimple_seq_copy (gimple_bind_body (bind_stmt
));
1655 gimple_bind_set_body (bind_copy
, new_seq
);
1656 gimple_bind_set_vars (bind_copy
,
1657 unshare_expr (gimple_bind_vars (bind_stmt
)));
1658 gimple_bind_set_block (bind_copy
, gimple_bind_block (bind_stmt
));
1663 new_seq
= gimple_seq_copy (gimple_catch_handler (stmt
));
1664 gimple_catch_set_handler (copy
, new_seq
);
1665 t
= unshare_expr (gimple_catch_types (stmt
));
1666 gimple_catch_set_types (copy
, t
);
1669 case GIMPLE_EH_FILTER
:
1670 new_seq
= gimple_seq_copy (gimple_eh_filter_failure (stmt
));
1671 gimple_eh_filter_set_failure (copy
, new_seq
);
1672 t
= unshare_expr (gimple_eh_filter_types (stmt
));
1673 gimple_eh_filter_set_types (copy
, t
);
1676 case GIMPLE_EH_ELSE
:
1677 new_seq
= gimple_seq_copy (gimple_eh_else_n_body (stmt
));
1678 gimple_eh_else_set_n_body (copy
, new_seq
);
1679 new_seq
= gimple_seq_copy (gimple_eh_else_e_body (stmt
));
1680 gimple_eh_else_set_e_body (copy
, new_seq
);
1684 new_seq
= gimple_seq_copy (gimple_try_eval (stmt
));
1685 gimple_try_set_eval (copy
, new_seq
);
1686 new_seq
= gimple_seq_copy (gimple_try_cleanup (stmt
));
1687 gimple_try_set_cleanup (copy
, new_seq
);
1690 case GIMPLE_OMP_FOR
:
1691 new_seq
= gimple_seq_copy (gimple_omp_for_pre_body (stmt
));
1692 gimple_omp_for_set_pre_body (copy
, new_seq
);
1693 t
= unshare_expr (gimple_omp_for_clauses (stmt
));
1694 gimple_omp_for_set_clauses (copy
, t
);
1696 gimple_statement_omp_for
*omp_for_copy
=
1697 as_a
<gimple_statement_omp_for
*> (copy
);
1698 omp_for_copy
->iter
= ggc_vec_alloc
<gimple_omp_for_iter
>
1699 ( gimple_omp_for_collapse (stmt
));
1701 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1703 gimple_omp_for_set_cond (copy
, i
,
1704 gimple_omp_for_cond (stmt
, i
));
1705 gimple_omp_for_set_index (copy
, i
,
1706 gimple_omp_for_index (stmt
, i
));
1707 t
= unshare_expr (gimple_omp_for_initial (stmt
, i
));
1708 gimple_omp_for_set_initial (copy
, i
, t
);
1709 t
= unshare_expr (gimple_omp_for_final (stmt
, i
));
1710 gimple_omp_for_set_final (copy
, i
, t
);
1711 t
= unshare_expr (gimple_omp_for_incr (stmt
, i
));
1712 gimple_omp_for_set_incr (copy
, i
, t
);
1716 case GIMPLE_OMP_PARALLEL
:
1717 t
= unshare_expr (gimple_omp_parallel_clauses (stmt
));
1718 gimple_omp_parallel_set_clauses (copy
, t
);
1719 t
= unshare_expr (gimple_omp_parallel_child_fn (stmt
));
1720 gimple_omp_parallel_set_child_fn (copy
, t
);
1721 t
= unshare_expr (gimple_omp_parallel_data_arg (stmt
));
1722 gimple_omp_parallel_set_data_arg (copy
, t
);
1725 case GIMPLE_OMP_TASK
:
1726 t
= unshare_expr (gimple_omp_task_clauses (stmt
));
1727 gimple_omp_task_set_clauses (copy
, t
);
1728 t
= unshare_expr (gimple_omp_task_child_fn (stmt
));
1729 gimple_omp_task_set_child_fn (copy
, t
);
1730 t
= unshare_expr (gimple_omp_task_data_arg (stmt
));
1731 gimple_omp_task_set_data_arg (copy
, t
);
1732 t
= unshare_expr (gimple_omp_task_copy_fn (stmt
));
1733 gimple_omp_task_set_copy_fn (copy
, t
);
1734 t
= unshare_expr (gimple_omp_task_arg_size (stmt
));
1735 gimple_omp_task_set_arg_size (copy
, t
);
1736 t
= unshare_expr (gimple_omp_task_arg_align (stmt
));
1737 gimple_omp_task_set_arg_align (copy
, t
);
1740 case GIMPLE_OMP_CRITICAL
:
1741 t
= unshare_expr (gimple_omp_critical_name (stmt
));
1742 gimple_omp_critical_set_name (copy
, t
);
1745 case GIMPLE_OMP_SECTIONS
:
1746 t
= unshare_expr (gimple_omp_sections_clauses (stmt
));
1747 gimple_omp_sections_set_clauses (copy
, t
);
1748 t
= unshare_expr (gimple_omp_sections_control (stmt
));
1749 gimple_omp_sections_set_control (copy
, t
);
1752 case GIMPLE_OMP_SINGLE
:
1753 case GIMPLE_OMP_TARGET
:
1754 case GIMPLE_OMP_TEAMS
:
1755 case GIMPLE_OMP_SECTION
:
1756 case GIMPLE_OMP_MASTER
:
1757 case GIMPLE_OMP_TASKGROUP
:
1758 case GIMPLE_OMP_ORDERED
:
1760 new_seq
= gimple_seq_copy (gimple_omp_body (stmt
));
1761 gimple_omp_set_body (copy
, new_seq
);
1764 case GIMPLE_TRANSACTION
:
1765 new_seq
= gimple_seq_copy (gimple_transaction_body (stmt
));
1766 gimple_transaction_set_body (copy
, new_seq
);
1769 case GIMPLE_WITH_CLEANUP_EXPR
:
1770 new_seq
= gimple_seq_copy (gimple_wce_cleanup (stmt
));
1771 gimple_wce_set_cleanup (copy
, new_seq
);
1779 /* Make copy of operands. */
1780 for (i
= 0; i
< num_ops
; i
++)
1781 gimple_set_op (copy
, i
, unshare_expr (gimple_op (stmt
, i
)));
1783 if (gimple_has_mem_ops (stmt
))
1785 gimple_set_vdef (copy
, gimple_vdef (stmt
));
1786 gimple_set_vuse (copy
, gimple_vuse (stmt
));
1789 /* Clear out SSA operand vectors on COPY. */
1790 if (gimple_has_ops (stmt
))
1792 gimple_set_use_ops (copy
, NULL
);
1794 /* SSA operands need to be updated. */
1795 gimple_set_modified (copy
, true);
1802 /* Return true if statement S has side-effects. We consider a
1803 statement to have side effects if:
1805 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
1806 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
1809 gimple_has_side_effects (const_gimple s
)
1811 if (is_gimple_debug (s
))
1814 /* We don't have to scan the arguments to check for
1815 volatile arguments, though, at present, we still
1816 do a scan to check for TREE_SIDE_EFFECTS. */
1817 if (gimple_has_volatile_ops (s
))
1820 if (gimple_code (s
) == GIMPLE_ASM
1821 && gimple_asm_volatile_p (s
))
1824 if (is_gimple_call (s
))
1826 int flags
= gimple_call_flags (s
);
1828 /* An infinite loop is considered a side effect. */
1829 if (!(flags
& (ECF_CONST
| ECF_PURE
))
1830 || (flags
& ECF_LOOPING_CONST_OR_PURE
))
1839 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
1840 Return true if S can trap. When INCLUDE_MEM is true, check whether
1841 the memory operations could trap. When INCLUDE_STORES is true and
1842 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
1845 gimple_could_trap_p_1 (gimple s
, bool include_mem
, bool include_stores
)
1847 tree t
, div
= NULL_TREE
;
1852 unsigned i
, start
= (is_gimple_assign (s
) && !include_stores
) ? 1 : 0;
1854 for (i
= start
; i
< gimple_num_ops (s
); i
++)
1855 if (tree_could_trap_p (gimple_op (s
, i
)))
1859 switch (gimple_code (s
))
1862 return gimple_asm_volatile_p (s
);
1865 t
= gimple_call_fndecl (s
);
1866 /* Assume that calls to weak functions may trap. */
1867 if (!t
|| !DECL_P (t
) || DECL_WEAK (t
))
1872 t
= gimple_expr_type (s
);
1873 op
= gimple_assign_rhs_code (s
);
1874 if (get_gimple_rhs_class (op
) == GIMPLE_BINARY_RHS
)
1875 div
= gimple_assign_rhs2 (s
);
1876 return (operation_could_trap_p (op
, FLOAT_TYPE_P (t
),
1877 (INTEGRAL_TYPE_P (t
)
1878 && TYPE_OVERFLOW_TRAPS (t
)),
1888 /* Return true if statement S can trap. */
1891 gimple_could_trap_p (gimple s
)
1893 return gimple_could_trap_p_1 (s
, true, true);
1896 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
1899 gimple_assign_rhs_could_trap_p (gimple s
)
1901 gcc_assert (is_gimple_assign (s
));
1902 return gimple_could_trap_p_1 (s
, true, false);
1906 /* Print debugging information for gimple stmts generated. */
1909 dump_gimple_statistics (void)
1911 int i
, total_tuples
= 0, total_bytes
= 0;
1913 if (! GATHER_STATISTICS
)
1915 fprintf (stderr
, "No gimple statistics\n");
1919 fprintf (stderr
, "\nGIMPLE statements\n");
1920 fprintf (stderr
, "Kind Stmts Bytes\n");
1921 fprintf (stderr
, "---------------------------------------\n");
1922 for (i
= 0; i
< (int) gimple_alloc_kind_all
; ++i
)
1924 fprintf (stderr
, "%-20s %7d %10d\n", gimple_alloc_kind_names
[i
],
1925 gimple_alloc_counts
[i
], gimple_alloc_sizes
[i
]);
1926 total_tuples
+= gimple_alloc_counts
[i
];
1927 total_bytes
+= gimple_alloc_sizes
[i
];
1929 fprintf (stderr
, "---------------------------------------\n");
1930 fprintf (stderr
, "%-20s %7d %10d\n", "Total", total_tuples
, total_bytes
);
1931 fprintf (stderr
, "---------------------------------------\n");
1935 /* Return the number of operands needed on the RHS of a GIMPLE
1936 assignment for an expression with tree code CODE. */
1939 get_gimple_rhs_num_ops (enum tree_code code
)
1941 enum gimple_rhs_class rhs_class
= get_gimple_rhs_class (code
);
1943 if (rhs_class
== GIMPLE_UNARY_RHS
|| rhs_class
== GIMPLE_SINGLE_RHS
)
1945 else if (rhs_class
== GIMPLE_BINARY_RHS
)
1947 else if (rhs_class
== GIMPLE_TERNARY_RHS
)
1953 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
1955 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
1956 : ((TYPE) == tcc_binary \
1957 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
1958 : ((TYPE) == tcc_constant \
1959 || (TYPE) == tcc_declaration \
1960 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
1961 : ((SYM) == TRUTH_AND_EXPR \
1962 || (SYM) == TRUTH_OR_EXPR \
1963 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
1964 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
1965 : ((SYM) == COND_EXPR \
1966 || (SYM) == WIDEN_MULT_PLUS_EXPR \
1967 || (SYM) == WIDEN_MULT_MINUS_EXPR \
1968 || (SYM) == DOT_PROD_EXPR \
1969 || (SYM) == SAD_EXPR \
1970 || (SYM) == REALIGN_LOAD_EXPR \
1971 || (SYM) == VEC_COND_EXPR \
1972 || (SYM) == VEC_PERM_EXPR \
1973 || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS \
1974 : ((SYM) == CONSTRUCTOR \
1975 || (SYM) == OBJ_TYPE_REF \
1976 || (SYM) == ASSERT_EXPR \
1977 || (SYM) == ADDR_EXPR \
1978 || (SYM) == WITH_SIZE_EXPR \
1979 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
1980 : GIMPLE_INVALID_RHS),
1981 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
1983 const unsigned char gimple_rhs_class_table
[] = {
1984 #include "all-tree.def"
1988 #undef END_OF_BASE_TREE_CODES
1990 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
1991 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
1992 we failed to create one. */
1995 canonicalize_cond_expr_cond (tree t
)
1997 /* Strip conversions around boolean operations. */
1998 if (CONVERT_EXPR_P (t
)
1999 && (truth_value_p (TREE_CODE (TREE_OPERAND (t
, 0)))
2000 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
2002 t
= TREE_OPERAND (t
, 0);
2004 /* For !x use x == 0. */
2005 if (TREE_CODE (t
) == TRUTH_NOT_EXPR
)
2007 tree top0
= TREE_OPERAND (t
, 0);
2008 t
= build2 (EQ_EXPR
, TREE_TYPE (t
),
2009 top0
, build_int_cst (TREE_TYPE (top0
), 0));
2011 /* For cmp ? 1 : 0 use cmp. */
2012 else if (TREE_CODE (t
) == COND_EXPR
2013 && COMPARISON_CLASS_P (TREE_OPERAND (t
, 0))
2014 && integer_onep (TREE_OPERAND (t
, 1))
2015 && integer_zerop (TREE_OPERAND (t
, 2)))
2017 tree top0
= TREE_OPERAND (t
, 0);
2018 t
= build2 (TREE_CODE (top0
), TREE_TYPE (t
),
2019 TREE_OPERAND (top0
, 0), TREE_OPERAND (top0
, 1));
2021 /* For x ^ y use x != y. */
2022 else if (TREE_CODE (t
) == BIT_XOR_EXPR
)
2023 t
= build2 (NE_EXPR
, TREE_TYPE (t
),
2024 TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1));
2026 if (is_gimple_condexpr (t
))
2032 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2033 the positions marked by the set ARGS_TO_SKIP. */
2036 gimple_call_copy_skip_args (gimple stmt
, bitmap args_to_skip
)
2039 int nargs
= gimple_call_num_args (stmt
);
2040 auto_vec
<tree
> vargs (nargs
);
2041 gimple_call new_stmt
;
2043 for (i
= 0; i
< nargs
; i
++)
2044 if (!bitmap_bit_p (args_to_skip
, i
))
2045 vargs
.quick_push (gimple_call_arg (stmt
, i
));
2047 if (gimple_call_internal_p (stmt
))
2048 new_stmt
= gimple_build_call_internal_vec (gimple_call_internal_fn (stmt
),
2051 new_stmt
= gimple_build_call_vec (gimple_call_fn (stmt
), vargs
);
2053 if (gimple_call_lhs (stmt
))
2054 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2056 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2057 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
2059 if (gimple_has_location (stmt
))
2060 gimple_set_location (new_stmt
, gimple_location (stmt
));
2061 gimple_call_copy_flags (new_stmt
, stmt
);
2062 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2064 gimple_set_modified (new_stmt
, true);
2071 /* Return true if the field decls F1 and F2 are at the same offset.
2073 This is intended to be used on GIMPLE types only. */
2076 gimple_compare_field_offset (tree f1
, tree f2
)
2078 if (DECL_OFFSET_ALIGN (f1
) == DECL_OFFSET_ALIGN (f2
))
2080 tree offset1
= DECL_FIELD_OFFSET (f1
);
2081 tree offset2
= DECL_FIELD_OFFSET (f2
);
2082 return ((offset1
== offset2
2083 /* Once gimplification is done, self-referential offsets are
2084 instantiated as operand #2 of the COMPONENT_REF built for
2085 each access and reset. Therefore, they are not relevant
2086 anymore and fields are interchangeable provided that they
2087 represent the same access. */
2088 || (TREE_CODE (offset1
) == PLACEHOLDER_EXPR
2089 && TREE_CODE (offset2
) == PLACEHOLDER_EXPR
2090 && (DECL_SIZE (f1
) == DECL_SIZE (f2
)
2091 || (TREE_CODE (DECL_SIZE (f1
)) == PLACEHOLDER_EXPR
2092 && TREE_CODE (DECL_SIZE (f2
)) == PLACEHOLDER_EXPR
)
2093 || operand_equal_p (DECL_SIZE (f1
), DECL_SIZE (f2
), 0))
2094 && DECL_ALIGN (f1
) == DECL_ALIGN (f2
))
2095 || operand_equal_p (offset1
, offset2
, 0))
2096 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1
),
2097 DECL_FIELD_BIT_OFFSET (f2
)));
2100 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2101 should be, so handle differing ones specially by decomposing
2102 the offset into a byte and bit offset manually. */
2103 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1
))
2104 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2
)))
2106 unsigned HOST_WIDE_INT byte_offset1
, byte_offset2
;
2107 unsigned HOST_WIDE_INT bit_offset1
, bit_offset2
;
2108 bit_offset1
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1
));
2109 byte_offset1
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1
))
2110 + bit_offset1
/ BITS_PER_UNIT
);
2111 bit_offset2
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2
));
2112 byte_offset2
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2
))
2113 + bit_offset2
/ BITS_PER_UNIT
);
2114 if (byte_offset1
!= byte_offset2
)
2116 return bit_offset1
% BITS_PER_UNIT
== bit_offset2
% BITS_PER_UNIT
;
2123 /* Return a type the same as TYPE except unsigned or
2124 signed according to UNSIGNEDP. */
2127 gimple_signed_or_unsigned_type (bool unsignedp
, tree type
)
2131 type1
= TYPE_MAIN_VARIANT (type
);
2132 if (type1
== signed_char_type_node
2133 || type1
== char_type_node
2134 || type1
== unsigned_char_type_node
)
2135 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2136 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2137 return unsignedp
? unsigned_type_node
: integer_type_node
;
2138 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2139 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2140 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2141 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2142 if (type1
== long_long_integer_type_node
2143 || type1
== long_long_unsigned_type_node
)
2145 ? long_long_unsigned_type_node
2146 : long_long_integer_type_node
;
2147 if (int128_integer_type_node
&& (type1
== int128_integer_type_node
|| type1
== int128_unsigned_type_node
))
2149 ? int128_unsigned_type_node
2150 : int128_integer_type_node
;
2151 #if HOST_BITS_PER_WIDE_INT >= 64
2152 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2153 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2155 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2156 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2157 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2158 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2159 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2160 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2161 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2162 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2164 #define GIMPLE_FIXED_TYPES(NAME) \
2165 if (type1 == short_ ## NAME ## _type_node \
2166 || type1 == unsigned_short_ ## NAME ## _type_node) \
2167 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2168 : short_ ## NAME ## _type_node; \
2169 if (type1 == NAME ## _type_node \
2170 || type1 == unsigned_ ## NAME ## _type_node) \
2171 return unsignedp ? unsigned_ ## NAME ## _type_node \
2172 : NAME ## _type_node; \
2173 if (type1 == long_ ## NAME ## _type_node \
2174 || type1 == unsigned_long_ ## NAME ## _type_node) \
2175 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2176 : long_ ## NAME ## _type_node; \
2177 if (type1 == long_long_ ## NAME ## _type_node \
2178 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2179 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2180 : long_long_ ## NAME ## _type_node;
2182 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2183 if (type1 == NAME ## _type_node \
2184 || type1 == u ## NAME ## _type_node) \
2185 return unsignedp ? u ## NAME ## _type_node \
2186 : NAME ## _type_node;
2188 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2189 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2190 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2191 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2192 : sat_ ## short_ ## NAME ## _type_node; \
2193 if (type1 == sat_ ## NAME ## _type_node \
2194 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2195 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2196 : sat_ ## NAME ## _type_node; \
2197 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2198 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2199 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2200 : sat_ ## long_ ## NAME ## _type_node; \
2201 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2202 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2203 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2204 : sat_ ## long_long_ ## NAME ## _type_node;
2206 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2207 if (type1 == sat_ ## NAME ## _type_node \
2208 || type1 == sat_ ## u ## NAME ## _type_node) \
2209 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2210 : sat_ ## NAME ## _type_node;
2212 GIMPLE_FIXED_TYPES (fract
);
2213 GIMPLE_FIXED_TYPES_SAT (fract
);
2214 GIMPLE_FIXED_TYPES (accum
);
2215 GIMPLE_FIXED_TYPES_SAT (accum
);
2217 GIMPLE_FIXED_MODE_TYPES (qq
);
2218 GIMPLE_FIXED_MODE_TYPES (hq
);
2219 GIMPLE_FIXED_MODE_TYPES (sq
);
2220 GIMPLE_FIXED_MODE_TYPES (dq
);
2221 GIMPLE_FIXED_MODE_TYPES (tq
);
2222 GIMPLE_FIXED_MODE_TYPES_SAT (qq
);
2223 GIMPLE_FIXED_MODE_TYPES_SAT (hq
);
2224 GIMPLE_FIXED_MODE_TYPES_SAT (sq
);
2225 GIMPLE_FIXED_MODE_TYPES_SAT (dq
);
2226 GIMPLE_FIXED_MODE_TYPES_SAT (tq
);
2227 GIMPLE_FIXED_MODE_TYPES (ha
);
2228 GIMPLE_FIXED_MODE_TYPES (sa
);
2229 GIMPLE_FIXED_MODE_TYPES (da
);
2230 GIMPLE_FIXED_MODE_TYPES (ta
);
2231 GIMPLE_FIXED_MODE_TYPES_SAT (ha
);
2232 GIMPLE_FIXED_MODE_TYPES_SAT (sa
);
2233 GIMPLE_FIXED_MODE_TYPES_SAT (da
);
2234 GIMPLE_FIXED_MODE_TYPES_SAT (ta
);
2236 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2237 the precision; they have precision set to match their range, but
2238 may use a wider mode to match an ABI. If we change modes, we may
2239 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2240 the precision as well, so as to yield correct results for
2241 bit-field types. C++ does not have these separate bit-field
2242 types, and producing a signed or unsigned variant of an
2243 ENUMERAL_TYPE may cause other problems as well. */
2244 if (!INTEGRAL_TYPE_P (type
)
2245 || TYPE_UNSIGNED (type
) == unsignedp
)
2248 #define TYPE_OK(node) \
2249 (TYPE_MODE (type) == TYPE_MODE (node) \
2250 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2251 if (TYPE_OK (signed_char_type_node
))
2252 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2253 if (TYPE_OK (integer_type_node
))
2254 return unsignedp
? unsigned_type_node
: integer_type_node
;
2255 if (TYPE_OK (short_integer_type_node
))
2256 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2257 if (TYPE_OK (long_integer_type_node
))
2258 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2259 if (TYPE_OK (long_long_integer_type_node
))
2261 ? long_long_unsigned_type_node
2262 : long_long_integer_type_node
);
2263 if (int128_integer_type_node
&& TYPE_OK (int128_integer_type_node
))
2265 ? int128_unsigned_type_node
2266 : int128_integer_type_node
);
2268 #if HOST_BITS_PER_WIDE_INT >= 64
2269 if (TYPE_OK (intTI_type_node
))
2270 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2272 if (TYPE_OK (intDI_type_node
))
2273 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2274 if (TYPE_OK (intSI_type_node
))
2275 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2276 if (TYPE_OK (intHI_type_node
))
2277 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2278 if (TYPE_OK (intQI_type_node
))
2279 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2281 #undef GIMPLE_FIXED_TYPES
2282 #undef GIMPLE_FIXED_MODE_TYPES
2283 #undef GIMPLE_FIXED_TYPES_SAT
2284 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2287 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2291 /* Return an unsigned type the same as TYPE in other respects. */
2294 gimple_unsigned_type (tree type
)
2296 return gimple_signed_or_unsigned_type (true, type
);
2300 /* Return a signed type the same as TYPE in other respects. */
2303 gimple_signed_type (tree type
)
2305 return gimple_signed_or_unsigned_type (false, type
);
2309 /* Return the typed-based alias set for T, which may be an expression
2310 or a type. Return -1 if we don't do anything special. */
2313 gimple_get_alias_set (tree t
)
2317 /* Permit type-punning when accessing a union, provided the access
2318 is directly through the union. For example, this code does not
2319 permit taking the address of a union member and then storing
2320 through it. Even the type-punning allowed here is a GCC
2321 extension, albeit a common and useful one; the C standard says
2322 that such accesses have implementation-defined behavior. */
2324 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2325 u
= TREE_OPERAND (u
, 0))
2326 if (TREE_CODE (u
) == COMPONENT_REF
2327 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2330 /* That's all the expressions we handle specially. */
2334 /* For convenience, follow the C standard when dealing with
2335 character types. Any object may be accessed via an lvalue that
2336 has character type. */
2337 if (t
== char_type_node
2338 || t
== signed_char_type_node
2339 || t
== unsigned_char_type_node
)
2342 /* Allow aliasing between signed and unsigned variants of the same
2343 type. We treat the signed variant as canonical. */
2344 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2346 tree t1
= gimple_signed_type (t
);
2348 /* t1 == t can happen for boolean nodes which are always unsigned. */
2350 return get_alias_set (t1
);
2357 /* Helper for gimple_ior_addresses_taken_1. */
2360 gimple_ior_addresses_taken_1 (gimple
, tree addr
, tree
, void *data
)
2362 bitmap addresses_taken
= (bitmap
)data
;
2363 addr
= get_base_address (addr
);
2367 bitmap_set_bit (addresses_taken
, DECL_UID (addr
));
2373 /* Set the bit for the uid of all decls that have their address taken
2374 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2375 were any in this stmt. */
2378 gimple_ior_addresses_taken (bitmap addresses_taken
, gimple stmt
)
2380 return walk_stmt_load_store_addr_ops (stmt
, addresses_taken
, NULL
, NULL
,
2381 gimple_ior_addresses_taken_1
);
2385 /* Return true if TYPE1 and TYPE2 are compatible enough for builtin
2389 validate_type (tree type1
, tree type2
)
2391 if (INTEGRAL_TYPE_P (type1
)
2392 && INTEGRAL_TYPE_P (type2
))
2394 else if (POINTER_TYPE_P (type1
)
2395 && POINTER_TYPE_P (type2
))
2397 else if (TREE_CODE (type1
)
2398 != TREE_CODE (type2
))
2403 /* Return true when STMTs arguments and return value match those of FNDECL,
2404 a decl of a builtin function. */
2407 gimple_builtin_call_types_compatible_p (const_gimple stmt
, tree fndecl
)
2409 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
);
2411 tree ret
= gimple_call_lhs (stmt
);
2413 && !validate_type (TREE_TYPE (ret
), TREE_TYPE (TREE_TYPE (fndecl
))))
2416 tree targs
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2417 unsigned nargs
= gimple_call_num_args (stmt
);
2418 for (unsigned i
= 0; i
< nargs
; ++i
)
2420 /* Variadic args follow. */
2423 tree arg
= gimple_call_arg (stmt
, i
);
2424 if (!validate_type (TREE_TYPE (arg
), TREE_VALUE (targs
)))
2426 targs
= TREE_CHAIN (targs
);
2428 if (targs
&& !VOID_TYPE_P (TREE_VALUE (targs
)))
2433 /* Return true when STMT is builtins call. */
2436 gimple_call_builtin_p (const_gimple stmt
)
2439 if (is_gimple_call (stmt
)
2440 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2441 && DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
)
2442 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2446 /* Return true when STMT is builtins call to CLASS. */
2449 gimple_call_builtin_p (const_gimple stmt
, enum built_in_class klass
)
2452 if (is_gimple_call (stmt
)
2453 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2454 && DECL_BUILT_IN_CLASS (fndecl
) == klass
)
2455 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2459 /* Return true when STMT is builtins call to CODE of CLASS. */
2462 gimple_call_builtin_p (const_gimple stmt
, enum built_in_function code
)
2465 if (is_gimple_call (stmt
)
2466 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2467 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
2468 && DECL_FUNCTION_CODE (fndecl
) == code
)
2469 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2473 /* Return true if STMT clobbers memory. STMT is required to be a
2477 gimple_asm_clobbers_memory_p (const_gimple stmt
)
2481 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
2483 tree op
= gimple_asm_clobber_op (stmt
, i
);
2484 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op
)), "memory") == 0)
2491 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2494 dump_decl_set (FILE *file
, bitmap set
)
2501 fprintf (file
, "{ ");
2503 EXECUTE_IF_SET_IN_BITMAP (set
, 0, i
, bi
)
2505 fprintf (file
, "D.%u", i
);
2506 fprintf (file
, " ");
2509 fprintf (file
, "}");
2512 fprintf (file
, "NIL");
2515 /* Return true when CALL is a call stmt that definitely doesn't
2516 free any memory or makes it unavailable otherwise. */
2518 nonfreeing_call_p (gimple call
)
2520 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2521 && gimple_call_flags (call
) & ECF_LEAF
)
2522 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call
)))
2524 /* Just in case these become ECF_LEAF in the future. */
2526 case BUILT_IN_TM_FREE
:
2527 case BUILT_IN_REALLOC
:
2528 case BUILT_IN_STACK_RESTORE
:
2537 /* Callback for walk_stmt_load_store_ops.
2539 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2542 This routine only makes a superficial check for a dereference. Thus
2543 it must only be used if it is safe to return a false negative. */
2545 check_loadstore (gimple
, tree op
, tree
, void *data
)
2547 if ((TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
2548 && operand_equal_p (TREE_OPERAND (op
, 0), (tree
)data
, 0))
2553 /* If OP can be inferred to be non-NULL after STMT executes, return true.
2555 DEREFERENCE is TRUE if we can use a pointer dereference to infer a
2556 non-NULL range, FALSE otherwise.
2558 ATTRIBUTE is TRUE if we can use attributes to infer a non-NULL range
2559 for function arguments and return values. FALSE otherwise. */
2562 infer_nonnull_range (gimple stmt
, tree op
, bool dereference
, bool attribute
)
2564 /* We can only assume that a pointer dereference will yield
2565 non-NULL if -fdelete-null-pointer-checks is enabled. */
2566 if (!flag_delete_null_pointer_checks
2567 || !POINTER_TYPE_P (TREE_TYPE (op
))
2568 || gimple_code (stmt
) == GIMPLE_ASM
)
2572 && walk_stmt_load_store_ops (stmt
, (void *)op
,
2573 check_loadstore
, check_loadstore
))
2577 && is_gimple_call (stmt
) && !gimple_call_internal_p (stmt
))
2579 tree fntype
= gimple_call_fntype (stmt
);
2580 tree attrs
= TYPE_ATTRIBUTES (fntype
);
2581 for (; attrs
; attrs
= TREE_CHAIN (attrs
))
2583 attrs
= lookup_attribute ("nonnull", attrs
);
2585 /* If "nonnull" wasn't specified, we know nothing about
2587 if (attrs
== NULL_TREE
)
2590 /* If "nonnull" applies to all the arguments, then ARG
2591 is non-null if it's in the argument list. */
2592 if (TREE_VALUE (attrs
) == NULL_TREE
)
2594 for (unsigned int i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2596 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt
, i
)))
2597 && operand_equal_p (op
, gimple_call_arg (stmt
, i
), 0))
2603 /* Now see if op appears in the nonnull list. */
2604 for (tree t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
2606 int idx
= TREE_INT_CST_LOW (TREE_VALUE (t
)) - 1;
2607 tree arg
= gimple_call_arg (stmt
, idx
);
2608 if (operand_equal_p (op
, arg
, 0))
2614 /* If this function is marked as returning non-null, then we can
2615 infer OP is non-null if it is used in the return statement. */
2617 && gimple_code (stmt
) == GIMPLE_RETURN
2618 && gimple_return_retval (stmt
)
2619 && operand_equal_p (gimple_return_retval (stmt
), op
, 0)
2620 && lookup_attribute ("returns_nonnull",
2621 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
))))
2627 /* Compare two case labels. Because the front end should already have
2628 made sure that case ranges do not overlap, it is enough to only compare
2629 the CASE_LOW values of each case label. */
2632 compare_case_labels (const void *p1
, const void *p2
)
2634 const_tree
const case1
= *(const_tree
const*)p1
;
2635 const_tree
const case2
= *(const_tree
const*)p2
;
2637 /* The 'default' case label always goes first. */
2638 if (!CASE_LOW (case1
))
2640 else if (!CASE_LOW (case2
))
2643 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
2646 /* Sort the case labels in LABEL_VEC in place in ascending order. */
2649 sort_case_labels (vec
<tree
> label_vec
)
2651 label_vec
.qsort (compare_case_labels
);
2654 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2656 LABELS is a vector that contains all case labels to look at.
2658 INDEX_TYPE is the type of the switch index expression. Case labels
2659 in LABELS are discarded if their values are not in the value range
2660 covered by INDEX_TYPE. The remaining case label values are folded
2663 If a default case exists in LABELS, it is removed from LABELS and
2664 returned in DEFAULT_CASEP. If no default case exists, but the
2665 case labels already cover the whole range of INDEX_TYPE, a default
2666 case is returned pointing to one of the existing case labels.
2667 Otherwise DEFAULT_CASEP is set to NULL_TREE.
2669 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2670 apply and no action is taken regardless of whether a default case is
2674 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
2676 tree
*default_casep
)
2678 tree min_value
, max_value
;
2679 tree default_case
= NULL_TREE
;
2683 min_value
= TYPE_MIN_VALUE (index_type
);
2684 max_value
= TYPE_MAX_VALUE (index_type
);
2685 while (i
< labels
.length ())
2687 tree elt
= labels
[i
];
2688 tree low
= CASE_LOW (elt
);
2689 tree high
= CASE_HIGH (elt
);
2690 bool remove_element
= FALSE
;
2694 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
2695 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
2697 /* This is a non-default case label, i.e. it has a value.
2699 See if the case label is reachable within the range of
2700 the index type. Remove out-of-range case values. Turn
2701 case ranges into a canonical form (high > low strictly)
2702 and convert the case label values to the index type.
2704 NB: The type of gimple_switch_index() may be the promoted
2705 type, but the case labels retain the original type. */
2709 /* This is a case range. Discard empty ranges.
2710 If the bounds or the range are equal, turn this
2711 into a simple (one-value) case. */
2712 int cmp
= tree_int_cst_compare (high
, low
);
2714 remove_element
= TRUE
;
2721 /* If the simple case value is unreachable, ignore it. */
2722 if ((TREE_CODE (min_value
) == INTEGER_CST
2723 && tree_int_cst_compare (low
, min_value
) < 0)
2724 || (TREE_CODE (max_value
) == INTEGER_CST
2725 && tree_int_cst_compare (low
, max_value
) > 0))
2726 remove_element
= TRUE
;
2728 low
= fold_convert (index_type
, low
);
2732 /* If the entire case range is unreachable, ignore it. */
2733 if ((TREE_CODE (min_value
) == INTEGER_CST
2734 && tree_int_cst_compare (high
, min_value
) < 0)
2735 || (TREE_CODE (max_value
) == INTEGER_CST
2736 && tree_int_cst_compare (low
, max_value
) > 0))
2737 remove_element
= TRUE
;
2740 /* If the lower bound is less than the index type's
2741 minimum value, truncate the range bounds. */
2742 if (TREE_CODE (min_value
) == INTEGER_CST
2743 && tree_int_cst_compare (low
, min_value
) < 0)
2745 low
= fold_convert (index_type
, low
);
2747 /* If the upper bound is greater than the index type's
2748 maximum value, truncate the range bounds. */
2749 if (TREE_CODE (max_value
) == INTEGER_CST
2750 && tree_int_cst_compare (high
, max_value
) > 0)
2752 high
= fold_convert (index_type
, high
);
2754 /* We may have folded a case range to a one-value case. */
2755 if (tree_int_cst_equal (low
, high
))
2760 CASE_LOW (elt
) = low
;
2761 CASE_HIGH (elt
) = high
;
2765 gcc_assert (!default_case
);
2767 /* The default case must be passed separately to the
2768 gimple_build_switch routine. But if DEFAULT_CASEP
2769 is NULL, we do not remove the default case (it would
2770 be completely lost). */
2772 remove_element
= TRUE
;
2776 labels
.ordered_remove (i
);
2782 if (!labels
.is_empty ())
2783 sort_case_labels (labels
);
2785 if (default_casep
&& !default_case
)
2787 /* If the switch has no default label, add one, so that we jump
2788 around the switch body. If the labels already cover the whole
2789 range of the switch index_type, add the default label pointing
2790 to one of the existing labels. */
2792 && TYPE_MIN_VALUE (index_type
)
2793 && TYPE_MAX_VALUE (index_type
)
2794 && tree_int_cst_equal (CASE_LOW (labels
[0]),
2795 TYPE_MIN_VALUE (index_type
)))
2797 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
2799 high
= CASE_LOW (labels
[len
- 1]);
2800 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
2802 for (i
= 1; i
< len
; i
++)
2804 high
= CASE_LOW (labels
[i
]);
2805 low
= CASE_HIGH (labels
[i
- 1]);
2807 low
= CASE_LOW (labels
[i
- 1]);
2808 if (wi::add (low
, 1) != high
)
2813 tree label
= CASE_LABEL (labels
[0]);
2814 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
2822 *default_casep
= default_case
;
2825 /* Set the location of all statements in SEQ to LOC. */
2828 gimple_seq_set_location (gimple_seq seq
, location_t loc
)
2830 for (gimple_stmt_iterator i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
2831 gimple_set_location (gsi_stmt (i
), loc
);