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 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
210 gimple_build_call_1 (tree fn
, unsigned nargs
)
212 gimple s
= gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
, nargs
+ 3);
213 if (TREE_CODE (fn
) == FUNCTION_DECL
)
214 fn
= build_fold_addr_expr (fn
);
215 gimple_set_op (s
, 1, fn
);
216 gimple_call_set_fntype (s
, TREE_TYPE (TREE_TYPE (fn
)));
217 gimple_call_reset_alias_info (s
);
222 /* Build a GIMPLE_CALL statement to function FN with the arguments
223 specified in vector ARGS. */
226 gimple_build_call_vec (tree fn
, vec
<tree
> args
)
229 unsigned nargs
= args
.length ();
230 gimple call
= gimple_build_call_1 (fn
, nargs
);
232 for (i
= 0; i
< nargs
; i
++)
233 gimple_call_set_arg (call
, i
, args
[i
]);
239 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
240 arguments. The ... are the arguments. */
243 gimple_build_call (tree fn
, unsigned nargs
, ...)
249 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
251 call
= gimple_build_call_1 (fn
, nargs
);
253 va_start (ap
, nargs
);
254 for (i
= 0; i
< nargs
; i
++)
255 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
262 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
263 arguments. AP contains the arguments. */
266 gimple_build_call_valist (tree fn
, unsigned nargs
, va_list ap
)
271 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
273 call
= gimple_build_call_1 (fn
, nargs
);
275 for (i
= 0; i
< nargs
; i
++)
276 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
282 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
283 Build the basic components of a GIMPLE_CALL statement to internal
284 function FN with NARGS arguments. */
287 gimple_build_call_internal_1 (enum internal_fn fn
, unsigned nargs
)
289 gimple s
= gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
, nargs
+ 3);
290 s
->subcode
|= GF_CALL_INTERNAL
;
291 gimple_call_set_internal_fn (s
, fn
);
292 gimple_call_reset_alias_info (s
);
297 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
298 the number of arguments. The ... are the arguments. */
301 gimple_build_call_internal (enum internal_fn fn
, unsigned nargs
, ...)
307 call
= gimple_build_call_internal_1 (fn
, nargs
);
308 va_start (ap
, nargs
);
309 for (i
= 0; i
< nargs
; i
++)
310 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
317 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
318 specified in vector ARGS. */
321 gimple_build_call_internal_vec (enum internal_fn fn
, vec
<tree
> args
)
326 nargs
= args
.length ();
327 call
= gimple_build_call_internal_1 (fn
, nargs
);
328 for (i
= 0; i
< nargs
; i
++)
329 gimple_call_set_arg (call
, i
, args
[i
]);
335 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
336 assumed to be in GIMPLE form already. Minimal checking is done of
340 gimple_build_call_from_tree (tree t
)
344 tree fndecl
= get_callee_fndecl (t
);
346 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
348 nargs
= call_expr_nargs (t
);
349 call
= gimple_build_call_1 (fndecl
? fndecl
: CALL_EXPR_FN (t
), nargs
);
351 for (i
= 0; i
< nargs
; i
++)
352 gimple_call_set_arg (call
, i
, CALL_EXPR_ARG (t
, i
));
354 gimple_set_block (call
, TREE_BLOCK (t
));
356 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
357 gimple_call_set_chain (call
, CALL_EXPR_STATIC_CHAIN (t
));
358 gimple_call_set_tail (call
, CALL_EXPR_TAILCALL (t
));
359 gimple_call_set_return_slot_opt (call
, CALL_EXPR_RETURN_SLOT_OPT (t
));
361 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
362 && (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA
363 || DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
364 gimple_call_set_alloca_for_var (call
, CALL_ALLOCA_FOR_VAR_P (t
));
366 gimple_call_set_from_thunk (call
, CALL_FROM_THUNK_P (t
));
367 gimple_call_set_va_arg_pack (call
, CALL_EXPR_VA_ARG_PACK (t
));
368 gimple_call_set_nothrow (call
, TREE_NOTHROW (t
));
369 gimple_set_no_warning (call
, TREE_NO_WARNING (t
));
375 /* Build a GIMPLE_ASSIGN statement.
377 LHS of the assignment.
378 RHS of the assignment which can be unary or binary. */
381 gimple_build_assign_stat (tree lhs
, tree rhs MEM_STAT_DECL
)
383 enum tree_code subcode
;
386 extract_ops_from_tree_1 (rhs
, &subcode
, &op1
, &op2
, &op3
);
387 return gimple_build_assign_with_ops (subcode
, lhs
, op1
, op2
, op3
392 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
393 OP1 and OP2. If OP2 is NULL then SUBCODE must be of class
394 GIMPLE_UNARY_RHS or GIMPLE_SINGLE_RHS. */
397 gimple_build_assign_with_ops (enum tree_code subcode
, tree lhs
, tree op1
,
398 tree op2
, tree op3 MEM_STAT_DECL
)
403 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
405 num_ops
= get_gimple_rhs_num_ops (subcode
) + 1;
407 p
= as_a
<gimple_assign
> (
408 gimple_build_with_ops_stat (GIMPLE_ASSIGN
, (unsigned)subcode
, num_ops
410 gimple_assign_set_lhs (p
, lhs
);
411 gimple_assign_set_rhs1 (p
, op1
);
414 gcc_assert (num_ops
> 2);
415 gimple_assign_set_rhs2 (p
, op2
);
420 gcc_assert (num_ops
> 3);
421 gimple_assign_set_rhs3 (p
, op3
);
428 gimple_build_assign_with_ops (enum tree_code subcode
, tree lhs
, tree op1
,
429 tree op2 MEM_STAT_DECL
)
431 return gimple_build_assign_with_ops (subcode
, lhs
, op1
, op2
, NULL_TREE
436 /* Build a GIMPLE_COND statement.
438 PRED is the condition used to compare LHS and the RHS.
439 T_LABEL is the label to jump to if the condition is true.
440 F_LABEL is the label to jump to otherwise. */
443 gimple_build_cond (enum tree_code pred_code
, tree lhs
, tree rhs
,
444 tree t_label
, tree f_label
)
448 gcc_assert (TREE_CODE_CLASS (pred_code
) == tcc_comparison
);
449 p
= as_a
<gimple_cond
> (gimple_build_with_ops (GIMPLE_COND
, pred_code
, 4));
450 gimple_cond_set_lhs (p
, lhs
);
451 gimple_cond_set_rhs (p
, rhs
);
452 gimple_cond_set_true_label (p
, t_label
);
453 gimple_cond_set_false_label (p
, f_label
);
457 /* Build a GIMPLE_COND statement from the conditional expression tree
458 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
461 gimple_build_cond_from_tree (tree cond
, tree t_label
, tree f_label
)
466 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
467 return gimple_build_cond (code
, lhs
, rhs
, t_label
, f_label
);
470 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
471 boolean expression tree COND. */
474 gimple_cond_set_condition_from_tree (gimple_cond stmt
, tree cond
)
479 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
480 gimple_cond_set_condition (stmt
, code
, lhs
, rhs
);
483 /* Build a GIMPLE_LABEL statement for LABEL. */
486 gimple_build_label (tree label
)
489 as_a
<gimple_label
> (gimple_build_with_ops (GIMPLE_LABEL
, ERROR_MARK
, 1));
490 gimple_label_set_label (p
, label
);
494 /* Build a GIMPLE_GOTO statement to label DEST. */
497 gimple_build_goto (tree dest
)
499 gimple p
= gimple_build_with_ops (GIMPLE_GOTO
, ERROR_MARK
, 1);
500 gimple_goto_set_dest (p
, dest
);
505 /* Build a GIMPLE_NOP statement. */
508 gimple_build_nop (void)
510 return gimple_alloc (GIMPLE_NOP
, 0);
514 /* Build a GIMPLE_BIND statement.
515 VARS are the variables in BODY.
516 BLOCK is the containing block. */
519 gimple_build_bind (tree vars
, gimple_seq body
, tree block
)
521 gimple_bind p
= as_a
<gimple_bind
> (gimple_alloc (GIMPLE_BIND
, 0));
522 gimple_bind_set_vars (p
, vars
);
524 gimple_bind_set_body (p
, body
);
526 gimple_bind_set_block (p
, block
);
530 /* Helper function to set the simple fields of a asm stmt.
532 STRING is a pointer to a string that is the asm blocks assembly code.
533 NINPUT is the number of register inputs.
534 NOUTPUT is the number of register outputs.
535 NCLOBBERS is the number of clobbered registers.
539 gimple_build_asm_1 (const char *string
, unsigned ninputs
, unsigned noutputs
,
540 unsigned nclobbers
, unsigned nlabels
)
542 gimple_statement_asm
*p
;
543 int size
= strlen (string
);
545 /* ASMs with labels cannot have outputs. This should have been
546 enforced by the front end. */
547 gcc_assert (nlabels
== 0 || noutputs
== 0);
549 p
= as_a
<gimple_statement_asm
*> (
550 gimple_build_with_ops (GIMPLE_ASM
, ERROR_MARK
,
551 ninputs
+ noutputs
+ nclobbers
+ nlabels
));
557 p
->string
= ggc_alloc_string (string
, size
);
559 if (GATHER_STATISTICS
)
560 gimple_alloc_sizes
[(int) gimple_alloc_kind (GIMPLE_ASM
)] += size
;
565 /* Build a GIMPLE_ASM statement.
567 STRING is the assembly code.
568 NINPUT is the number of register inputs.
569 NOUTPUT is the number of register outputs.
570 NCLOBBERS is the number of clobbered registers.
571 INPUTS is a vector of the input register parameters.
572 OUTPUTS is a vector of the output register parameters.
573 CLOBBERS is a vector of the clobbered register parameters.
574 LABELS is a vector of destination labels. */
577 gimple_build_asm_vec (const char *string
, vec
<tree
, va_gc
> *inputs
,
578 vec
<tree
, va_gc
> *outputs
, vec
<tree
, va_gc
> *clobbers
,
579 vec
<tree
, va_gc
> *labels
)
584 p
= gimple_build_asm_1 (string
,
585 vec_safe_length (inputs
),
586 vec_safe_length (outputs
),
587 vec_safe_length (clobbers
),
588 vec_safe_length (labels
));
590 for (i
= 0; i
< vec_safe_length (inputs
); i
++)
591 gimple_asm_set_input_op (p
, i
, (*inputs
)[i
]);
593 for (i
= 0; i
< vec_safe_length (outputs
); i
++)
594 gimple_asm_set_output_op (p
, i
, (*outputs
)[i
]);
596 for (i
= 0; i
< vec_safe_length (clobbers
); i
++)
597 gimple_asm_set_clobber_op (p
, i
, (*clobbers
)[i
]);
599 for (i
= 0; i
< vec_safe_length (labels
); i
++)
600 gimple_asm_set_label_op (p
, i
, (*labels
)[i
]);
605 /* Build a GIMPLE_CATCH statement.
607 TYPES are the catch types.
608 HANDLER is the exception handler. */
611 gimple_build_catch (tree types
, gimple_seq handler
)
613 gimple p
= gimple_alloc (GIMPLE_CATCH
, 0);
614 gimple_catch_set_types (p
, types
);
616 gimple_catch_set_handler (p
, handler
);
621 /* Build a GIMPLE_EH_FILTER statement.
623 TYPES are the filter's types.
624 FAILURE is the filter's failure action. */
627 gimple_build_eh_filter (tree types
, gimple_seq failure
)
629 gimple p
= gimple_alloc (GIMPLE_EH_FILTER
, 0);
630 gimple_eh_filter_set_types (p
, types
);
632 gimple_eh_filter_set_failure (p
, failure
);
637 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
640 gimple_build_eh_must_not_throw (tree decl
)
642 gimple p
= gimple_alloc (GIMPLE_EH_MUST_NOT_THROW
, 0);
644 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
645 gcc_assert (flags_from_decl_or_type (decl
) & ECF_NORETURN
);
646 gimple_eh_must_not_throw_set_fndecl (p
, decl
);
651 /* Build a GIMPLE_EH_ELSE statement. */
654 gimple_build_eh_else (gimple_seq n_body
, gimple_seq e_body
)
656 gimple p
= gimple_alloc (GIMPLE_EH_ELSE
, 0);
657 gimple_eh_else_set_n_body (p
, n_body
);
658 gimple_eh_else_set_e_body (p
, e_body
);
662 /* Build a GIMPLE_TRY statement.
664 EVAL is the expression to evaluate.
665 CLEANUP is the cleanup expression.
666 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
667 whether this is a try/catch or a try/finally respectively. */
669 gimple_statement_try
*
670 gimple_build_try (gimple_seq eval
, gimple_seq cleanup
,
671 enum gimple_try_flags kind
)
673 gimple_statement_try
*p
;
675 gcc_assert (kind
== GIMPLE_TRY_CATCH
|| kind
== GIMPLE_TRY_FINALLY
);
676 p
= as_a
<gimple_statement_try
*> (gimple_alloc (GIMPLE_TRY
, 0));
677 gimple_set_subcode (p
, kind
);
679 gimple_try_set_eval (p
, eval
);
681 gimple_try_set_cleanup (p
, cleanup
);
686 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
688 CLEANUP is the cleanup expression. */
691 gimple_build_wce (gimple_seq cleanup
)
693 gimple p
= gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR
, 0);
695 gimple_wce_set_cleanup (p
, cleanup
);
701 /* Build a GIMPLE_RESX statement. */
704 gimple_build_resx (int region
)
706 gimple_statement_resx
*p
=
707 as_a
<gimple_statement_resx
*> (
708 gimple_build_with_ops (GIMPLE_RESX
, ERROR_MARK
, 0));
714 /* The helper for constructing a gimple switch statement.
715 INDEX is the switch's index.
716 NLABELS is the number of labels in the switch excluding the default.
717 DEFAULT_LABEL is the default label for the switch statement. */
720 gimple_build_switch_nlabels (unsigned nlabels
, tree index
, tree default_label
)
722 /* nlabels + 1 default label + 1 index. */
723 gcc_checking_assert (default_label
);
725 as_a
<gimple_switch
> (gimple_build_with_ops (GIMPLE_SWITCH
, ERROR_MARK
,
727 gimple_switch_set_index (p
, index
);
728 gimple_switch_set_default_label (p
, default_label
);
732 /* Build a GIMPLE_SWITCH statement.
734 INDEX is the switch's index.
735 DEFAULT_LABEL is the default label
736 ARGS is a vector of labels excluding the default. */
739 gimple_build_switch (tree index
, tree default_label
, vec
<tree
> args
)
741 unsigned i
, nlabels
= args
.length ();
743 gimple_switch p
= gimple_build_switch_nlabels (nlabels
, index
, default_label
);
745 /* Copy the labels from the vector to the switch statement. */
746 for (i
= 0; i
< nlabels
; i
++)
747 gimple_switch_set_label (p
, i
+ 1, args
[i
]);
752 /* Build a GIMPLE_EH_DISPATCH statement. */
755 gimple_build_eh_dispatch (int region
)
757 gimple_statement_eh_dispatch
*p
=
758 as_a
<gimple_statement_eh_dispatch
*> (
759 gimple_build_with_ops (GIMPLE_EH_DISPATCH
, ERROR_MARK
, 0));
764 /* Build a new GIMPLE_DEBUG_BIND statement.
766 VAR is bound to VALUE; block and location are taken from STMT. */
769 gimple_build_debug_bind_stat (tree var
, tree value
, gimple stmt MEM_STAT_DECL
)
772 as_a
<gimple_debug
> (gimple_build_with_ops_stat (GIMPLE_DEBUG
,
773 (unsigned)GIMPLE_DEBUG_BIND
, 2
775 gimple_debug_bind_set_var (p
, var
);
776 gimple_debug_bind_set_value (p
, value
);
778 gimple_set_location (p
, gimple_location (stmt
));
784 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
786 VAR is bound to VALUE; block and location are taken from STMT. */
789 gimple_build_debug_source_bind_stat (tree var
, tree value
,
790 gimple stmt MEM_STAT_DECL
)
793 as_a
<gimple_debug
> (
794 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
795 (unsigned)GIMPLE_DEBUG_SOURCE_BIND
, 2
798 gimple_debug_source_bind_set_var (p
, var
);
799 gimple_debug_source_bind_set_value (p
, value
);
801 gimple_set_location (p
, gimple_location (stmt
));
807 /* Build a GIMPLE_OMP_CRITICAL statement.
809 BODY is the sequence of statements for which only one thread can execute.
810 NAME is optional identifier for this critical block. */
813 gimple_build_omp_critical (gimple_seq body
, tree name
)
815 gimple p
= gimple_alloc (GIMPLE_OMP_CRITICAL
, 0);
816 gimple_omp_critical_set_name (p
, name
);
818 gimple_omp_set_body (p
, body
);
823 /* Build a GIMPLE_OMP_FOR statement.
825 BODY is sequence of statements inside the for loop.
826 KIND is the `for' variant.
827 CLAUSES, are any of the OMP loop construct's clauses: private, firstprivate,
828 lastprivate, reductions, ordered, schedule, and nowait.
829 COLLAPSE is the collapse count.
830 PRE_BODY is the sequence of statements that are loop invariant. */
833 gimple_build_omp_for (gimple_seq body
, int kind
, tree clauses
, size_t collapse
,
836 gimple_statement_omp_for
*p
=
837 as_a
<gimple_statement_omp_for
*> (gimple_alloc (GIMPLE_OMP_FOR
, 0));
839 gimple_omp_set_body (p
, body
);
840 gimple_omp_for_set_clauses (p
, clauses
);
841 gimple_omp_for_set_kind (p
, kind
);
842 p
->collapse
= collapse
;
843 p
->iter
= ggc_cleared_vec_alloc
<gimple_omp_for_iter
> (collapse
);
846 gimple_omp_for_set_pre_body (p
, pre_body
);
852 /* Build a GIMPLE_OMP_PARALLEL statement.
854 BODY is sequence of statements which are executed in parallel.
855 CLAUSES, are the OMP parallel construct's clauses.
856 CHILD_FN is the function created for the parallel threads to execute.
857 DATA_ARG are the shared data argument(s). */
860 gimple_build_omp_parallel (gimple_seq body
, tree clauses
, tree child_fn
,
863 gimple p
= gimple_alloc (GIMPLE_OMP_PARALLEL
, 0);
865 gimple_omp_set_body (p
, body
);
866 gimple_omp_parallel_set_clauses (p
, clauses
);
867 gimple_omp_parallel_set_child_fn (p
, child_fn
);
868 gimple_omp_parallel_set_data_arg (p
, data_arg
);
874 /* Build a GIMPLE_OMP_TASK statement.
876 BODY is sequence of statements which are executed by the explicit task.
877 CLAUSES, are the OMP parallel construct's clauses.
878 CHILD_FN is the function created for the parallel threads to execute.
879 DATA_ARG are the shared data argument(s).
880 COPY_FN is the optional function for firstprivate initialization.
881 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
884 gimple_build_omp_task (gimple_seq body
, tree clauses
, tree child_fn
,
885 tree data_arg
, tree copy_fn
, tree arg_size
,
888 gimple p
= gimple_alloc (GIMPLE_OMP_TASK
, 0);
890 gimple_omp_set_body (p
, body
);
891 gimple_omp_task_set_clauses (p
, clauses
);
892 gimple_omp_task_set_child_fn (p
, child_fn
);
893 gimple_omp_task_set_data_arg (p
, data_arg
);
894 gimple_omp_task_set_copy_fn (p
, copy_fn
);
895 gimple_omp_task_set_arg_size (p
, arg_size
);
896 gimple_omp_task_set_arg_align (p
, arg_align
);
902 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
904 BODY is the sequence of statements in the section. */
907 gimple_build_omp_section (gimple_seq body
)
909 gimple p
= gimple_alloc (GIMPLE_OMP_SECTION
, 0);
911 gimple_omp_set_body (p
, body
);
917 /* Build a GIMPLE_OMP_MASTER statement.
919 BODY is the sequence of statements to be executed by just the master. */
922 gimple_build_omp_master (gimple_seq body
)
924 gimple p
= gimple_alloc (GIMPLE_OMP_MASTER
, 0);
926 gimple_omp_set_body (p
, body
);
932 /* Build a GIMPLE_OMP_TASKGROUP statement.
934 BODY is the sequence of statements to be executed by the taskgroup
938 gimple_build_omp_taskgroup (gimple_seq body
)
940 gimple p
= gimple_alloc (GIMPLE_OMP_TASKGROUP
, 0);
942 gimple_omp_set_body (p
, body
);
948 /* Build a GIMPLE_OMP_CONTINUE statement.
950 CONTROL_DEF is the definition of the control variable.
951 CONTROL_USE is the use of the control variable. */
954 gimple_build_omp_continue (tree control_def
, tree control_use
)
956 gimple p
= gimple_alloc (GIMPLE_OMP_CONTINUE
, 0);
957 gimple_omp_continue_set_control_def (p
, control_def
);
958 gimple_omp_continue_set_control_use (p
, control_use
);
962 /* Build a GIMPLE_OMP_ORDERED statement.
964 BODY is the sequence of statements inside a loop that will executed in
968 gimple_build_omp_ordered (gimple_seq body
)
970 gimple p
= gimple_alloc (GIMPLE_OMP_ORDERED
, 0);
972 gimple_omp_set_body (p
, body
);
978 /* Build a GIMPLE_OMP_RETURN statement.
979 WAIT_P is true if this is a non-waiting return. */
982 gimple_build_omp_return (bool wait_p
)
984 gimple p
= gimple_alloc (GIMPLE_OMP_RETURN
, 0);
986 gimple_omp_return_set_nowait (p
);
992 /* Build a GIMPLE_OMP_SECTIONS statement.
994 BODY is a sequence of section statements.
995 CLAUSES are any of the OMP sections contsruct's clauses: private,
996 firstprivate, lastprivate, reduction, and nowait. */
999 gimple_build_omp_sections (gimple_seq body
, tree clauses
)
1001 gimple p
= gimple_alloc (GIMPLE_OMP_SECTIONS
, 0);
1003 gimple_omp_set_body (p
, body
);
1004 gimple_omp_sections_set_clauses (p
, clauses
);
1010 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1013 gimple_build_omp_sections_switch (void)
1015 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH
, 0);
1019 /* Build a GIMPLE_OMP_SINGLE statement.
1021 BODY is the sequence of statements that will be executed once.
1022 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1023 copyprivate, nowait. */
1026 gimple_build_omp_single (gimple_seq body
, tree clauses
)
1028 gimple p
= gimple_alloc (GIMPLE_OMP_SINGLE
, 0);
1030 gimple_omp_set_body (p
, body
);
1031 gimple_omp_single_set_clauses (p
, clauses
);
1037 /* Build a GIMPLE_OMP_TARGET statement.
1039 BODY is the sequence of statements that will be executed.
1040 CLAUSES are any of the OMP target construct's clauses. */
1043 gimple_build_omp_target (gimple_seq body
, int kind
, tree clauses
)
1045 gimple p
= gimple_alloc (GIMPLE_OMP_TARGET
, 0);
1047 gimple_omp_set_body (p
, body
);
1048 gimple_omp_target_set_clauses (p
, clauses
);
1049 gimple_omp_target_set_kind (p
, kind
);
1055 /* Build a GIMPLE_OMP_TEAMS statement.
1057 BODY is the sequence of statements that will be executed.
1058 CLAUSES are any of the OMP teams construct's clauses. */
1061 gimple_build_omp_teams (gimple_seq body
, tree clauses
)
1063 gimple p
= gimple_alloc (GIMPLE_OMP_TEAMS
, 0);
1065 gimple_omp_set_body (p
, body
);
1066 gimple_omp_teams_set_clauses (p
, clauses
);
1072 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1075 gimple_build_omp_atomic_load (tree lhs
, tree rhs
)
1077 gimple p
= gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD
, 0);
1078 gimple_omp_atomic_load_set_lhs (p
, lhs
);
1079 gimple_omp_atomic_load_set_rhs (p
, rhs
);
1083 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1085 VAL is the value we are storing. */
1088 gimple_build_omp_atomic_store (tree val
)
1090 gimple p
= gimple_alloc (GIMPLE_OMP_ATOMIC_STORE
, 0);
1091 gimple_omp_atomic_store_set_val (p
, val
);
1095 /* Build a GIMPLE_TRANSACTION statement. */
1098 gimple_build_transaction (gimple_seq body
, tree label
)
1100 gimple p
= gimple_alloc (GIMPLE_TRANSACTION
, 0);
1101 gimple_transaction_set_body (p
, body
);
1102 gimple_transaction_set_label (p
, label
);
1106 /* Build a GIMPLE_PREDICT statement. PREDICT is one of the predictors from
1107 predict.def, OUTCOME is NOT_TAKEN or TAKEN. */
1110 gimple_build_predict (enum br_predictor predictor
, enum prediction outcome
)
1112 gimple p
= gimple_alloc (GIMPLE_PREDICT
, 0);
1113 /* Ensure all the predictors fit into the lower bits of the subcode. */
1114 gcc_assert ((int) END_PREDICTORS
<= GF_PREDICT_TAKEN
);
1115 gimple_predict_set_predictor (p
, predictor
);
1116 gimple_predict_set_outcome (p
, outcome
);
1120 #if defined ENABLE_GIMPLE_CHECKING
1121 /* Complain of a gimple type mismatch and die. */
1124 gimple_check_failed (const_gimple gs
, const char *file
, int line
,
1125 const char *function
, enum gimple_code code
,
1126 enum tree_code subcode
)
1128 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1129 gimple_code_name
[code
],
1130 get_tree_code_name (subcode
),
1131 gimple_code_name
[gimple_code (gs
)],
1133 ? get_tree_code_name ((enum tree_code
) gs
->subcode
)
1135 function
, trim_filename (file
), line
);
1137 #endif /* ENABLE_GIMPLE_CHECKING */
1140 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1141 *SEQ_P is NULL, a new sequence is allocated. */
1144 gimple_seq_add_stmt (gimple_seq
*seq_p
, gimple gs
)
1146 gimple_stmt_iterator si
;
1150 si
= gsi_last (*seq_p
);
1151 gsi_insert_after (&si
, gs
, GSI_NEW_STMT
);
1154 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1155 *SEQ_P is NULL, a new sequence is allocated. This function is
1156 similar to gimple_seq_add_stmt, but does not scan the operands.
1157 During gimplification, we need to manipulate statement sequences
1158 before the def/use vectors have been constructed. */
1161 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple gs
)
1163 gimple_stmt_iterator si
;
1168 si
= gsi_last (*seq_p
);
1169 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
1172 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1173 NULL, a new sequence is allocated. */
1176 gimple_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
1178 gimple_stmt_iterator si
;
1182 si
= gsi_last (*dst_p
);
1183 gsi_insert_seq_after (&si
, src
, GSI_NEW_STMT
);
1186 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1187 NULL, a new sequence is allocated. This function is
1188 similar to gimple_seq_add_seq, but does not scan the operands. */
1191 gimple_seq_add_seq_without_update (gimple_seq
*dst_p
, gimple_seq src
)
1193 gimple_stmt_iterator si
;
1197 si
= gsi_last (*dst_p
);
1198 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
1201 /* Determine whether to assign a location to the statement GS. */
1204 should_carry_location_p (gimple gs
)
1206 /* Don't emit a line note for a label. We particularly don't want to
1207 emit one for the break label, since it doesn't actually correspond
1208 to the beginning of the loop/switch. */
1209 if (gimple_code (gs
) == GIMPLE_LABEL
)
1215 /* Set the location for gimple statement GS to LOCATION. */
1218 annotate_one_with_location (gimple gs
, location_t location
)
1220 if (!gimple_has_location (gs
)
1221 && !gimple_do_not_emit_location_p (gs
)
1222 && should_carry_location_p (gs
))
1223 gimple_set_location (gs
, location
);
1226 /* Set LOCATION for all the statements after iterator GSI in sequence
1227 SEQ. If GSI is pointing to the end of the sequence, start with the
1228 first statement in SEQ. */
1231 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
1232 location_t location
)
1234 if (gsi_end_p (gsi
))
1235 gsi
= gsi_start (seq
);
1239 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
1240 annotate_one_with_location (gsi_stmt (gsi
), location
);
1243 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1246 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
1248 gimple_stmt_iterator i
;
1250 if (gimple_seq_empty_p (stmt_p
))
1253 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
1255 gimple gs
= gsi_stmt (i
);
1256 annotate_one_with_location (gs
, location
);
1260 /* Helper function of empty_body_p. Return true if STMT is an empty
1264 empty_stmt_p (gimple stmt
)
1266 if (gimple_code (stmt
) == GIMPLE_NOP
)
1268 if (gimple_bind bind_stmt
= dyn_cast
<gimple_bind
> (stmt
))
1269 return empty_body_p (gimple_bind_body (bind_stmt
));
1274 /* Return true if BODY contains nothing but empty statements. */
1277 empty_body_p (gimple_seq body
)
1279 gimple_stmt_iterator i
;
1281 if (gimple_seq_empty_p (body
))
1283 for (i
= gsi_start (body
); !gsi_end_p (i
); gsi_next (&i
))
1284 if (!empty_stmt_p (gsi_stmt (i
))
1285 && !is_gimple_debug (gsi_stmt (i
)))
1292 /* Perform a deep copy of sequence SRC and return the result. */
1295 gimple_seq_copy (gimple_seq src
)
1297 gimple_stmt_iterator gsi
;
1298 gimple_seq new_seq
= NULL
;
1301 for (gsi
= gsi_start (src
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1303 stmt
= gimple_copy (gsi_stmt (gsi
));
1304 gimple_seq_add_stmt (&new_seq
, stmt
);
1312 /* Return true if calls C1 and C2 are known to go to the same function. */
1315 gimple_call_same_target_p (const_gimple c1
, const_gimple c2
)
1317 if (gimple_call_internal_p (c1
))
1318 return (gimple_call_internal_p (c2
)
1319 && gimple_call_internal_fn (c1
) == gimple_call_internal_fn (c2
));
1321 return (gimple_call_fn (c1
) == gimple_call_fn (c2
)
1322 || (gimple_call_fndecl (c1
)
1323 && gimple_call_fndecl (c1
) == gimple_call_fndecl (c2
)));
1326 /* Detect flags from a GIMPLE_CALL. This is just like
1327 call_expr_flags, but for gimple tuples. */
1330 gimple_call_flags (const_gimple stmt
)
1333 tree decl
= gimple_call_fndecl (stmt
);
1336 flags
= flags_from_decl_or_type (decl
);
1337 else if (gimple_call_internal_p (stmt
))
1338 flags
= internal_fn_flags (gimple_call_internal_fn (stmt
));
1340 flags
= flags_from_decl_or_type (gimple_call_fntype (stmt
));
1342 if (stmt
->subcode
& GF_CALL_NOTHROW
)
1343 flags
|= ECF_NOTHROW
;
1348 /* Return the "fn spec" string for call STMT. */
1351 gimple_call_fnspec (const_gimple stmt
)
1355 if (gimple_call_internal_p (stmt
))
1356 return internal_fn_fnspec (gimple_call_internal_fn (stmt
));
1358 type
= gimple_call_fntype (stmt
);
1362 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
1366 return TREE_VALUE (TREE_VALUE (attr
));
1369 /* Detects argument flags for argument number ARG on call STMT. */
1372 gimple_call_arg_flags (const_gimple stmt
, unsigned arg
)
1374 const_tree attr
= gimple_call_fnspec (stmt
);
1376 if (!attr
|| 1 + arg
>= (unsigned) TREE_STRING_LENGTH (attr
))
1379 switch (TREE_STRING_POINTER (attr
)[1 + arg
])
1386 return EAF_DIRECT
| EAF_NOCLOBBER
| EAF_NOESCAPE
;
1389 return EAF_NOCLOBBER
| EAF_NOESCAPE
;
1392 return EAF_DIRECT
| EAF_NOESCAPE
;
1395 return EAF_NOESCAPE
;
1403 /* Detects return flags for the call STMT. */
1406 gimple_call_return_flags (const_gimple stmt
)
1410 if (gimple_call_flags (stmt
) & ECF_MALLOC
)
1413 attr
= gimple_call_fnspec (stmt
);
1414 if (!attr
|| TREE_STRING_LENGTH (attr
) < 1)
1417 switch (TREE_STRING_POINTER (attr
)[0])
1423 return ERF_RETURNS_ARG
| (TREE_STRING_POINTER (attr
)[0] - '1');
1435 /* Return true if GS is a copy assignment. */
1438 gimple_assign_copy_p (gimple gs
)
1440 return (gimple_assign_single_p (gs
)
1441 && is_gimple_val (gimple_op (gs
, 1)));
1445 /* Return true if GS is a SSA_NAME copy assignment. */
1448 gimple_assign_ssa_name_copy_p (gimple gs
)
1450 return (gimple_assign_single_p (gs
)
1451 && TREE_CODE (gimple_assign_lhs (gs
)) == SSA_NAME
1452 && TREE_CODE (gimple_assign_rhs1 (gs
)) == SSA_NAME
);
1456 /* Return true if GS is an assignment with a unary RHS, but the
1457 operator has no effect on the assigned value. The logic is adapted
1458 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1459 instances in which STRIP_NOPS was previously applied to the RHS of
1462 NOTE: In the use cases that led to the creation of this function
1463 and of gimple_assign_single_p, it is typical to test for either
1464 condition and to proceed in the same manner. In each case, the
1465 assigned value is represented by the single RHS operand of the
1466 assignment. I suspect there may be cases where gimple_assign_copy_p,
1467 gimple_assign_single_p, or equivalent logic is used where a similar
1468 treatment of unary NOPs is appropriate. */
1471 gimple_assign_unary_nop_p (gimple gs
)
1473 return (is_gimple_assign (gs
)
1474 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs
))
1475 || gimple_assign_rhs_code (gs
) == NON_LVALUE_EXPR
)
1476 && gimple_assign_rhs1 (gs
) != error_mark_node
1477 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs
)))
1478 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs
)))));
1481 /* Set BB to be the basic block holding G. */
1484 gimple_set_bb (gimple stmt
, basic_block bb
)
1488 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1491 /* If the statement is a label, add the label to block-to-labels map
1492 so that we can speed up edge creation for GIMPLE_GOTOs. */
1498 t
= gimple_label_label (stmt
);
1499 uid
= LABEL_DECL_UID (t
);
1503 vec_safe_length (label_to_block_map_for_fn (cfun
));
1504 LABEL_DECL_UID (t
) = uid
= cfun
->cfg
->last_label_uid
++;
1505 if (old_len
<= (unsigned) uid
)
1507 unsigned new_len
= 3 * uid
/ 2 + 1;
1509 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun
),
1514 (*label_to_block_map_for_fn (cfun
))[uid
] = bb
;
1519 /* Modify the RHS of the assignment pointed-to by GSI using the
1520 operands in the expression tree EXPR.
1522 NOTE: The statement pointed-to by GSI may be reallocated if it
1523 did not have enough operand slots.
1525 This function is useful to convert an existing tree expression into
1526 the flat representation used for the RHS of a GIMPLE assignment.
1527 It will reallocate memory as needed to expand or shrink the number
1528 of operand slots needed to represent EXPR.
1530 NOTE: If you find yourself building a tree and then calling this
1531 function, you are most certainly doing it the slow way. It is much
1532 better to build a new assignment or to use the function
1533 gimple_assign_set_rhs_with_ops, which does not require an
1534 expression tree to be built. */
1537 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*gsi
, tree expr
)
1539 enum tree_code subcode
;
1542 extract_ops_from_tree_1 (expr
, &subcode
, &op1
, &op2
, &op3
);
1543 gimple_assign_set_rhs_with_ops_1 (gsi
, subcode
, op1
, op2
, op3
);
1547 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1548 operands OP1, OP2 and OP3.
1550 NOTE: The statement pointed-to by GSI may be reallocated if it
1551 did not have enough operand slots. */
1554 gimple_assign_set_rhs_with_ops_1 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
1555 tree op1
, tree op2
, tree op3
)
1557 unsigned new_rhs_ops
= get_gimple_rhs_num_ops (code
);
1558 gimple stmt
= gsi_stmt (*gsi
);
1560 /* If the new CODE needs more operands, allocate a new statement. */
1561 if (gimple_num_ops (stmt
) < new_rhs_ops
+ 1)
1563 tree lhs
= gimple_assign_lhs (stmt
);
1564 gimple new_stmt
= gimple_alloc (gimple_code (stmt
), new_rhs_ops
+ 1);
1565 memcpy (new_stmt
, stmt
, gimple_size (gimple_code (stmt
)));
1566 gimple_init_singleton (new_stmt
);
1567 gsi_replace (gsi
, new_stmt
, true);
1570 /* The LHS needs to be reset as this also changes the SSA name
1572 gimple_assign_set_lhs (stmt
, lhs
);
1575 gimple_set_num_ops (stmt
, new_rhs_ops
+ 1);
1576 gimple_set_subcode (stmt
, code
);
1577 gimple_assign_set_rhs1 (stmt
, op1
);
1578 if (new_rhs_ops
> 1)
1579 gimple_assign_set_rhs2 (stmt
, op2
);
1580 if (new_rhs_ops
> 2)
1581 gimple_assign_set_rhs3 (stmt
, op3
);
1585 /* Return the LHS of a statement that performs an assignment,
1586 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1587 for a call to a function that returns no value, or for a
1588 statement other than an assignment or a call. */
1591 gimple_get_lhs (const_gimple stmt
)
1593 enum gimple_code code
= gimple_code (stmt
);
1595 if (code
== GIMPLE_ASSIGN
)
1596 return gimple_assign_lhs (stmt
);
1597 else if (code
== GIMPLE_CALL
)
1598 return gimple_call_lhs (stmt
);
1604 /* Set the LHS of a statement that performs an assignment,
1605 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1608 gimple_set_lhs (gimple stmt
, tree lhs
)
1610 enum gimple_code code
= gimple_code (stmt
);
1612 if (code
== GIMPLE_ASSIGN
)
1613 gimple_assign_set_lhs (stmt
, lhs
);
1614 else if (code
== GIMPLE_CALL
)
1615 gimple_call_set_lhs (stmt
, lhs
);
1621 /* Return a deep copy of statement STMT. All the operands from STMT
1622 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1623 and VUSE operand arrays are set to empty in the new copy. The new
1624 copy isn't part of any sequence. */
1627 gimple_copy (gimple stmt
)
1629 enum gimple_code code
= gimple_code (stmt
);
1630 unsigned num_ops
= gimple_num_ops (stmt
);
1631 gimple copy
= gimple_alloc (code
, num_ops
);
1634 /* Shallow copy all the fields from STMT. */
1635 memcpy (copy
, stmt
, gimple_size (code
));
1636 gimple_init_singleton (copy
);
1638 /* If STMT has sub-statements, deep-copy them as well. */
1639 if (gimple_has_substatements (stmt
))
1644 switch (gimple_code (stmt
))
1648 gimple_bind bind_stmt
= as_a
<gimple_bind
> (stmt
);
1649 gimple_bind bind_copy
= as_a
<gimple_bind
> (copy
);
1650 new_seq
= gimple_seq_copy (gimple_bind_body (bind_stmt
));
1651 gimple_bind_set_body (bind_copy
, new_seq
);
1652 gimple_bind_set_vars (bind_copy
,
1653 unshare_expr (gimple_bind_vars (bind_stmt
)));
1654 gimple_bind_set_block (bind_copy
, gimple_bind_block (bind_stmt
));
1659 new_seq
= gimple_seq_copy (gimple_catch_handler (stmt
));
1660 gimple_catch_set_handler (copy
, new_seq
);
1661 t
= unshare_expr (gimple_catch_types (stmt
));
1662 gimple_catch_set_types (copy
, t
);
1665 case GIMPLE_EH_FILTER
:
1666 new_seq
= gimple_seq_copy (gimple_eh_filter_failure (stmt
));
1667 gimple_eh_filter_set_failure (copy
, new_seq
);
1668 t
= unshare_expr (gimple_eh_filter_types (stmt
));
1669 gimple_eh_filter_set_types (copy
, t
);
1672 case GIMPLE_EH_ELSE
:
1673 new_seq
= gimple_seq_copy (gimple_eh_else_n_body (stmt
));
1674 gimple_eh_else_set_n_body (copy
, new_seq
);
1675 new_seq
= gimple_seq_copy (gimple_eh_else_e_body (stmt
));
1676 gimple_eh_else_set_e_body (copy
, new_seq
);
1680 new_seq
= gimple_seq_copy (gimple_try_eval (stmt
));
1681 gimple_try_set_eval (copy
, new_seq
);
1682 new_seq
= gimple_seq_copy (gimple_try_cleanup (stmt
));
1683 gimple_try_set_cleanup (copy
, new_seq
);
1686 case GIMPLE_OMP_FOR
:
1687 new_seq
= gimple_seq_copy (gimple_omp_for_pre_body (stmt
));
1688 gimple_omp_for_set_pre_body (copy
, new_seq
);
1689 t
= unshare_expr (gimple_omp_for_clauses (stmt
));
1690 gimple_omp_for_set_clauses (copy
, t
);
1692 gimple_statement_omp_for
*omp_for_copy
=
1693 as_a
<gimple_statement_omp_for
*> (copy
);
1694 omp_for_copy
->iter
= ggc_vec_alloc
<gimple_omp_for_iter
>
1695 ( gimple_omp_for_collapse (stmt
));
1697 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1699 gimple_omp_for_set_cond (copy
, i
,
1700 gimple_omp_for_cond (stmt
, i
));
1701 gimple_omp_for_set_index (copy
, i
,
1702 gimple_omp_for_index (stmt
, i
));
1703 t
= unshare_expr (gimple_omp_for_initial (stmt
, i
));
1704 gimple_omp_for_set_initial (copy
, i
, t
);
1705 t
= unshare_expr (gimple_omp_for_final (stmt
, i
));
1706 gimple_omp_for_set_final (copy
, i
, t
);
1707 t
= unshare_expr (gimple_omp_for_incr (stmt
, i
));
1708 gimple_omp_for_set_incr (copy
, i
, t
);
1712 case GIMPLE_OMP_PARALLEL
:
1713 t
= unshare_expr (gimple_omp_parallel_clauses (stmt
));
1714 gimple_omp_parallel_set_clauses (copy
, t
);
1715 t
= unshare_expr (gimple_omp_parallel_child_fn (stmt
));
1716 gimple_omp_parallel_set_child_fn (copy
, t
);
1717 t
= unshare_expr (gimple_omp_parallel_data_arg (stmt
));
1718 gimple_omp_parallel_set_data_arg (copy
, t
);
1721 case GIMPLE_OMP_TASK
:
1722 t
= unshare_expr (gimple_omp_task_clauses (stmt
));
1723 gimple_omp_task_set_clauses (copy
, t
);
1724 t
= unshare_expr (gimple_omp_task_child_fn (stmt
));
1725 gimple_omp_task_set_child_fn (copy
, t
);
1726 t
= unshare_expr (gimple_omp_task_data_arg (stmt
));
1727 gimple_omp_task_set_data_arg (copy
, t
);
1728 t
= unshare_expr (gimple_omp_task_copy_fn (stmt
));
1729 gimple_omp_task_set_copy_fn (copy
, t
);
1730 t
= unshare_expr (gimple_omp_task_arg_size (stmt
));
1731 gimple_omp_task_set_arg_size (copy
, t
);
1732 t
= unshare_expr (gimple_omp_task_arg_align (stmt
));
1733 gimple_omp_task_set_arg_align (copy
, t
);
1736 case GIMPLE_OMP_CRITICAL
:
1737 t
= unshare_expr (gimple_omp_critical_name (stmt
));
1738 gimple_omp_critical_set_name (copy
, t
);
1741 case GIMPLE_OMP_SECTIONS
:
1742 t
= unshare_expr (gimple_omp_sections_clauses (stmt
));
1743 gimple_omp_sections_set_clauses (copy
, t
);
1744 t
= unshare_expr (gimple_omp_sections_control (stmt
));
1745 gimple_omp_sections_set_control (copy
, t
);
1748 case GIMPLE_OMP_SINGLE
:
1749 case GIMPLE_OMP_TARGET
:
1750 case GIMPLE_OMP_TEAMS
:
1751 case GIMPLE_OMP_SECTION
:
1752 case GIMPLE_OMP_MASTER
:
1753 case GIMPLE_OMP_TASKGROUP
:
1754 case GIMPLE_OMP_ORDERED
:
1756 new_seq
= gimple_seq_copy (gimple_omp_body (stmt
));
1757 gimple_omp_set_body (copy
, new_seq
);
1760 case GIMPLE_TRANSACTION
:
1761 new_seq
= gimple_seq_copy (gimple_transaction_body (stmt
));
1762 gimple_transaction_set_body (copy
, new_seq
);
1765 case GIMPLE_WITH_CLEANUP_EXPR
:
1766 new_seq
= gimple_seq_copy (gimple_wce_cleanup (stmt
));
1767 gimple_wce_set_cleanup (copy
, new_seq
);
1775 /* Make copy of operands. */
1776 for (i
= 0; i
< num_ops
; i
++)
1777 gimple_set_op (copy
, i
, unshare_expr (gimple_op (stmt
, i
)));
1779 if (gimple_has_mem_ops (stmt
))
1781 gimple_set_vdef (copy
, gimple_vdef (stmt
));
1782 gimple_set_vuse (copy
, gimple_vuse (stmt
));
1785 /* Clear out SSA operand vectors on COPY. */
1786 if (gimple_has_ops (stmt
))
1788 gimple_set_use_ops (copy
, NULL
);
1790 /* SSA operands need to be updated. */
1791 gimple_set_modified (copy
, true);
1798 /* Return true if statement S has side-effects. We consider a
1799 statement to have side effects if:
1801 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
1802 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
1805 gimple_has_side_effects (const_gimple s
)
1807 if (is_gimple_debug (s
))
1810 /* We don't have to scan the arguments to check for
1811 volatile arguments, though, at present, we still
1812 do a scan to check for TREE_SIDE_EFFECTS. */
1813 if (gimple_has_volatile_ops (s
))
1816 if (gimple_code (s
) == GIMPLE_ASM
1817 && gimple_asm_volatile_p (s
))
1820 if (is_gimple_call (s
))
1822 int flags
= gimple_call_flags (s
);
1824 /* An infinite loop is considered a side effect. */
1825 if (!(flags
& (ECF_CONST
| ECF_PURE
))
1826 || (flags
& ECF_LOOPING_CONST_OR_PURE
))
1835 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
1836 Return true if S can trap. When INCLUDE_MEM is true, check whether
1837 the memory operations could trap. When INCLUDE_STORES is true and
1838 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
1841 gimple_could_trap_p_1 (gimple s
, bool include_mem
, bool include_stores
)
1843 tree t
, div
= NULL_TREE
;
1848 unsigned i
, start
= (is_gimple_assign (s
) && !include_stores
) ? 1 : 0;
1850 for (i
= start
; i
< gimple_num_ops (s
); i
++)
1851 if (tree_could_trap_p (gimple_op (s
, i
)))
1855 switch (gimple_code (s
))
1858 return gimple_asm_volatile_p (s
);
1861 t
= gimple_call_fndecl (s
);
1862 /* Assume that calls to weak functions may trap. */
1863 if (!t
|| !DECL_P (t
) || DECL_WEAK (t
))
1868 t
= gimple_expr_type (s
);
1869 op
= gimple_assign_rhs_code (s
);
1870 if (get_gimple_rhs_class (op
) == GIMPLE_BINARY_RHS
)
1871 div
= gimple_assign_rhs2 (s
);
1872 return (operation_could_trap_p (op
, FLOAT_TYPE_P (t
),
1873 (INTEGRAL_TYPE_P (t
)
1874 && TYPE_OVERFLOW_TRAPS (t
)),
1884 /* Return true if statement S can trap. */
1887 gimple_could_trap_p (gimple s
)
1889 return gimple_could_trap_p_1 (s
, true, true);
1892 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
1895 gimple_assign_rhs_could_trap_p (gimple s
)
1897 gcc_assert (is_gimple_assign (s
));
1898 return gimple_could_trap_p_1 (s
, true, false);
1902 /* Print debugging information for gimple stmts generated. */
1905 dump_gimple_statistics (void)
1907 int i
, total_tuples
= 0, total_bytes
= 0;
1909 if (! GATHER_STATISTICS
)
1911 fprintf (stderr
, "No gimple statistics\n");
1915 fprintf (stderr
, "\nGIMPLE statements\n");
1916 fprintf (stderr
, "Kind Stmts Bytes\n");
1917 fprintf (stderr
, "---------------------------------------\n");
1918 for (i
= 0; i
< (int) gimple_alloc_kind_all
; ++i
)
1920 fprintf (stderr
, "%-20s %7d %10d\n", gimple_alloc_kind_names
[i
],
1921 gimple_alloc_counts
[i
], gimple_alloc_sizes
[i
]);
1922 total_tuples
+= gimple_alloc_counts
[i
];
1923 total_bytes
+= gimple_alloc_sizes
[i
];
1925 fprintf (stderr
, "---------------------------------------\n");
1926 fprintf (stderr
, "%-20s %7d %10d\n", "Total", total_tuples
, total_bytes
);
1927 fprintf (stderr
, "---------------------------------------\n");
1931 /* Return the number of operands needed on the RHS of a GIMPLE
1932 assignment for an expression with tree code CODE. */
1935 get_gimple_rhs_num_ops (enum tree_code code
)
1937 enum gimple_rhs_class rhs_class
= get_gimple_rhs_class (code
);
1939 if (rhs_class
== GIMPLE_UNARY_RHS
|| rhs_class
== GIMPLE_SINGLE_RHS
)
1941 else if (rhs_class
== GIMPLE_BINARY_RHS
)
1943 else if (rhs_class
== GIMPLE_TERNARY_RHS
)
1949 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
1951 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
1952 : ((TYPE) == tcc_binary \
1953 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
1954 : ((TYPE) == tcc_constant \
1955 || (TYPE) == tcc_declaration \
1956 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
1957 : ((SYM) == TRUTH_AND_EXPR \
1958 || (SYM) == TRUTH_OR_EXPR \
1959 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
1960 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
1961 : ((SYM) == COND_EXPR \
1962 || (SYM) == WIDEN_MULT_PLUS_EXPR \
1963 || (SYM) == WIDEN_MULT_MINUS_EXPR \
1964 || (SYM) == DOT_PROD_EXPR \
1965 || (SYM) == SAD_EXPR \
1966 || (SYM) == REALIGN_LOAD_EXPR \
1967 || (SYM) == VEC_COND_EXPR \
1968 || (SYM) == VEC_PERM_EXPR \
1969 || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS \
1970 : ((SYM) == CONSTRUCTOR \
1971 || (SYM) == OBJ_TYPE_REF \
1972 || (SYM) == ASSERT_EXPR \
1973 || (SYM) == ADDR_EXPR \
1974 || (SYM) == WITH_SIZE_EXPR \
1975 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
1976 : GIMPLE_INVALID_RHS),
1977 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
1979 const unsigned char gimple_rhs_class_table
[] = {
1980 #include "all-tree.def"
1984 #undef END_OF_BASE_TREE_CODES
1986 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
1987 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
1988 we failed to create one. */
1991 canonicalize_cond_expr_cond (tree t
)
1993 /* Strip conversions around boolean operations. */
1994 if (CONVERT_EXPR_P (t
)
1995 && (truth_value_p (TREE_CODE (TREE_OPERAND (t
, 0)))
1996 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
1998 t
= TREE_OPERAND (t
, 0);
2000 /* For !x use x == 0. */
2001 if (TREE_CODE (t
) == TRUTH_NOT_EXPR
)
2003 tree top0
= TREE_OPERAND (t
, 0);
2004 t
= build2 (EQ_EXPR
, TREE_TYPE (t
),
2005 top0
, build_int_cst (TREE_TYPE (top0
), 0));
2007 /* For cmp ? 1 : 0 use cmp. */
2008 else if (TREE_CODE (t
) == COND_EXPR
2009 && COMPARISON_CLASS_P (TREE_OPERAND (t
, 0))
2010 && integer_onep (TREE_OPERAND (t
, 1))
2011 && integer_zerop (TREE_OPERAND (t
, 2)))
2013 tree top0
= TREE_OPERAND (t
, 0);
2014 t
= build2 (TREE_CODE (top0
), TREE_TYPE (t
),
2015 TREE_OPERAND (top0
, 0), TREE_OPERAND (top0
, 1));
2017 /* For x ^ y use x != y. */
2018 else if (TREE_CODE (t
) == BIT_XOR_EXPR
)
2019 t
= build2 (NE_EXPR
, TREE_TYPE (t
),
2020 TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1));
2022 if (is_gimple_condexpr (t
))
2028 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2029 the positions marked by the set ARGS_TO_SKIP. */
2032 gimple_call_copy_skip_args (gimple stmt
, bitmap args_to_skip
)
2035 int nargs
= gimple_call_num_args (stmt
);
2036 auto_vec
<tree
> vargs (nargs
);
2039 for (i
= 0; i
< nargs
; i
++)
2040 if (!bitmap_bit_p (args_to_skip
, i
))
2041 vargs
.quick_push (gimple_call_arg (stmt
, i
));
2043 if (gimple_call_internal_p (stmt
))
2044 new_stmt
= gimple_build_call_internal_vec (gimple_call_internal_fn (stmt
),
2047 new_stmt
= gimple_build_call_vec (gimple_call_fn (stmt
), vargs
);
2049 if (gimple_call_lhs (stmt
))
2050 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2052 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2053 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
2055 if (gimple_has_location (stmt
))
2056 gimple_set_location (new_stmt
, gimple_location (stmt
));
2057 gimple_call_copy_flags (new_stmt
, stmt
);
2058 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2060 gimple_set_modified (new_stmt
, true);
2067 /* Return true if the field decls F1 and F2 are at the same offset.
2069 This is intended to be used on GIMPLE types only. */
2072 gimple_compare_field_offset (tree f1
, tree f2
)
2074 if (DECL_OFFSET_ALIGN (f1
) == DECL_OFFSET_ALIGN (f2
))
2076 tree offset1
= DECL_FIELD_OFFSET (f1
);
2077 tree offset2
= DECL_FIELD_OFFSET (f2
);
2078 return ((offset1
== offset2
2079 /* Once gimplification is done, self-referential offsets are
2080 instantiated as operand #2 of the COMPONENT_REF built for
2081 each access and reset. Therefore, they are not relevant
2082 anymore and fields are interchangeable provided that they
2083 represent the same access. */
2084 || (TREE_CODE (offset1
) == PLACEHOLDER_EXPR
2085 && TREE_CODE (offset2
) == PLACEHOLDER_EXPR
2086 && (DECL_SIZE (f1
) == DECL_SIZE (f2
)
2087 || (TREE_CODE (DECL_SIZE (f1
)) == PLACEHOLDER_EXPR
2088 && TREE_CODE (DECL_SIZE (f2
)) == PLACEHOLDER_EXPR
)
2089 || operand_equal_p (DECL_SIZE (f1
), DECL_SIZE (f2
), 0))
2090 && DECL_ALIGN (f1
) == DECL_ALIGN (f2
))
2091 || operand_equal_p (offset1
, offset2
, 0))
2092 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1
),
2093 DECL_FIELD_BIT_OFFSET (f2
)));
2096 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2097 should be, so handle differing ones specially by decomposing
2098 the offset into a byte and bit offset manually. */
2099 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1
))
2100 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2
)))
2102 unsigned HOST_WIDE_INT byte_offset1
, byte_offset2
;
2103 unsigned HOST_WIDE_INT bit_offset1
, bit_offset2
;
2104 bit_offset1
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1
));
2105 byte_offset1
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1
))
2106 + bit_offset1
/ BITS_PER_UNIT
);
2107 bit_offset2
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2
));
2108 byte_offset2
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2
))
2109 + bit_offset2
/ BITS_PER_UNIT
);
2110 if (byte_offset1
!= byte_offset2
)
2112 return bit_offset1
% BITS_PER_UNIT
== bit_offset2
% BITS_PER_UNIT
;
2119 /* Return a type the same as TYPE except unsigned or
2120 signed according to UNSIGNEDP. */
2123 gimple_signed_or_unsigned_type (bool unsignedp
, tree type
)
2127 type1
= TYPE_MAIN_VARIANT (type
);
2128 if (type1
== signed_char_type_node
2129 || type1
== char_type_node
2130 || type1
== unsigned_char_type_node
)
2131 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2132 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2133 return unsignedp
? unsigned_type_node
: integer_type_node
;
2134 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2135 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2136 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2137 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2138 if (type1
== long_long_integer_type_node
2139 || type1
== long_long_unsigned_type_node
)
2141 ? long_long_unsigned_type_node
2142 : long_long_integer_type_node
;
2143 if (int128_integer_type_node
&& (type1
== int128_integer_type_node
|| type1
== int128_unsigned_type_node
))
2145 ? int128_unsigned_type_node
2146 : int128_integer_type_node
;
2147 #if HOST_BITS_PER_WIDE_INT >= 64
2148 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2149 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2151 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2152 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2153 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2154 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2155 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2156 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2157 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2158 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2160 #define GIMPLE_FIXED_TYPES(NAME) \
2161 if (type1 == short_ ## NAME ## _type_node \
2162 || type1 == unsigned_short_ ## NAME ## _type_node) \
2163 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2164 : short_ ## NAME ## _type_node; \
2165 if (type1 == NAME ## _type_node \
2166 || type1 == unsigned_ ## NAME ## _type_node) \
2167 return unsignedp ? unsigned_ ## NAME ## _type_node \
2168 : NAME ## _type_node; \
2169 if (type1 == long_ ## NAME ## _type_node \
2170 || type1 == unsigned_long_ ## NAME ## _type_node) \
2171 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2172 : long_ ## NAME ## _type_node; \
2173 if (type1 == long_long_ ## NAME ## _type_node \
2174 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2175 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2176 : long_long_ ## NAME ## _type_node;
2178 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2179 if (type1 == NAME ## _type_node \
2180 || type1 == u ## NAME ## _type_node) \
2181 return unsignedp ? u ## NAME ## _type_node \
2182 : NAME ## _type_node;
2184 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2185 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2186 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2187 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2188 : sat_ ## short_ ## NAME ## _type_node; \
2189 if (type1 == sat_ ## NAME ## _type_node \
2190 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2191 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2192 : sat_ ## NAME ## _type_node; \
2193 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2194 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2195 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2196 : sat_ ## long_ ## NAME ## _type_node; \
2197 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2198 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2199 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2200 : sat_ ## long_long_ ## NAME ## _type_node;
2202 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2203 if (type1 == sat_ ## NAME ## _type_node \
2204 || type1 == sat_ ## u ## NAME ## _type_node) \
2205 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2206 : sat_ ## NAME ## _type_node;
2208 GIMPLE_FIXED_TYPES (fract
);
2209 GIMPLE_FIXED_TYPES_SAT (fract
);
2210 GIMPLE_FIXED_TYPES (accum
);
2211 GIMPLE_FIXED_TYPES_SAT (accum
);
2213 GIMPLE_FIXED_MODE_TYPES (qq
);
2214 GIMPLE_FIXED_MODE_TYPES (hq
);
2215 GIMPLE_FIXED_MODE_TYPES (sq
);
2216 GIMPLE_FIXED_MODE_TYPES (dq
);
2217 GIMPLE_FIXED_MODE_TYPES (tq
);
2218 GIMPLE_FIXED_MODE_TYPES_SAT (qq
);
2219 GIMPLE_FIXED_MODE_TYPES_SAT (hq
);
2220 GIMPLE_FIXED_MODE_TYPES_SAT (sq
);
2221 GIMPLE_FIXED_MODE_TYPES_SAT (dq
);
2222 GIMPLE_FIXED_MODE_TYPES_SAT (tq
);
2223 GIMPLE_FIXED_MODE_TYPES (ha
);
2224 GIMPLE_FIXED_MODE_TYPES (sa
);
2225 GIMPLE_FIXED_MODE_TYPES (da
);
2226 GIMPLE_FIXED_MODE_TYPES (ta
);
2227 GIMPLE_FIXED_MODE_TYPES_SAT (ha
);
2228 GIMPLE_FIXED_MODE_TYPES_SAT (sa
);
2229 GIMPLE_FIXED_MODE_TYPES_SAT (da
);
2230 GIMPLE_FIXED_MODE_TYPES_SAT (ta
);
2232 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2233 the precision; they have precision set to match their range, but
2234 may use a wider mode to match an ABI. If we change modes, we may
2235 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2236 the precision as well, so as to yield correct results for
2237 bit-field types. C++ does not have these separate bit-field
2238 types, and producing a signed or unsigned variant of an
2239 ENUMERAL_TYPE may cause other problems as well. */
2240 if (!INTEGRAL_TYPE_P (type
)
2241 || TYPE_UNSIGNED (type
) == unsignedp
)
2244 #define TYPE_OK(node) \
2245 (TYPE_MODE (type) == TYPE_MODE (node) \
2246 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2247 if (TYPE_OK (signed_char_type_node
))
2248 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2249 if (TYPE_OK (integer_type_node
))
2250 return unsignedp
? unsigned_type_node
: integer_type_node
;
2251 if (TYPE_OK (short_integer_type_node
))
2252 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2253 if (TYPE_OK (long_integer_type_node
))
2254 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2255 if (TYPE_OK (long_long_integer_type_node
))
2257 ? long_long_unsigned_type_node
2258 : long_long_integer_type_node
);
2259 if (int128_integer_type_node
&& TYPE_OK (int128_integer_type_node
))
2261 ? int128_unsigned_type_node
2262 : int128_integer_type_node
);
2264 #if HOST_BITS_PER_WIDE_INT >= 64
2265 if (TYPE_OK (intTI_type_node
))
2266 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2268 if (TYPE_OK (intDI_type_node
))
2269 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2270 if (TYPE_OK (intSI_type_node
))
2271 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2272 if (TYPE_OK (intHI_type_node
))
2273 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2274 if (TYPE_OK (intQI_type_node
))
2275 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2277 #undef GIMPLE_FIXED_TYPES
2278 #undef GIMPLE_FIXED_MODE_TYPES
2279 #undef GIMPLE_FIXED_TYPES_SAT
2280 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2283 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2287 /* Return an unsigned type the same as TYPE in other respects. */
2290 gimple_unsigned_type (tree type
)
2292 return gimple_signed_or_unsigned_type (true, type
);
2296 /* Return a signed type the same as TYPE in other respects. */
2299 gimple_signed_type (tree type
)
2301 return gimple_signed_or_unsigned_type (false, type
);
2305 /* Return the typed-based alias set for T, which may be an expression
2306 or a type. Return -1 if we don't do anything special. */
2309 gimple_get_alias_set (tree t
)
2313 /* Permit type-punning when accessing a union, provided the access
2314 is directly through the union. For example, this code does not
2315 permit taking the address of a union member and then storing
2316 through it. Even the type-punning allowed here is a GCC
2317 extension, albeit a common and useful one; the C standard says
2318 that such accesses have implementation-defined behavior. */
2320 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2321 u
= TREE_OPERAND (u
, 0))
2322 if (TREE_CODE (u
) == COMPONENT_REF
2323 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2326 /* That's all the expressions we handle specially. */
2330 /* For convenience, follow the C standard when dealing with
2331 character types. Any object may be accessed via an lvalue that
2332 has character type. */
2333 if (t
== char_type_node
2334 || t
== signed_char_type_node
2335 || t
== unsigned_char_type_node
)
2338 /* Allow aliasing between signed and unsigned variants of the same
2339 type. We treat the signed variant as canonical. */
2340 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2342 tree t1
= gimple_signed_type (t
);
2344 /* t1 == t can happen for boolean nodes which are always unsigned. */
2346 return get_alias_set (t1
);
2353 /* Helper for gimple_ior_addresses_taken_1. */
2356 gimple_ior_addresses_taken_1 (gimple
, tree addr
, tree
, void *data
)
2358 bitmap addresses_taken
= (bitmap
)data
;
2359 addr
= get_base_address (addr
);
2363 bitmap_set_bit (addresses_taken
, DECL_UID (addr
));
2369 /* Set the bit for the uid of all decls that have their address taken
2370 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2371 were any in this stmt. */
2374 gimple_ior_addresses_taken (bitmap addresses_taken
, gimple stmt
)
2376 return walk_stmt_load_store_addr_ops (stmt
, addresses_taken
, NULL
, NULL
,
2377 gimple_ior_addresses_taken_1
);
2381 /* Return true if TYPE1 and TYPE2 are compatible enough for builtin
2385 validate_type (tree type1
, tree type2
)
2387 if (INTEGRAL_TYPE_P (type1
)
2388 && INTEGRAL_TYPE_P (type2
))
2390 else if (POINTER_TYPE_P (type1
)
2391 && POINTER_TYPE_P (type2
))
2393 else if (TREE_CODE (type1
)
2394 != TREE_CODE (type2
))
2399 /* Return true when STMTs arguments and return value match those of FNDECL,
2400 a decl of a builtin function. */
2403 gimple_builtin_call_types_compatible_p (const_gimple stmt
, tree fndecl
)
2405 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
);
2407 tree ret
= gimple_call_lhs (stmt
);
2409 && !validate_type (TREE_TYPE (ret
), TREE_TYPE (TREE_TYPE (fndecl
))))
2412 tree targs
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2413 unsigned nargs
= gimple_call_num_args (stmt
);
2414 for (unsigned i
= 0; i
< nargs
; ++i
)
2416 /* Variadic args follow. */
2419 tree arg
= gimple_call_arg (stmt
, i
);
2420 if (!validate_type (TREE_TYPE (arg
), TREE_VALUE (targs
)))
2422 targs
= TREE_CHAIN (targs
);
2424 if (targs
&& !VOID_TYPE_P (TREE_VALUE (targs
)))
2429 /* Return true when STMT is builtins call. */
2432 gimple_call_builtin_p (const_gimple stmt
)
2435 if (is_gimple_call (stmt
)
2436 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2437 && DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
)
2438 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2442 /* Return true when STMT is builtins call to CLASS. */
2445 gimple_call_builtin_p (const_gimple stmt
, enum built_in_class klass
)
2448 if (is_gimple_call (stmt
)
2449 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2450 && DECL_BUILT_IN_CLASS (fndecl
) == klass
)
2451 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2455 /* Return true when STMT is builtins call to CODE of CLASS. */
2458 gimple_call_builtin_p (const_gimple stmt
, enum built_in_function code
)
2461 if (is_gimple_call (stmt
)
2462 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2463 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
2464 && DECL_FUNCTION_CODE (fndecl
) == code
)
2465 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2469 /* Return true if STMT clobbers memory. STMT is required to be a
2473 gimple_asm_clobbers_memory_p (const_gimple stmt
)
2477 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
2479 tree op
= gimple_asm_clobber_op (stmt
, i
);
2480 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op
)), "memory") == 0)
2487 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2490 dump_decl_set (FILE *file
, bitmap set
)
2497 fprintf (file
, "{ ");
2499 EXECUTE_IF_SET_IN_BITMAP (set
, 0, i
, bi
)
2501 fprintf (file
, "D.%u", i
);
2502 fprintf (file
, " ");
2505 fprintf (file
, "}");
2508 fprintf (file
, "NIL");
2511 /* Return true when CALL is a call stmt that definitely doesn't
2512 free any memory or makes it unavailable otherwise. */
2514 nonfreeing_call_p (gimple call
)
2516 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2517 && gimple_call_flags (call
) & ECF_LEAF
)
2518 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call
)))
2520 /* Just in case these become ECF_LEAF in the future. */
2522 case BUILT_IN_TM_FREE
:
2523 case BUILT_IN_REALLOC
:
2524 case BUILT_IN_STACK_RESTORE
:
2533 /* Callback for walk_stmt_load_store_ops.
2535 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2538 This routine only makes a superficial check for a dereference. Thus
2539 it must only be used if it is safe to return a false negative. */
2541 check_loadstore (gimple
, tree op
, tree
, void *data
)
2543 if ((TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
2544 && operand_equal_p (TREE_OPERAND (op
, 0), (tree
)data
, 0))
2549 /* If OP can be inferred to be non-NULL after STMT executes, return true.
2551 DEREFERENCE is TRUE if we can use a pointer dereference to infer a
2552 non-NULL range, FALSE otherwise.
2554 ATTRIBUTE is TRUE if we can use attributes to infer a non-NULL range
2555 for function arguments and return values. FALSE otherwise. */
2558 infer_nonnull_range (gimple stmt
, tree op
, bool dereference
, bool attribute
)
2560 /* We can only assume that a pointer dereference will yield
2561 non-NULL if -fdelete-null-pointer-checks is enabled. */
2562 if (!flag_delete_null_pointer_checks
2563 || !POINTER_TYPE_P (TREE_TYPE (op
))
2564 || gimple_code (stmt
) == GIMPLE_ASM
)
2568 && walk_stmt_load_store_ops (stmt
, (void *)op
,
2569 check_loadstore
, check_loadstore
))
2573 && is_gimple_call (stmt
) && !gimple_call_internal_p (stmt
))
2575 tree fntype
= gimple_call_fntype (stmt
);
2576 tree attrs
= TYPE_ATTRIBUTES (fntype
);
2577 for (; attrs
; attrs
= TREE_CHAIN (attrs
))
2579 attrs
= lookup_attribute ("nonnull", attrs
);
2581 /* If "nonnull" wasn't specified, we know nothing about
2583 if (attrs
== NULL_TREE
)
2586 /* If "nonnull" applies to all the arguments, then ARG
2587 is non-null if it's in the argument list. */
2588 if (TREE_VALUE (attrs
) == NULL_TREE
)
2590 for (unsigned int i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2592 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt
, i
)))
2593 && operand_equal_p (op
, gimple_call_arg (stmt
, i
), 0))
2599 /* Now see if op appears in the nonnull list. */
2600 for (tree t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
2602 int idx
= TREE_INT_CST_LOW (TREE_VALUE (t
)) - 1;
2603 tree arg
= gimple_call_arg (stmt
, idx
);
2604 if (operand_equal_p (op
, arg
, 0))
2610 /* If this function is marked as returning non-null, then we can
2611 infer OP is non-null if it is used in the return statement. */
2613 && gimple_code (stmt
) == GIMPLE_RETURN
2614 && gimple_return_retval (stmt
)
2615 && operand_equal_p (gimple_return_retval (stmt
), op
, 0)
2616 && lookup_attribute ("returns_nonnull",
2617 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
))))
2623 /* Compare two case labels. Because the front end should already have
2624 made sure that case ranges do not overlap, it is enough to only compare
2625 the CASE_LOW values of each case label. */
2628 compare_case_labels (const void *p1
, const void *p2
)
2630 const_tree
const case1
= *(const_tree
const*)p1
;
2631 const_tree
const case2
= *(const_tree
const*)p2
;
2633 /* The 'default' case label always goes first. */
2634 if (!CASE_LOW (case1
))
2636 else if (!CASE_LOW (case2
))
2639 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
2642 /* Sort the case labels in LABEL_VEC in place in ascending order. */
2645 sort_case_labels (vec
<tree
> label_vec
)
2647 label_vec
.qsort (compare_case_labels
);
2650 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2652 LABELS is a vector that contains all case labels to look at.
2654 INDEX_TYPE is the type of the switch index expression. Case labels
2655 in LABELS are discarded if their values are not in the value range
2656 covered by INDEX_TYPE. The remaining case label values are folded
2659 If a default case exists in LABELS, it is removed from LABELS and
2660 returned in DEFAULT_CASEP. If no default case exists, but the
2661 case labels already cover the whole range of INDEX_TYPE, a default
2662 case is returned pointing to one of the existing case labels.
2663 Otherwise DEFAULT_CASEP is set to NULL_TREE.
2665 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2666 apply and no action is taken regardless of whether a default case is
2670 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
2672 tree
*default_casep
)
2674 tree min_value
, max_value
;
2675 tree default_case
= NULL_TREE
;
2679 min_value
= TYPE_MIN_VALUE (index_type
);
2680 max_value
= TYPE_MAX_VALUE (index_type
);
2681 while (i
< labels
.length ())
2683 tree elt
= labels
[i
];
2684 tree low
= CASE_LOW (elt
);
2685 tree high
= CASE_HIGH (elt
);
2686 bool remove_element
= FALSE
;
2690 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
2691 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
2693 /* This is a non-default case label, i.e. it has a value.
2695 See if the case label is reachable within the range of
2696 the index type. Remove out-of-range case values. Turn
2697 case ranges into a canonical form (high > low strictly)
2698 and convert the case label values to the index type.
2700 NB: The type of gimple_switch_index() may be the promoted
2701 type, but the case labels retain the original type. */
2705 /* This is a case range. Discard empty ranges.
2706 If the bounds or the range are equal, turn this
2707 into a simple (one-value) case. */
2708 int cmp
= tree_int_cst_compare (high
, low
);
2710 remove_element
= TRUE
;
2717 /* If the simple case value is unreachable, ignore it. */
2718 if ((TREE_CODE (min_value
) == INTEGER_CST
2719 && tree_int_cst_compare (low
, min_value
) < 0)
2720 || (TREE_CODE (max_value
) == INTEGER_CST
2721 && tree_int_cst_compare (low
, max_value
) > 0))
2722 remove_element
= TRUE
;
2724 low
= fold_convert (index_type
, low
);
2728 /* If the entire case range is unreachable, ignore it. */
2729 if ((TREE_CODE (min_value
) == INTEGER_CST
2730 && tree_int_cst_compare (high
, min_value
) < 0)
2731 || (TREE_CODE (max_value
) == INTEGER_CST
2732 && tree_int_cst_compare (low
, max_value
) > 0))
2733 remove_element
= TRUE
;
2736 /* If the lower bound is less than the index type's
2737 minimum value, truncate the range bounds. */
2738 if (TREE_CODE (min_value
) == INTEGER_CST
2739 && tree_int_cst_compare (low
, min_value
) < 0)
2741 low
= fold_convert (index_type
, low
);
2743 /* If the upper bound is greater than the index type's
2744 maximum value, truncate the range bounds. */
2745 if (TREE_CODE (max_value
) == INTEGER_CST
2746 && tree_int_cst_compare (high
, max_value
) > 0)
2748 high
= fold_convert (index_type
, high
);
2750 /* We may have folded a case range to a one-value case. */
2751 if (tree_int_cst_equal (low
, high
))
2756 CASE_LOW (elt
) = low
;
2757 CASE_HIGH (elt
) = high
;
2761 gcc_assert (!default_case
);
2763 /* The default case must be passed separately to the
2764 gimple_build_switch routine. But if DEFAULT_CASEP
2765 is NULL, we do not remove the default case (it would
2766 be completely lost). */
2768 remove_element
= TRUE
;
2772 labels
.ordered_remove (i
);
2778 if (!labels
.is_empty ())
2779 sort_case_labels (labels
);
2781 if (default_casep
&& !default_case
)
2783 /* If the switch has no default label, add one, so that we jump
2784 around the switch body. If the labels already cover the whole
2785 range of the switch index_type, add the default label pointing
2786 to one of the existing labels. */
2788 && TYPE_MIN_VALUE (index_type
)
2789 && TYPE_MAX_VALUE (index_type
)
2790 && tree_int_cst_equal (CASE_LOW (labels
[0]),
2791 TYPE_MIN_VALUE (index_type
)))
2793 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
2795 high
= CASE_LOW (labels
[len
- 1]);
2796 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
2798 for (i
= 1; i
< len
; i
++)
2800 high
= CASE_LOW (labels
[i
]);
2801 low
= CASE_HIGH (labels
[i
- 1]);
2803 low
= CASE_LOW (labels
[i
- 1]);
2804 if (wi::add (low
, 1) != high
)
2809 tree label
= CASE_LABEL (labels
[0]);
2810 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
2818 *default_casep
= default_case
;
2821 /* Set the location of all statements in SEQ to LOC. */
2824 gimple_seq_set_location (gimple_seq seq
, location_t loc
)
2826 for (gimple_stmt_iterator i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
2827 gimple_set_location (gsi_stmt (i
), loc
);