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
= gimple_build_with_ops_stat (GIMPLE_ASSIGN
, (unsigned)subcode
, num_ops
409 gimple_assign_set_lhs (p
, lhs
);
410 gimple_assign_set_rhs1 (p
, op1
);
413 gcc_assert (num_ops
> 2);
414 gimple_assign_set_rhs2 (p
, op2
);
419 gcc_assert (num_ops
> 3);
420 gimple_assign_set_rhs3 (p
, op3
);
427 gimple_build_assign_with_ops (enum tree_code subcode
, tree lhs
, tree op1
,
428 tree op2 MEM_STAT_DECL
)
430 return gimple_build_assign_with_ops (subcode
, lhs
, op1
, op2
, NULL_TREE
435 /* Build a GIMPLE_COND statement.
437 PRED is the condition used to compare LHS and the RHS.
438 T_LABEL is the label to jump to if the condition is true.
439 F_LABEL is the label to jump to otherwise. */
442 gimple_build_cond (enum tree_code pred_code
, tree lhs
, tree rhs
,
443 tree t_label
, tree f_label
)
447 gcc_assert (TREE_CODE_CLASS (pred_code
) == tcc_comparison
);
448 p
= gimple_build_with_ops (GIMPLE_COND
, pred_code
, 4);
449 gimple_cond_set_lhs (p
, lhs
);
450 gimple_cond_set_rhs (p
, rhs
);
451 gimple_cond_set_true_label (p
, t_label
);
452 gimple_cond_set_false_label (p
, f_label
);
456 /* Build a GIMPLE_COND statement from the conditional expression tree
457 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
460 gimple_build_cond_from_tree (tree cond
, tree t_label
, tree f_label
)
465 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
466 return gimple_build_cond (code
, lhs
, rhs
, t_label
, f_label
);
469 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
470 boolean expression tree COND. */
473 gimple_cond_set_condition_from_tree (gimple stmt
, tree cond
)
478 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
479 gimple_cond_set_condition (stmt
, code
, lhs
, rhs
);
482 /* Build a GIMPLE_LABEL statement for LABEL. */
485 gimple_build_label (tree label
)
487 gimple p
= gimple_build_with_ops (GIMPLE_LABEL
, ERROR_MARK
, 1);
488 gimple_label_set_label (p
, label
);
492 /* Build a GIMPLE_GOTO statement to label DEST. */
495 gimple_build_goto (tree dest
)
497 gimple p
= gimple_build_with_ops (GIMPLE_GOTO
, ERROR_MARK
, 1);
498 gimple_goto_set_dest (p
, dest
);
503 /* Build a GIMPLE_NOP statement. */
506 gimple_build_nop (void)
508 return gimple_alloc (GIMPLE_NOP
, 0);
512 /* Build a GIMPLE_BIND statement.
513 VARS are the variables in BODY.
514 BLOCK is the containing block. */
517 gimple_build_bind (tree vars
, gimple_seq body
, tree block
)
519 gimple p
= gimple_alloc (GIMPLE_BIND
, 0);
520 gimple_bind_set_vars (p
, vars
);
522 gimple_bind_set_body (p
, body
);
524 gimple_bind_set_block (p
, block
);
528 /* Helper function to set the simple fields of a asm stmt.
530 STRING is a pointer to a string that is the asm blocks assembly code.
531 NINPUT is the number of register inputs.
532 NOUTPUT is the number of register outputs.
533 NCLOBBERS is the number of clobbered registers.
537 gimple_build_asm_1 (const char *string
, unsigned ninputs
, unsigned noutputs
,
538 unsigned nclobbers
, unsigned nlabels
)
540 gimple_statement_asm
*p
;
541 int size
= strlen (string
);
543 /* ASMs with labels cannot have outputs. This should have been
544 enforced by the front end. */
545 gcc_assert (nlabels
== 0 || noutputs
== 0);
547 p
= as_a
<gimple_statement_asm
> (
548 gimple_build_with_ops (GIMPLE_ASM
, ERROR_MARK
,
549 ninputs
+ noutputs
+ nclobbers
+ nlabels
));
555 p
->string
= ggc_alloc_string (string
, size
);
557 if (GATHER_STATISTICS
)
558 gimple_alloc_sizes
[(int) gimple_alloc_kind (GIMPLE_ASM
)] += size
;
563 /* Build a GIMPLE_ASM statement.
565 STRING is the assembly code.
566 NINPUT is the number of register inputs.
567 NOUTPUT is the number of register outputs.
568 NCLOBBERS is the number of clobbered registers.
569 INPUTS is a vector of the input register parameters.
570 OUTPUTS is a vector of the output register parameters.
571 CLOBBERS is a vector of the clobbered register parameters.
572 LABELS is a vector of destination labels. */
575 gimple_build_asm_vec (const char *string
, vec
<tree
, va_gc
> *inputs
,
576 vec
<tree
, va_gc
> *outputs
, vec
<tree
, va_gc
> *clobbers
,
577 vec
<tree
, va_gc
> *labels
)
582 p
= gimple_build_asm_1 (string
,
583 vec_safe_length (inputs
),
584 vec_safe_length (outputs
),
585 vec_safe_length (clobbers
),
586 vec_safe_length (labels
));
588 for (i
= 0; i
< vec_safe_length (inputs
); i
++)
589 gimple_asm_set_input_op (p
, i
, (*inputs
)[i
]);
591 for (i
= 0; i
< vec_safe_length (outputs
); i
++)
592 gimple_asm_set_output_op (p
, i
, (*outputs
)[i
]);
594 for (i
= 0; i
< vec_safe_length (clobbers
); i
++)
595 gimple_asm_set_clobber_op (p
, i
, (*clobbers
)[i
]);
597 for (i
= 0; i
< vec_safe_length (labels
); i
++)
598 gimple_asm_set_label_op (p
, i
, (*labels
)[i
]);
603 /* Build a GIMPLE_CATCH statement.
605 TYPES are the catch types.
606 HANDLER is the exception handler. */
609 gimple_build_catch (tree types
, gimple_seq handler
)
611 gimple p
= gimple_alloc (GIMPLE_CATCH
, 0);
612 gimple_catch_set_types (p
, types
);
614 gimple_catch_set_handler (p
, handler
);
619 /* Build a GIMPLE_EH_FILTER statement.
621 TYPES are the filter's types.
622 FAILURE is the filter's failure action. */
625 gimple_build_eh_filter (tree types
, gimple_seq failure
)
627 gimple p
= gimple_alloc (GIMPLE_EH_FILTER
, 0);
628 gimple_eh_filter_set_types (p
, types
);
630 gimple_eh_filter_set_failure (p
, failure
);
635 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
638 gimple_build_eh_must_not_throw (tree decl
)
640 gimple p
= gimple_alloc (GIMPLE_EH_MUST_NOT_THROW
, 0);
642 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
643 gcc_assert (flags_from_decl_or_type (decl
) & ECF_NORETURN
);
644 gimple_eh_must_not_throw_set_fndecl (p
, decl
);
649 /* Build a GIMPLE_EH_ELSE statement. */
652 gimple_build_eh_else (gimple_seq n_body
, gimple_seq e_body
)
654 gimple p
= gimple_alloc (GIMPLE_EH_ELSE
, 0);
655 gimple_eh_else_set_n_body (p
, n_body
);
656 gimple_eh_else_set_e_body (p
, e_body
);
660 /* Build a GIMPLE_TRY statement.
662 EVAL is the expression to evaluate.
663 CLEANUP is the cleanup expression.
664 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
665 whether this is a try/catch or a try/finally respectively. */
667 gimple_statement_try
*
668 gimple_build_try (gimple_seq eval
, gimple_seq cleanup
,
669 enum gimple_try_flags kind
)
671 gimple_statement_try
*p
;
673 gcc_assert (kind
== GIMPLE_TRY_CATCH
|| kind
== GIMPLE_TRY_FINALLY
);
674 p
= as_a
<gimple_statement_try
> (gimple_alloc (GIMPLE_TRY
, 0));
675 gimple_set_subcode (p
, kind
);
677 gimple_try_set_eval (p
, eval
);
679 gimple_try_set_cleanup (p
, cleanup
);
684 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
686 CLEANUP is the cleanup expression. */
689 gimple_build_wce (gimple_seq cleanup
)
691 gimple p
= gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR
, 0);
693 gimple_wce_set_cleanup (p
, cleanup
);
699 /* Build a GIMPLE_RESX statement. */
702 gimple_build_resx (int region
)
704 gimple_statement_resx
*p
=
705 as_a
<gimple_statement_resx
> (
706 gimple_build_with_ops (GIMPLE_RESX
, ERROR_MARK
, 0));
712 /* The helper for constructing a gimple switch statement.
713 INDEX is the switch's index.
714 NLABELS is the number of labels in the switch excluding the default.
715 DEFAULT_LABEL is the default label for the switch statement. */
718 gimple_build_switch_nlabels (unsigned nlabels
, tree index
, tree default_label
)
720 /* nlabels + 1 default label + 1 index. */
721 gcc_checking_assert (default_label
);
722 gimple p
= gimple_build_with_ops (GIMPLE_SWITCH
, ERROR_MARK
,
724 gimple_switch_set_index (p
, index
);
725 gimple_switch_set_default_label (p
, default_label
);
729 /* Build a GIMPLE_SWITCH statement.
731 INDEX is the switch's index.
732 DEFAULT_LABEL is the default label
733 ARGS is a vector of labels excluding the default. */
736 gimple_build_switch (tree index
, tree default_label
, vec
<tree
> args
)
738 unsigned i
, nlabels
= args
.length ();
740 gimple p
= gimple_build_switch_nlabels (nlabels
, index
, default_label
);
742 /* Copy the labels from the vector to the switch statement. */
743 for (i
= 0; i
< nlabels
; i
++)
744 gimple_switch_set_label (p
, i
+ 1, args
[i
]);
749 /* Build a GIMPLE_EH_DISPATCH statement. */
752 gimple_build_eh_dispatch (int region
)
754 gimple_statement_eh_dispatch
*p
=
755 as_a
<gimple_statement_eh_dispatch
> (
756 gimple_build_with_ops (GIMPLE_EH_DISPATCH
, ERROR_MARK
, 0));
761 /* Build a new GIMPLE_DEBUG_BIND statement.
763 VAR is bound to VALUE; block and location are taken from STMT. */
766 gimple_build_debug_bind_stat (tree var
, tree value
, gimple stmt MEM_STAT_DECL
)
768 gimple p
= gimple_build_with_ops_stat (GIMPLE_DEBUG
,
769 (unsigned)GIMPLE_DEBUG_BIND
, 2
772 gimple_debug_bind_set_var (p
, var
);
773 gimple_debug_bind_set_value (p
, value
);
775 gimple_set_location (p
, gimple_location (stmt
));
781 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
783 VAR is bound to VALUE; block and location are taken from STMT. */
786 gimple_build_debug_source_bind_stat (tree var
, tree value
,
787 gimple stmt MEM_STAT_DECL
)
789 gimple p
= gimple_build_with_ops_stat (GIMPLE_DEBUG
,
790 (unsigned)GIMPLE_DEBUG_SOURCE_BIND
, 2
793 gimple_debug_source_bind_set_var (p
, var
);
794 gimple_debug_source_bind_set_value (p
, value
);
796 gimple_set_location (p
, gimple_location (stmt
));
802 /* Build a GIMPLE_OMP_CRITICAL statement.
804 BODY is the sequence of statements for which only one thread can execute.
805 NAME is optional identifier for this critical block. */
808 gimple_build_omp_critical (gimple_seq body
, tree name
)
810 gimple p
= gimple_alloc (GIMPLE_OMP_CRITICAL
, 0);
811 gimple_omp_critical_set_name (p
, name
);
813 gimple_omp_set_body (p
, body
);
818 /* Build a GIMPLE_OMP_FOR statement.
820 BODY is sequence of statements inside the for loop.
821 KIND is the `for' variant.
822 CLAUSES, are any of the OMP loop construct's clauses: private, firstprivate,
823 lastprivate, reductions, ordered, schedule, and nowait.
824 COLLAPSE is the collapse count.
825 PRE_BODY is the sequence of statements that are loop invariant. */
828 gimple_build_omp_for (gimple_seq body
, int kind
, tree clauses
, size_t collapse
,
831 gimple_statement_omp_for
*p
=
832 as_a
<gimple_statement_omp_for
> (gimple_alloc (GIMPLE_OMP_FOR
, 0));
834 gimple_omp_set_body (p
, body
);
835 gimple_omp_for_set_clauses (p
, clauses
);
836 gimple_omp_for_set_kind (p
, kind
);
837 p
->collapse
= collapse
;
838 p
->iter
= static_cast <struct gimple_omp_for_iter
*> (
839 ggc_internal_cleared_vec_alloc_stat (sizeof (*p
->iter
),
840 collapse MEM_STAT_INFO
));
843 gimple_omp_for_set_pre_body (p
, pre_body
);
849 /* Build a GIMPLE_OMP_PARALLEL statement.
851 BODY is sequence of statements which are executed in parallel.
852 CLAUSES, are the OMP parallel construct's clauses.
853 CHILD_FN is the function created for the parallel threads to execute.
854 DATA_ARG are the shared data argument(s). */
857 gimple_build_omp_parallel (gimple_seq body
, tree clauses
, tree child_fn
,
860 gimple p
= gimple_alloc (GIMPLE_OMP_PARALLEL
, 0);
862 gimple_omp_set_body (p
, body
);
863 gimple_omp_parallel_set_clauses (p
, clauses
);
864 gimple_omp_parallel_set_child_fn (p
, child_fn
);
865 gimple_omp_parallel_set_data_arg (p
, data_arg
);
871 /* Build a GIMPLE_OMP_TASK statement.
873 BODY is sequence of statements which are executed by the explicit task.
874 CLAUSES, are the OMP parallel construct's clauses.
875 CHILD_FN is the function created for the parallel threads to execute.
876 DATA_ARG are the shared data argument(s).
877 COPY_FN is the optional function for firstprivate initialization.
878 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
881 gimple_build_omp_task (gimple_seq body
, tree clauses
, tree child_fn
,
882 tree data_arg
, tree copy_fn
, tree arg_size
,
885 gimple p
= gimple_alloc (GIMPLE_OMP_TASK
, 0);
887 gimple_omp_set_body (p
, body
);
888 gimple_omp_task_set_clauses (p
, clauses
);
889 gimple_omp_task_set_child_fn (p
, child_fn
);
890 gimple_omp_task_set_data_arg (p
, data_arg
);
891 gimple_omp_task_set_copy_fn (p
, copy_fn
);
892 gimple_omp_task_set_arg_size (p
, arg_size
);
893 gimple_omp_task_set_arg_align (p
, arg_align
);
899 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
901 BODY is the sequence of statements in the section. */
904 gimple_build_omp_section (gimple_seq body
)
906 gimple p
= gimple_alloc (GIMPLE_OMP_SECTION
, 0);
908 gimple_omp_set_body (p
, body
);
914 /* Build a GIMPLE_OMP_MASTER statement.
916 BODY is the sequence of statements to be executed by just the master. */
919 gimple_build_omp_master (gimple_seq body
)
921 gimple p
= gimple_alloc (GIMPLE_OMP_MASTER
, 0);
923 gimple_omp_set_body (p
, body
);
929 /* Build a GIMPLE_OMP_TASKGROUP statement.
931 BODY is the sequence of statements to be executed by the taskgroup
935 gimple_build_omp_taskgroup (gimple_seq body
)
937 gimple p
= gimple_alloc (GIMPLE_OMP_TASKGROUP
, 0);
939 gimple_omp_set_body (p
, body
);
945 /* Build a GIMPLE_OMP_CONTINUE statement.
947 CONTROL_DEF is the definition of the control variable.
948 CONTROL_USE is the use of the control variable. */
951 gimple_build_omp_continue (tree control_def
, tree control_use
)
953 gimple p
= gimple_alloc (GIMPLE_OMP_CONTINUE
, 0);
954 gimple_omp_continue_set_control_def (p
, control_def
);
955 gimple_omp_continue_set_control_use (p
, control_use
);
959 /* Build a GIMPLE_OMP_ORDERED statement.
961 BODY is the sequence of statements inside a loop that will executed in
965 gimple_build_omp_ordered (gimple_seq body
)
967 gimple p
= gimple_alloc (GIMPLE_OMP_ORDERED
, 0);
969 gimple_omp_set_body (p
, body
);
975 /* Build a GIMPLE_OMP_RETURN statement.
976 WAIT_P is true if this is a non-waiting return. */
979 gimple_build_omp_return (bool wait_p
)
981 gimple p
= gimple_alloc (GIMPLE_OMP_RETURN
, 0);
983 gimple_omp_return_set_nowait (p
);
989 /* Build a GIMPLE_OMP_SECTIONS statement.
991 BODY is a sequence of section statements.
992 CLAUSES are any of the OMP sections contsruct's clauses: private,
993 firstprivate, lastprivate, reduction, and nowait. */
996 gimple_build_omp_sections (gimple_seq body
, tree clauses
)
998 gimple p
= gimple_alloc (GIMPLE_OMP_SECTIONS
, 0);
1000 gimple_omp_set_body (p
, body
);
1001 gimple_omp_sections_set_clauses (p
, clauses
);
1007 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1010 gimple_build_omp_sections_switch (void)
1012 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH
, 0);
1016 /* Build a GIMPLE_OMP_SINGLE statement.
1018 BODY is the sequence of statements that will be executed once.
1019 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1020 copyprivate, nowait. */
1023 gimple_build_omp_single (gimple_seq body
, tree clauses
)
1025 gimple p
= gimple_alloc (GIMPLE_OMP_SINGLE
, 0);
1027 gimple_omp_set_body (p
, body
);
1028 gimple_omp_single_set_clauses (p
, clauses
);
1034 /* Build a GIMPLE_OMP_TARGET statement.
1036 BODY is the sequence of statements that will be executed.
1037 CLAUSES are any of the OMP target construct's clauses. */
1040 gimple_build_omp_target (gimple_seq body
, int kind
, tree clauses
)
1042 gimple p
= gimple_alloc (GIMPLE_OMP_TARGET
, 0);
1044 gimple_omp_set_body (p
, body
);
1045 gimple_omp_target_set_clauses (p
, clauses
);
1046 gimple_omp_target_set_kind (p
, kind
);
1052 /* Build a GIMPLE_OMP_TEAMS statement.
1054 BODY is the sequence of statements that will be executed.
1055 CLAUSES are any of the OMP teams construct's clauses. */
1058 gimple_build_omp_teams (gimple_seq body
, tree clauses
)
1060 gimple p
= gimple_alloc (GIMPLE_OMP_TEAMS
, 0);
1062 gimple_omp_set_body (p
, body
);
1063 gimple_omp_teams_set_clauses (p
, clauses
);
1069 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1072 gimple_build_omp_atomic_load (tree lhs
, tree rhs
)
1074 gimple p
= gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD
, 0);
1075 gimple_omp_atomic_load_set_lhs (p
, lhs
);
1076 gimple_omp_atomic_load_set_rhs (p
, rhs
);
1080 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1082 VAL is the value we are storing. */
1085 gimple_build_omp_atomic_store (tree val
)
1087 gimple p
= gimple_alloc (GIMPLE_OMP_ATOMIC_STORE
, 0);
1088 gimple_omp_atomic_store_set_val (p
, val
);
1092 /* Build a GIMPLE_TRANSACTION statement. */
1095 gimple_build_transaction (gimple_seq body
, tree label
)
1097 gimple p
= gimple_alloc (GIMPLE_TRANSACTION
, 0);
1098 gimple_transaction_set_body (p
, body
);
1099 gimple_transaction_set_label (p
, label
);
1103 /* Build a GIMPLE_PREDICT statement. PREDICT is one of the predictors from
1104 predict.def, OUTCOME is NOT_TAKEN or TAKEN. */
1107 gimple_build_predict (enum br_predictor predictor
, enum prediction outcome
)
1109 gimple p
= gimple_alloc (GIMPLE_PREDICT
, 0);
1110 /* Ensure all the predictors fit into the lower bits of the subcode. */
1111 gcc_assert ((int) END_PREDICTORS
<= GF_PREDICT_TAKEN
);
1112 gimple_predict_set_predictor (p
, predictor
);
1113 gimple_predict_set_outcome (p
, outcome
);
1117 #if defined ENABLE_GIMPLE_CHECKING
1118 /* Complain of a gimple type mismatch and die. */
1121 gimple_check_failed (const_gimple gs
, const char *file
, int line
,
1122 const char *function
, enum gimple_code code
,
1123 enum tree_code subcode
)
1125 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1126 gimple_code_name
[code
],
1127 get_tree_code_name (subcode
),
1128 gimple_code_name
[gimple_code (gs
)],
1130 ? get_tree_code_name ((enum tree_code
) gs
->subcode
)
1132 function
, trim_filename (file
), line
);
1134 #endif /* ENABLE_GIMPLE_CHECKING */
1137 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1138 *SEQ_P is NULL, a new sequence is allocated. */
1141 gimple_seq_add_stmt (gimple_seq
*seq_p
, gimple gs
)
1143 gimple_stmt_iterator si
;
1147 si
= gsi_last (*seq_p
);
1148 gsi_insert_after (&si
, gs
, GSI_NEW_STMT
);
1151 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1152 *SEQ_P is NULL, a new sequence is allocated. This function is
1153 similar to gimple_seq_add_stmt, but does not scan the operands.
1154 During gimplification, we need to manipulate statement sequences
1155 before the def/use vectors have been constructed. */
1158 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple gs
)
1160 gimple_stmt_iterator si
;
1165 si
= gsi_last (*seq_p
);
1166 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
1169 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1170 NULL, a new sequence is allocated. */
1173 gimple_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
1175 gimple_stmt_iterator si
;
1179 si
= gsi_last (*dst_p
);
1180 gsi_insert_seq_after (&si
, src
, GSI_NEW_STMT
);
1183 /* Determine whether to assign a location to the statement GS. */
1186 should_carry_location_p (gimple gs
)
1188 /* Don't emit a line note for a label. We particularly don't want to
1189 emit one for the break label, since it doesn't actually correspond
1190 to the beginning of the loop/switch. */
1191 if (gimple_code (gs
) == GIMPLE_LABEL
)
1197 /* Set the location for gimple statement GS to LOCATION. */
1200 annotate_one_with_location (gimple gs
, location_t location
)
1202 if (!gimple_has_location (gs
)
1203 && !gimple_do_not_emit_location_p (gs
)
1204 && should_carry_location_p (gs
))
1205 gimple_set_location (gs
, location
);
1208 /* Set LOCATION for all the statements after iterator GSI in sequence
1209 SEQ. If GSI is pointing to the end of the sequence, start with the
1210 first statement in SEQ. */
1213 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
1214 location_t location
)
1216 if (gsi_end_p (gsi
))
1217 gsi
= gsi_start (seq
);
1221 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
1222 annotate_one_with_location (gsi_stmt (gsi
), location
);
1225 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1228 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
1230 gimple_stmt_iterator i
;
1232 if (gimple_seq_empty_p (stmt_p
))
1235 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
1237 gimple gs
= gsi_stmt (i
);
1238 annotate_one_with_location (gs
, location
);
1242 /* Helper function of empty_body_p. Return true if STMT is an empty
1246 empty_stmt_p (gimple stmt
)
1248 if (gimple_code (stmt
) == GIMPLE_NOP
)
1250 if (gimple_code (stmt
) == GIMPLE_BIND
)
1251 return empty_body_p (gimple_bind_body (stmt
));
1256 /* Return true if BODY contains nothing but empty statements. */
1259 empty_body_p (gimple_seq body
)
1261 gimple_stmt_iterator i
;
1263 if (gimple_seq_empty_p (body
))
1265 for (i
= gsi_start (body
); !gsi_end_p (i
); gsi_next (&i
))
1266 if (!empty_stmt_p (gsi_stmt (i
))
1267 && !is_gimple_debug (gsi_stmt (i
)))
1274 /* Perform a deep copy of sequence SRC and return the result. */
1277 gimple_seq_copy (gimple_seq src
)
1279 gimple_stmt_iterator gsi
;
1280 gimple_seq new_seq
= NULL
;
1283 for (gsi
= gsi_start (src
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1285 stmt
= gimple_copy (gsi_stmt (gsi
));
1286 gimple_seq_add_stmt (&new_seq
, stmt
);
1294 /* Return true if calls C1 and C2 are known to go to the same function. */
1297 gimple_call_same_target_p (const_gimple c1
, const_gimple c2
)
1299 if (gimple_call_internal_p (c1
))
1300 return (gimple_call_internal_p (c2
)
1301 && gimple_call_internal_fn (c1
) == gimple_call_internal_fn (c2
));
1303 return (gimple_call_fn (c1
) == gimple_call_fn (c2
)
1304 || (gimple_call_fndecl (c1
)
1305 && gimple_call_fndecl (c1
) == gimple_call_fndecl (c2
)));
1308 /* Detect flags from a GIMPLE_CALL. This is just like
1309 call_expr_flags, but for gimple tuples. */
1312 gimple_call_flags (const_gimple stmt
)
1315 tree decl
= gimple_call_fndecl (stmt
);
1318 flags
= flags_from_decl_or_type (decl
);
1319 else if (gimple_call_internal_p (stmt
))
1320 flags
= internal_fn_flags (gimple_call_internal_fn (stmt
));
1322 flags
= flags_from_decl_or_type (gimple_call_fntype (stmt
));
1324 if (stmt
->subcode
& GF_CALL_NOTHROW
)
1325 flags
|= ECF_NOTHROW
;
1330 /* Return the "fn spec" string for call STMT. */
1333 gimple_call_fnspec (const_gimple stmt
)
1337 if (gimple_call_internal_p (stmt
))
1338 return internal_fn_fnspec (gimple_call_internal_fn (stmt
));
1340 type
= gimple_call_fntype (stmt
);
1344 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
1348 return TREE_VALUE (TREE_VALUE (attr
));
1351 /* Detects argument flags for argument number ARG on call STMT. */
1354 gimple_call_arg_flags (const_gimple stmt
, unsigned arg
)
1356 const_tree attr
= gimple_call_fnspec (stmt
);
1358 if (!attr
|| 1 + arg
>= (unsigned) TREE_STRING_LENGTH (attr
))
1361 switch (TREE_STRING_POINTER (attr
)[1 + arg
])
1368 return EAF_DIRECT
| EAF_NOCLOBBER
| EAF_NOESCAPE
;
1371 return EAF_NOCLOBBER
| EAF_NOESCAPE
;
1374 return EAF_DIRECT
| EAF_NOESCAPE
;
1377 return EAF_NOESCAPE
;
1385 /* Detects return flags for the call STMT. */
1388 gimple_call_return_flags (const_gimple stmt
)
1392 if (gimple_call_flags (stmt
) & ECF_MALLOC
)
1395 attr
= gimple_call_fnspec (stmt
);
1396 if (!attr
|| TREE_STRING_LENGTH (attr
) < 1)
1399 switch (TREE_STRING_POINTER (attr
)[0])
1405 return ERF_RETURNS_ARG
| (TREE_STRING_POINTER (attr
)[0] - '1');
1417 /* Return true if GS is a copy assignment. */
1420 gimple_assign_copy_p (gimple gs
)
1422 return (gimple_assign_single_p (gs
)
1423 && is_gimple_val (gimple_op (gs
, 1)));
1427 /* Return true if GS is a SSA_NAME copy assignment. */
1430 gimple_assign_ssa_name_copy_p (gimple gs
)
1432 return (gimple_assign_single_p (gs
)
1433 && TREE_CODE (gimple_assign_lhs (gs
)) == SSA_NAME
1434 && TREE_CODE (gimple_assign_rhs1 (gs
)) == SSA_NAME
);
1438 /* Return true if GS is an assignment with a unary RHS, but the
1439 operator has no effect on the assigned value. The logic is adapted
1440 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1441 instances in which STRIP_NOPS was previously applied to the RHS of
1444 NOTE: In the use cases that led to the creation of this function
1445 and of gimple_assign_single_p, it is typical to test for either
1446 condition and to proceed in the same manner. In each case, the
1447 assigned value is represented by the single RHS operand of the
1448 assignment. I suspect there may be cases where gimple_assign_copy_p,
1449 gimple_assign_single_p, or equivalent logic is used where a similar
1450 treatment of unary NOPs is appropriate. */
1453 gimple_assign_unary_nop_p (gimple gs
)
1455 return (is_gimple_assign (gs
)
1456 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs
))
1457 || gimple_assign_rhs_code (gs
) == NON_LVALUE_EXPR
)
1458 && gimple_assign_rhs1 (gs
) != error_mark_node
1459 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs
)))
1460 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs
)))));
1463 /* Set BB to be the basic block holding G. */
1466 gimple_set_bb (gimple stmt
, basic_block bb
)
1470 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1473 /* If the statement is a label, add the label to block-to-labels map
1474 so that we can speed up edge creation for GIMPLE_GOTOs. */
1480 t
= gimple_label_label (stmt
);
1481 uid
= LABEL_DECL_UID (t
);
1485 vec_safe_length (label_to_block_map_for_fn (cfun
));
1486 LABEL_DECL_UID (t
) = uid
= cfun
->cfg
->last_label_uid
++;
1487 if (old_len
<= (unsigned) uid
)
1489 unsigned new_len
= 3 * uid
/ 2 + 1;
1491 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun
),
1496 (*label_to_block_map_for_fn (cfun
))[uid
] = bb
;
1501 /* Modify the RHS of the assignment pointed-to by GSI using the
1502 operands in the expression tree EXPR.
1504 NOTE: The statement pointed-to by GSI may be reallocated if it
1505 did not have enough operand slots.
1507 This function is useful to convert an existing tree expression into
1508 the flat representation used for the RHS of a GIMPLE assignment.
1509 It will reallocate memory as needed to expand or shrink the number
1510 of operand slots needed to represent EXPR.
1512 NOTE: If you find yourself building a tree and then calling this
1513 function, you are most certainly doing it the slow way. It is much
1514 better to build a new assignment or to use the function
1515 gimple_assign_set_rhs_with_ops, which does not require an
1516 expression tree to be built. */
1519 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*gsi
, tree expr
)
1521 enum tree_code subcode
;
1524 extract_ops_from_tree_1 (expr
, &subcode
, &op1
, &op2
, &op3
);
1525 gimple_assign_set_rhs_with_ops_1 (gsi
, subcode
, op1
, op2
, op3
);
1529 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1530 operands OP1, OP2 and OP3.
1532 NOTE: The statement pointed-to by GSI may be reallocated if it
1533 did not have enough operand slots. */
1536 gimple_assign_set_rhs_with_ops_1 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
1537 tree op1
, tree op2
, tree op3
)
1539 unsigned new_rhs_ops
= get_gimple_rhs_num_ops (code
);
1540 gimple stmt
= gsi_stmt (*gsi
);
1542 /* If the new CODE needs more operands, allocate a new statement. */
1543 if (gimple_num_ops (stmt
) < new_rhs_ops
+ 1)
1545 tree lhs
= gimple_assign_lhs (stmt
);
1546 gimple new_stmt
= gimple_alloc (gimple_code (stmt
), new_rhs_ops
+ 1);
1547 memcpy (new_stmt
, stmt
, gimple_size (gimple_code (stmt
)));
1548 gimple_init_singleton (new_stmt
);
1549 gsi_replace (gsi
, new_stmt
, true);
1552 /* The LHS needs to be reset as this also changes the SSA name
1554 gimple_assign_set_lhs (stmt
, lhs
);
1557 gimple_set_num_ops (stmt
, new_rhs_ops
+ 1);
1558 gimple_set_subcode (stmt
, code
);
1559 gimple_assign_set_rhs1 (stmt
, op1
);
1560 if (new_rhs_ops
> 1)
1561 gimple_assign_set_rhs2 (stmt
, op2
);
1562 if (new_rhs_ops
> 2)
1563 gimple_assign_set_rhs3 (stmt
, op3
);
1567 /* Return the LHS of a statement that performs an assignment,
1568 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1569 for a call to a function that returns no value, or for a
1570 statement other than an assignment or a call. */
1573 gimple_get_lhs (const_gimple stmt
)
1575 enum gimple_code code
= gimple_code (stmt
);
1577 if (code
== GIMPLE_ASSIGN
)
1578 return gimple_assign_lhs (stmt
);
1579 else if (code
== GIMPLE_CALL
)
1580 return gimple_call_lhs (stmt
);
1586 /* Set the LHS of a statement that performs an assignment,
1587 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1590 gimple_set_lhs (gimple stmt
, tree lhs
)
1592 enum gimple_code code
= gimple_code (stmt
);
1594 if (code
== GIMPLE_ASSIGN
)
1595 gimple_assign_set_lhs (stmt
, lhs
);
1596 else if (code
== GIMPLE_CALL
)
1597 gimple_call_set_lhs (stmt
, lhs
);
1603 /* Return a deep copy of statement STMT. All the operands from STMT
1604 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1605 and VUSE operand arrays are set to empty in the new copy. The new
1606 copy isn't part of any sequence. */
1609 gimple_copy (gimple stmt
)
1611 enum gimple_code code
= gimple_code (stmt
);
1612 unsigned num_ops
= gimple_num_ops (stmt
);
1613 gimple copy
= gimple_alloc (code
, num_ops
);
1616 /* Shallow copy all the fields from STMT. */
1617 memcpy (copy
, stmt
, gimple_size (code
));
1618 gimple_init_singleton (copy
);
1620 /* If STMT has sub-statements, deep-copy them as well. */
1621 if (gimple_has_substatements (stmt
))
1626 switch (gimple_code (stmt
))
1629 new_seq
= gimple_seq_copy (gimple_bind_body (stmt
));
1630 gimple_bind_set_body (copy
, new_seq
);
1631 gimple_bind_set_vars (copy
, unshare_expr (gimple_bind_vars (stmt
)));
1632 gimple_bind_set_block (copy
, gimple_bind_block (stmt
));
1636 new_seq
= gimple_seq_copy (gimple_catch_handler (stmt
));
1637 gimple_catch_set_handler (copy
, new_seq
);
1638 t
= unshare_expr (gimple_catch_types (stmt
));
1639 gimple_catch_set_types (copy
, t
);
1642 case GIMPLE_EH_FILTER
:
1643 new_seq
= gimple_seq_copy (gimple_eh_filter_failure (stmt
));
1644 gimple_eh_filter_set_failure (copy
, new_seq
);
1645 t
= unshare_expr (gimple_eh_filter_types (stmt
));
1646 gimple_eh_filter_set_types (copy
, t
);
1649 case GIMPLE_EH_ELSE
:
1650 new_seq
= gimple_seq_copy (gimple_eh_else_n_body (stmt
));
1651 gimple_eh_else_set_n_body (copy
, new_seq
);
1652 new_seq
= gimple_seq_copy (gimple_eh_else_e_body (stmt
));
1653 gimple_eh_else_set_e_body (copy
, new_seq
);
1657 new_seq
= gimple_seq_copy (gimple_try_eval (stmt
));
1658 gimple_try_set_eval (copy
, new_seq
);
1659 new_seq
= gimple_seq_copy (gimple_try_cleanup (stmt
));
1660 gimple_try_set_cleanup (copy
, new_seq
);
1663 case GIMPLE_OMP_FOR
:
1664 new_seq
= gimple_seq_copy (gimple_omp_for_pre_body (stmt
));
1665 gimple_omp_for_set_pre_body (copy
, new_seq
);
1666 t
= unshare_expr (gimple_omp_for_clauses (stmt
));
1667 gimple_omp_for_set_clauses (copy
, t
);
1669 gimple_statement_omp_for
*omp_for_copy
=
1670 as_a
<gimple_statement_omp_for
> (copy
);
1671 omp_for_copy
->iter
=
1672 static_cast <struct gimple_omp_for_iter
*> (
1673 ggc_internal_vec_alloc_stat (sizeof (struct gimple_omp_for_iter
),
1674 gimple_omp_for_collapse (stmt
)
1677 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1679 gimple_omp_for_set_cond (copy
, i
,
1680 gimple_omp_for_cond (stmt
, i
));
1681 gimple_omp_for_set_index (copy
, i
,
1682 gimple_omp_for_index (stmt
, i
));
1683 t
= unshare_expr (gimple_omp_for_initial (stmt
, i
));
1684 gimple_omp_for_set_initial (copy
, i
, t
);
1685 t
= unshare_expr (gimple_omp_for_final (stmt
, i
));
1686 gimple_omp_for_set_final (copy
, i
, t
);
1687 t
= unshare_expr (gimple_omp_for_incr (stmt
, i
));
1688 gimple_omp_for_set_incr (copy
, i
, t
);
1692 case GIMPLE_OMP_PARALLEL
:
1693 t
= unshare_expr (gimple_omp_parallel_clauses (stmt
));
1694 gimple_omp_parallel_set_clauses (copy
, t
);
1695 t
= unshare_expr (gimple_omp_parallel_child_fn (stmt
));
1696 gimple_omp_parallel_set_child_fn (copy
, t
);
1697 t
= unshare_expr (gimple_omp_parallel_data_arg (stmt
));
1698 gimple_omp_parallel_set_data_arg (copy
, t
);
1701 case GIMPLE_OMP_TASK
:
1702 t
= unshare_expr (gimple_omp_task_clauses (stmt
));
1703 gimple_omp_task_set_clauses (copy
, t
);
1704 t
= unshare_expr (gimple_omp_task_child_fn (stmt
));
1705 gimple_omp_task_set_child_fn (copy
, t
);
1706 t
= unshare_expr (gimple_omp_task_data_arg (stmt
));
1707 gimple_omp_task_set_data_arg (copy
, t
);
1708 t
= unshare_expr (gimple_omp_task_copy_fn (stmt
));
1709 gimple_omp_task_set_copy_fn (copy
, t
);
1710 t
= unshare_expr (gimple_omp_task_arg_size (stmt
));
1711 gimple_omp_task_set_arg_size (copy
, t
);
1712 t
= unshare_expr (gimple_omp_task_arg_align (stmt
));
1713 gimple_omp_task_set_arg_align (copy
, t
);
1716 case GIMPLE_OMP_CRITICAL
:
1717 t
= unshare_expr (gimple_omp_critical_name (stmt
));
1718 gimple_omp_critical_set_name (copy
, t
);
1721 case GIMPLE_OMP_SECTIONS
:
1722 t
= unshare_expr (gimple_omp_sections_clauses (stmt
));
1723 gimple_omp_sections_set_clauses (copy
, t
);
1724 t
= unshare_expr (gimple_omp_sections_control (stmt
));
1725 gimple_omp_sections_set_control (copy
, t
);
1728 case GIMPLE_OMP_SINGLE
:
1729 case GIMPLE_OMP_TARGET
:
1730 case GIMPLE_OMP_TEAMS
:
1731 case GIMPLE_OMP_SECTION
:
1732 case GIMPLE_OMP_MASTER
:
1733 case GIMPLE_OMP_TASKGROUP
:
1734 case GIMPLE_OMP_ORDERED
:
1736 new_seq
= gimple_seq_copy (gimple_omp_body (stmt
));
1737 gimple_omp_set_body (copy
, new_seq
);
1740 case GIMPLE_TRANSACTION
:
1741 new_seq
= gimple_seq_copy (gimple_transaction_body (stmt
));
1742 gimple_transaction_set_body (copy
, new_seq
);
1745 case GIMPLE_WITH_CLEANUP_EXPR
:
1746 new_seq
= gimple_seq_copy (gimple_wce_cleanup (stmt
));
1747 gimple_wce_set_cleanup (copy
, new_seq
);
1755 /* Make copy of operands. */
1756 for (i
= 0; i
< num_ops
; i
++)
1757 gimple_set_op (copy
, i
, unshare_expr (gimple_op (stmt
, i
)));
1759 if (gimple_has_mem_ops (stmt
))
1761 gimple_set_vdef (copy
, gimple_vdef (stmt
));
1762 gimple_set_vuse (copy
, gimple_vuse (stmt
));
1765 /* Clear out SSA operand vectors on COPY. */
1766 if (gimple_has_ops (stmt
))
1768 gimple_set_use_ops (copy
, NULL
);
1770 /* SSA operands need to be updated. */
1771 gimple_set_modified (copy
, true);
1778 /* Return true if statement S has side-effects. We consider a
1779 statement to have side effects if:
1781 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
1782 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
1785 gimple_has_side_effects (const_gimple s
)
1787 if (is_gimple_debug (s
))
1790 /* We don't have to scan the arguments to check for
1791 volatile arguments, though, at present, we still
1792 do a scan to check for TREE_SIDE_EFFECTS. */
1793 if (gimple_has_volatile_ops (s
))
1796 if (gimple_code (s
) == GIMPLE_ASM
1797 && gimple_asm_volatile_p (s
))
1800 if (is_gimple_call (s
))
1802 int flags
= gimple_call_flags (s
);
1804 /* An infinite loop is considered a side effect. */
1805 if (!(flags
& (ECF_CONST
| ECF_PURE
))
1806 || (flags
& ECF_LOOPING_CONST_OR_PURE
))
1815 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
1816 Return true if S can trap. When INCLUDE_MEM is true, check whether
1817 the memory operations could trap. When INCLUDE_STORES is true and
1818 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
1821 gimple_could_trap_p_1 (gimple s
, bool include_mem
, bool include_stores
)
1823 tree t
, div
= NULL_TREE
;
1828 unsigned i
, start
= (is_gimple_assign (s
) && !include_stores
) ? 1 : 0;
1830 for (i
= start
; i
< gimple_num_ops (s
); i
++)
1831 if (tree_could_trap_p (gimple_op (s
, i
)))
1835 switch (gimple_code (s
))
1838 return gimple_asm_volatile_p (s
);
1841 t
= gimple_call_fndecl (s
);
1842 /* Assume that calls to weak functions may trap. */
1843 if (!t
|| !DECL_P (t
) || DECL_WEAK (t
))
1848 t
= gimple_expr_type (s
);
1849 op
= gimple_assign_rhs_code (s
);
1850 if (get_gimple_rhs_class (op
) == GIMPLE_BINARY_RHS
)
1851 div
= gimple_assign_rhs2 (s
);
1852 return (operation_could_trap_p (op
, FLOAT_TYPE_P (t
),
1853 (INTEGRAL_TYPE_P (t
)
1854 && TYPE_OVERFLOW_TRAPS (t
)),
1864 /* Return true if statement S can trap. */
1867 gimple_could_trap_p (gimple s
)
1869 return gimple_could_trap_p_1 (s
, true, true);
1872 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
1875 gimple_assign_rhs_could_trap_p (gimple s
)
1877 gcc_assert (is_gimple_assign (s
));
1878 return gimple_could_trap_p_1 (s
, true, false);
1882 /* Print debugging information for gimple stmts generated. */
1885 dump_gimple_statistics (void)
1887 int i
, total_tuples
= 0, total_bytes
= 0;
1889 if (! GATHER_STATISTICS
)
1891 fprintf (stderr
, "No gimple statistics\n");
1895 fprintf (stderr
, "\nGIMPLE statements\n");
1896 fprintf (stderr
, "Kind Stmts Bytes\n");
1897 fprintf (stderr
, "---------------------------------------\n");
1898 for (i
= 0; i
< (int) gimple_alloc_kind_all
; ++i
)
1900 fprintf (stderr
, "%-20s %7d %10d\n", gimple_alloc_kind_names
[i
],
1901 gimple_alloc_counts
[i
], gimple_alloc_sizes
[i
]);
1902 total_tuples
+= gimple_alloc_counts
[i
];
1903 total_bytes
+= gimple_alloc_sizes
[i
];
1905 fprintf (stderr
, "---------------------------------------\n");
1906 fprintf (stderr
, "%-20s %7d %10d\n", "Total", total_tuples
, total_bytes
);
1907 fprintf (stderr
, "---------------------------------------\n");
1911 /* Return the number of operands needed on the RHS of a GIMPLE
1912 assignment for an expression with tree code CODE. */
1915 get_gimple_rhs_num_ops (enum tree_code code
)
1917 enum gimple_rhs_class rhs_class
= get_gimple_rhs_class (code
);
1919 if (rhs_class
== GIMPLE_UNARY_RHS
|| rhs_class
== GIMPLE_SINGLE_RHS
)
1921 else if (rhs_class
== GIMPLE_BINARY_RHS
)
1923 else if (rhs_class
== GIMPLE_TERNARY_RHS
)
1929 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
1931 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
1932 : ((TYPE) == tcc_binary \
1933 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
1934 : ((TYPE) == tcc_constant \
1935 || (TYPE) == tcc_declaration \
1936 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
1937 : ((SYM) == TRUTH_AND_EXPR \
1938 || (SYM) == TRUTH_OR_EXPR \
1939 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
1940 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
1941 : ((SYM) == COND_EXPR \
1942 || (SYM) == WIDEN_MULT_PLUS_EXPR \
1943 || (SYM) == WIDEN_MULT_MINUS_EXPR \
1944 || (SYM) == DOT_PROD_EXPR \
1945 || (SYM) == REALIGN_LOAD_EXPR \
1946 || (SYM) == VEC_COND_EXPR \
1947 || (SYM) == VEC_PERM_EXPR \
1948 || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS \
1949 : ((SYM) == CONSTRUCTOR \
1950 || (SYM) == OBJ_TYPE_REF \
1951 || (SYM) == ASSERT_EXPR \
1952 || (SYM) == ADDR_EXPR \
1953 || (SYM) == WITH_SIZE_EXPR \
1954 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
1955 : GIMPLE_INVALID_RHS),
1956 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
1958 const unsigned char gimple_rhs_class_table
[] = {
1959 #include "all-tree.def"
1963 #undef END_OF_BASE_TREE_CODES
1965 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
1966 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
1967 we failed to create one. */
1970 canonicalize_cond_expr_cond (tree t
)
1972 /* Strip conversions around boolean operations. */
1973 if (CONVERT_EXPR_P (t
)
1974 && (truth_value_p (TREE_CODE (TREE_OPERAND (t
, 0)))
1975 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
1977 t
= TREE_OPERAND (t
, 0);
1979 /* For !x use x == 0. */
1980 if (TREE_CODE (t
) == TRUTH_NOT_EXPR
)
1982 tree top0
= TREE_OPERAND (t
, 0);
1983 t
= build2 (EQ_EXPR
, TREE_TYPE (t
),
1984 top0
, build_int_cst (TREE_TYPE (top0
), 0));
1986 /* For cmp ? 1 : 0 use cmp. */
1987 else if (TREE_CODE (t
) == COND_EXPR
1988 && COMPARISON_CLASS_P (TREE_OPERAND (t
, 0))
1989 && integer_onep (TREE_OPERAND (t
, 1))
1990 && integer_zerop (TREE_OPERAND (t
, 2)))
1992 tree top0
= TREE_OPERAND (t
, 0);
1993 t
= build2 (TREE_CODE (top0
), TREE_TYPE (t
),
1994 TREE_OPERAND (top0
, 0), TREE_OPERAND (top0
, 1));
1996 /* For x ^ y use x != y. */
1997 else if (TREE_CODE (t
) == BIT_XOR_EXPR
)
1998 t
= build2 (NE_EXPR
, TREE_TYPE (t
),
1999 TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1));
2001 if (is_gimple_condexpr (t
))
2007 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2008 the positions marked by the set ARGS_TO_SKIP. */
2011 gimple_call_copy_skip_args (gimple stmt
, bitmap args_to_skip
)
2014 int nargs
= gimple_call_num_args (stmt
);
2015 auto_vec
<tree
> vargs (nargs
);
2018 for (i
= 0; i
< nargs
; i
++)
2019 if (!bitmap_bit_p (args_to_skip
, i
))
2020 vargs
.quick_push (gimple_call_arg (stmt
, i
));
2022 if (gimple_call_internal_p (stmt
))
2023 new_stmt
= gimple_build_call_internal_vec (gimple_call_internal_fn (stmt
),
2026 new_stmt
= gimple_build_call_vec (gimple_call_fn (stmt
), vargs
);
2028 if (gimple_call_lhs (stmt
))
2029 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2031 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2032 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
2034 if (gimple_has_location (stmt
))
2035 gimple_set_location (new_stmt
, gimple_location (stmt
));
2036 gimple_call_copy_flags (new_stmt
, stmt
);
2037 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2039 gimple_set_modified (new_stmt
, true);
2046 /* Return true if the field decls F1 and F2 are at the same offset.
2048 This is intended to be used on GIMPLE types only. */
2051 gimple_compare_field_offset (tree f1
, tree f2
)
2053 if (DECL_OFFSET_ALIGN (f1
) == DECL_OFFSET_ALIGN (f2
))
2055 tree offset1
= DECL_FIELD_OFFSET (f1
);
2056 tree offset2
= DECL_FIELD_OFFSET (f2
);
2057 return ((offset1
== offset2
2058 /* Once gimplification is done, self-referential offsets are
2059 instantiated as operand #2 of the COMPONENT_REF built for
2060 each access and reset. Therefore, they are not relevant
2061 anymore and fields are interchangeable provided that they
2062 represent the same access. */
2063 || (TREE_CODE (offset1
) == PLACEHOLDER_EXPR
2064 && TREE_CODE (offset2
) == PLACEHOLDER_EXPR
2065 && (DECL_SIZE (f1
) == DECL_SIZE (f2
)
2066 || (TREE_CODE (DECL_SIZE (f1
)) == PLACEHOLDER_EXPR
2067 && TREE_CODE (DECL_SIZE (f2
)) == PLACEHOLDER_EXPR
)
2068 || operand_equal_p (DECL_SIZE (f1
), DECL_SIZE (f2
), 0))
2069 && DECL_ALIGN (f1
) == DECL_ALIGN (f2
))
2070 || operand_equal_p (offset1
, offset2
, 0))
2071 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1
),
2072 DECL_FIELD_BIT_OFFSET (f2
)));
2075 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2076 should be, so handle differing ones specially by decomposing
2077 the offset into a byte and bit offset manually. */
2078 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1
))
2079 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2
)))
2081 unsigned HOST_WIDE_INT byte_offset1
, byte_offset2
;
2082 unsigned HOST_WIDE_INT bit_offset1
, bit_offset2
;
2083 bit_offset1
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1
));
2084 byte_offset1
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1
))
2085 + bit_offset1
/ BITS_PER_UNIT
);
2086 bit_offset2
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2
));
2087 byte_offset2
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2
))
2088 + bit_offset2
/ BITS_PER_UNIT
);
2089 if (byte_offset1
!= byte_offset2
)
2091 return bit_offset1
% BITS_PER_UNIT
== bit_offset2
% BITS_PER_UNIT
;
2098 /* Return a type the same as TYPE except unsigned or
2099 signed according to UNSIGNEDP. */
2102 gimple_signed_or_unsigned_type (bool unsignedp
, tree type
)
2106 type1
= TYPE_MAIN_VARIANT (type
);
2107 if (type1
== signed_char_type_node
2108 || type1
== char_type_node
2109 || type1
== unsigned_char_type_node
)
2110 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2111 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2112 return unsignedp
? unsigned_type_node
: integer_type_node
;
2113 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2114 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2115 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2116 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2117 if (type1
== long_long_integer_type_node
2118 || type1
== long_long_unsigned_type_node
)
2120 ? long_long_unsigned_type_node
2121 : long_long_integer_type_node
;
2122 if (int128_integer_type_node
&& (type1
== int128_integer_type_node
|| type1
== int128_unsigned_type_node
))
2124 ? int128_unsigned_type_node
2125 : int128_integer_type_node
;
2126 #if HOST_BITS_PER_WIDE_INT >= 64
2127 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2128 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2130 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2131 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2132 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2133 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2134 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2135 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2136 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2137 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2139 #define GIMPLE_FIXED_TYPES(NAME) \
2140 if (type1 == short_ ## NAME ## _type_node \
2141 || type1 == unsigned_short_ ## NAME ## _type_node) \
2142 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2143 : short_ ## NAME ## _type_node; \
2144 if (type1 == NAME ## _type_node \
2145 || type1 == unsigned_ ## NAME ## _type_node) \
2146 return unsignedp ? unsigned_ ## NAME ## _type_node \
2147 : NAME ## _type_node; \
2148 if (type1 == long_ ## NAME ## _type_node \
2149 || type1 == unsigned_long_ ## NAME ## _type_node) \
2150 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2151 : long_ ## NAME ## _type_node; \
2152 if (type1 == long_long_ ## NAME ## _type_node \
2153 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2154 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2155 : long_long_ ## NAME ## _type_node;
2157 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2158 if (type1 == NAME ## _type_node \
2159 || type1 == u ## NAME ## _type_node) \
2160 return unsignedp ? u ## NAME ## _type_node \
2161 : NAME ## _type_node;
2163 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2164 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2165 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2166 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2167 : sat_ ## short_ ## NAME ## _type_node; \
2168 if (type1 == sat_ ## NAME ## _type_node \
2169 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2170 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2171 : sat_ ## NAME ## _type_node; \
2172 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2173 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2174 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2175 : sat_ ## long_ ## NAME ## _type_node; \
2176 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2177 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2178 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2179 : sat_ ## long_long_ ## NAME ## _type_node;
2181 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2182 if (type1 == sat_ ## NAME ## _type_node \
2183 || type1 == sat_ ## u ## NAME ## _type_node) \
2184 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2185 : sat_ ## NAME ## _type_node;
2187 GIMPLE_FIXED_TYPES (fract
);
2188 GIMPLE_FIXED_TYPES_SAT (fract
);
2189 GIMPLE_FIXED_TYPES (accum
);
2190 GIMPLE_FIXED_TYPES_SAT (accum
);
2192 GIMPLE_FIXED_MODE_TYPES (qq
);
2193 GIMPLE_FIXED_MODE_TYPES (hq
);
2194 GIMPLE_FIXED_MODE_TYPES (sq
);
2195 GIMPLE_FIXED_MODE_TYPES (dq
);
2196 GIMPLE_FIXED_MODE_TYPES (tq
);
2197 GIMPLE_FIXED_MODE_TYPES_SAT (qq
);
2198 GIMPLE_FIXED_MODE_TYPES_SAT (hq
);
2199 GIMPLE_FIXED_MODE_TYPES_SAT (sq
);
2200 GIMPLE_FIXED_MODE_TYPES_SAT (dq
);
2201 GIMPLE_FIXED_MODE_TYPES_SAT (tq
);
2202 GIMPLE_FIXED_MODE_TYPES (ha
);
2203 GIMPLE_FIXED_MODE_TYPES (sa
);
2204 GIMPLE_FIXED_MODE_TYPES (da
);
2205 GIMPLE_FIXED_MODE_TYPES (ta
);
2206 GIMPLE_FIXED_MODE_TYPES_SAT (ha
);
2207 GIMPLE_FIXED_MODE_TYPES_SAT (sa
);
2208 GIMPLE_FIXED_MODE_TYPES_SAT (da
);
2209 GIMPLE_FIXED_MODE_TYPES_SAT (ta
);
2211 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2212 the precision; they have precision set to match their range, but
2213 may use a wider mode to match an ABI. If we change modes, we may
2214 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2215 the precision as well, so as to yield correct results for
2216 bit-field types. C++ does not have these separate bit-field
2217 types, and producing a signed or unsigned variant of an
2218 ENUMERAL_TYPE may cause other problems as well. */
2219 if (!INTEGRAL_TYPE_P (type
)
2220 || TYPE_UNSIGNED (type
) == unsignedp
)
2223 #define TYPE_OK(node) \
2224 (TYPE_MODE (type) == TYPE_MODE (node) \
2225 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2226 if (TYPE_OK (signed_char_type_node
))
2227 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2228 if (TYPE_OK (integer_type_node
))
2229 return unsignedp
? unsigned_type_node
: integer_type_node
;
2230 if (TYPE_OK (short_integer_type_node
))
2231 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2232 if (TYPE_OK (long_integer_type_node
))
2233 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2234 if (TYPE_OK (long_long_integer_type_node
))
2236 ? long_long_unsigned_type_node
2237 : long_long_integer_type_node
);
2238 if (int128_integer_type_node
&& TYPE_OK (int128_integer_type_node
))
2240 ? int128_unsigned_type_node
2241 : int128_integer_type_node
);
2243 #if HOST_BITS_PER_WIDE_INT >= 64
2244 if (TYPE_OK (intTI_type_node
))
2245 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2247 if (TYPE_OK (intDI_type_node
))
2248 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2249 if (TYPE_OK (intSI_type_node
))
2250 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2251 if (TYPE_OK (intHI_type_node
))
2252 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2253 if (TYPE_OK (intQI_type_node
))
2254 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2256 #undef GIMPLE_FIXED_TYPES
2257 #undef GIMPLE_FIXED_MODE_TYPES
2258 #undef GIMPLE_FIXED_TYPES_SAT
2259 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2262 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2266 /* Return an unsigned type the same as TYPE in other respects. */
2269 gimple_unsigned_type (tree type
)
2271 return gimple_signed_or_unsigned_type (true, type
);
2275 /* Return a signed type the same as TYPE in other respects. */
2278 gimple_signed_type (tree type
)
2280 return gimple_signed_or_unsigned_type (false, type
);
2284 /* Return the typed-based alias set for T, which may be an expression
2285 or a type. Return -1 if we don't do anything special. */
2288 gimple_get_alias_set (tree t
)
2292 /* Permit type-punning when accessing a union, provided the access
2293 is directly through the union. For example, this code does not
2294 permit taking the address of a union member and then storing
2295 through it. Even the type-punning allowed here is a GCC
2296 extension, albeit a common and useful one; the C standard says
2297 that such accesses have implementation-defined behavior. */
2299 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2300 u
= TREE_OPERAND (u
, 0))
2301 if (TREE_CODE (u
) == COMPONENT_REF
2302 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2305 /* That's all the expressions we handle specially. */
2309 /* For convenience, follow the C standard when dealing with
2310 character types. Any object may be accessed via an lvalue that
2311 has character type. */
2312 if (t
== char_type_node
2313 || t
== signed_char_type_node
2314 || t
== unsigned_char_type_node
)
2317 /* Allow aliasing between signed and unsigned variants of the same
2318 type. We treat the signed variant as canonical. */
2319 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2321 tree t1
= gimple_signed_type (t
);
2323 /* t1 == t can happen for boolean nodes which are always unsigned. */
2325 return get_alias_set (t1
);
2332 /* Helper for gimple_ior_addresses_taken_1. */
2335 gimple_ior_addresses_taken_1 (gimple
, tree addr
, tree
, void *data
)
2337 bitmap addresses_taken
= (bitmap
)data
;
2338 addr
= get_base_address (addr
);
2342 bitmap_set_bit (addresses_taken
, DECL_UID (addr
));
2348 /* Set the bit for the uid of all decls that have their address taken
2349 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2350 were any in this stmt. */
2353 gimple_ior_addresses_taken (bitmap addresses_taken
, gimple stmt
)
2355 return walk_stmt_load_store_addr_ops (stmt
, addresses_taken
, NULL
, NULL
,
2356 gimple_ior_addresses_taken_1
);
2360 /* Return true if TYPE1 and TYPE2 are compatible enough for builtin
2364 validate_type (tree type1
, tree type2
)
2366 if (INTEGRAL_TYPE_P (type1
)
2367 && INTEGRAL_TYPE_P (type2
))
2369 else if (POINTER_TYPE_P (type1
)
2370 && POINTER_TYPE_P (type2
))
2372 else if (TREE_CODE (type1
)
2373 != TREE_CODE (type2
))
2378 /* Return true when STMTs arguments and return value match those of FNDECL,
2379 a decl of a builtin function. */
2382 gimple_builtin_call_types_compatible_p (gimple stmt
, tree fndecl
)
2384 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
);
2386 tree ret
= gimple_call_lhs (stmt
);
2388 && !validate_type (TREE_TYPE (ret
), TREE_TYPE (TREE_TYPE (fndecl
))))
2391 tree targs
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2392 unsigned nargs
= gimple_call_num_args (stmt
);
2393 for (unsigned i
= 0; i
< nargs
; ++i
)
2395 /* Variadic args follow. */
2398 tree arg
= gimple_call_arg (stmt
, i
);
2399 if (!validate_type (TREE_TYPE (arg
), TREE_VALUE (targs
)))
2401 targs
= TREE_CHAIN (targs
);
2403 if (targs
&& !VOID_TYPE_P (TREE_VALUE (targs
)))
2408 /* Return true when STMT is builtins call. */
2411 gimple_call_builtin_p (gimple stmt
)
2414 if (is_gimple_call (stmt
)
2415 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2416 && DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
)
2417 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2421 /* Return true when STMT is builtins call to CLASS. */
2424 gimple_call_builtin_p (gimple stmt
, enum built_in_class klass
)
2427 if (is_gimple_call (stmt
)
2428 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2429 && DECL_BUILT_IN_CLASS (fndecl
) == klass
)
2430 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2434 /* Return true when STMT is builtins call to CODE of CLASS. */
2437 gimple_call_builtin_p (gimple stmt
, enum built_in_function code
)
2440 if (is_gimple_call (stmt
)
2441 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2442 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
2443 && DECL_FUNCTION_CODE (fndecl
) == code
)
2444 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2448 /* Return true if STMT clobbers memory. STMT is required to be a
2452 gimple_asm_clobbers_memory_p (const_gimple stmt
)
2456 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
2458 tree op
= gimple_asm_clobber_op (stmt
, i
);
2459 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op
)), "memory") == 0)
2466 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2469 dump_decl_set (FILE *file
, bitmap set
)
2476 fprintf (file
, "{ ");
2478 EXECUTE_IF_SET_IN_BITMAP (set
, 0, i
, bi
)
2480 fprintf (file
, "D.%u", i
);
2481 fprintf (file
, " ");
2484 fprintf (file
, "}");
2487 fprintf (file
, "NIL");
2490 /* Return true when CALL is a call stmt that definitely doesn't
2491 free any memory or makes it unavailable otherwise. */
2493 nonfreeing_call_p (gimple call
)
2495 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2496 && gimple_call_flags (call
) & ECF_LEAF
)
2497 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call
)))
2499 /* Just in case these become ECF_LEAF in the future. */
2501 case BUILT_IN_TM_FREE
:
2502 case BUILT_IN_REALLOC
:
2503 case BUILT_IN_STACK_RESTORE
:
2512 /* Callback for walk_stmt_load_store_ops.
2514 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2517 This routine only makes a superficial check for a dereference. Thus
2518 it must only be used if it is safe to return a false negative. */
2520 check_loadstore (gimple
, tree op
, tree
, void *data
)
2522 if ((TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
2523 && operand_equal_p (TREE_OPERAND (op
, 0), (tree
)data
, 0))
2528 /* If OP can be inferred to be non-NULL after STMT executes, return true.
2530 DEREFERENCE is TRUE if we can use a pointer dereference to infer a
2531 non-NULL range, FALSE otherwise.
2533 ATTRIBUTE is TRUE if we can use attributes to infer a non-NULL range
2534 for function arguments and return values. FALSE otherwise. */
2537 infer_nonnull_range (gimple stmt
, tree op
, bool dereference
, bool attribute
)
2539 /* We can only assume that a pointer dereference will yield
2540 non-NULL if -fdelete-null-pointer-checks is enabled. */
2541 if (!flag_delete_null_pointer_checks
2542 || !POINTER_TYPE_P (TREE_TYPE (op
))
2543 || gimple_code (stmt
) == GIMPLE_ASM
)
2547 && walk_stmt_load_store_ops (stmt
, (void *)op
,
2548 check_loadstore
, check_loadstore
))
2552 && is_gimple_call (stmt
) && !gimple_call_internal_p (stmt
))
2554 tree fntype
= gimple_call_fntype (stmt
);
2555 tree attrs
= TYPE_ATTRIBUTES (fntype
);
2556 for (; attrs
; attrs
= TREE_CHAIN (attrs
))
2558 attrs
= lookup_attribute ("nonnull", attrs
);
2560 /* If "nonnull" wasn't specified, we know nothing about
2562 if (attrs
== NULL_TREE
)
2565 /* If "nonnull" applies to all the arguments, then ARG
2566 is non-null if it's in the argument list. */
2567 if (TREE_VALUE (attrs
) == NULL_TREE
)
2569 for (unsigned int i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2571 if (operand_equal_p (op
, gimple_call_arg (stmt
, i
), 0)
2572 && POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt
, i
))))
2578 /* Now see if op appears in the nonnull list. */
2579 for (tree t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
2581 int idx
= TREE_INT_CST_LOW (TREE_VALUE (t
)) - 1;
2582 tree arg
= gimple_call_arg (stmt
, idx
);
2583 if (operand_equal_p (op
, arg
, 0))
2589 /* If this function is marked as returning non-null, then we can
2590 infer OP is non-null if it is used in the return statement. */
2592 && gimple_code (stmt
) == GIMPLE_RETURN
2593 && gimple_return_retval (stmt
)
2594 && operand_equal_p (gimple_return_retval (stmt
), op
, 0)
2595 && lookup_attribute ("returns_nonnull",
2596 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
))))
2602 /* Compare two case labels. Because the front end should already have
2603 made sure that case ranges do not overlap, it is enough to only compare
2604 the CASE_LOW values of each case label. */
2607 compare_case_labels (const void *p1
, const void *p2
)
2609 const_tree
const case1
= *(const_tree
const*)p1
;
2610 const_tree
const case2
= *(const_tree
const*)p2
;
2612 /* The 'default' case label always goes first. */
2613 if (!CASE_LOW (case1
))
2615 else if (!CASE_LOW (case2
))
2618 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
2621 /* Sort the case labels in LABEL_VEC in place in ascending order. */
2624 sort_case_labels (vec
<tree
> label_vec
)
2626 label_vec
.qsort (compare_case_labels
);
2629 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2631 LABELS is a vector that contains all case labels to look at.
2633 INDEX_TYPE is the type of the switch index expression. Case labels
2634 in LABELS are discarded if their values are not in the value range
2635 covered by INDEX_TYPE. The remaining case label values are folded
2638 If a default case exists in LABELS, it is removed from LABELS and
2639 returned in DEFAULT_CASEP. If no default case exists, but the
2640 case labels already cover the whole range of INDEX_TYPE, a default
2641 case is returned pointing to one of the existing case labels.
2642 Otherwise DEFAULT_CASEP is set to NULL_TREE.
2644 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2645 apply and no action is taken regardless of whether a default case is
2649 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
2651 tree
*default_casep
)
2653 tree min_value
, max_value
;
2654 tree default_case
= NULL_TREE
;
2658 min_value
= TYPE_MIN_VALUE (index_type
);
2659 max_value
= TYPE_MAX_VALUE (index_type
);
2660 while (i
< labels
.length ())
2662 tree elt
= labels
[i
];
2663 tree low
= CASE_LOW (elt
);
2664 tree high
= CASE_HIGH (elt
);
2665 bool remove_element
= FALSE
;
2669 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
2670 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
2672 /* This is a non-default case label, i.e. it has a value.
2674 See if the case label is reachable within the range of
2675 the index type. Remove out-of-range case values. Turn
2676 case ranges into a canonical form (high > low strictly)
2677 and convert the case label values to the index type.
2679 NB: The type of gimple_switch_index() may be the promoted
2680 type, but the case labels retain the original type. */
2684 /* This is a case range. Discard empty ranges.
2685 If the bounds or the range are equal, turn this
2686 into a simple (one-value) case. */
2687 int cmp
= tree_int_cst_compare (high
, low
);
2689 remove_element
= TRUE
;
2696 /* If the simple case value is unreachable, ignore it. */
2697 if ((TREE_CODE (min_value
) == INTEGER_CST
2698 && tree_int_cst_compare (low
, min_value
) < 0)
2699 || (TREE_CODE (max_value
) == INTEGER_CST
2700 && tree_int_cst_compare (low
, max_value
) > 0))
2701 remove_element
= TRUE
;
2703 low
= fold_convert (index_type
, low
);
2707 /* If the entire case range is unreachable, ignore it. */
2708 if ((TREE_CODE (min_value
) == INTEGER_CST
2709 && tree_int_cst_compare (high
, min_value
) < 0)
2710 || (TREE_CODE (max_value
) == INTEGER_CST
2711 && tree_int_cst_compare (low
, max_value
) > 0))
2712 remove_element
= TRUE
;
2715 /* If the lower bound is less than the index type's
2716 minimum value, truncate the range bounds. */
2717 if (TREE_CODE (min_value
) == INTEGER_CST
2718 && tree_int_cst_compare (low
, min_value
) < 0)
2720 low
= fold_convert (index_type
, low
);
2722 /* If the upper bound is greater than the index type's
2723 maximum value, truncate the range bounds. */
2724 if (TREE_CODE (max_value
) == INTEGER_CST
2725 && tree_int_cst_compare (high
, max_value
) > 0)
2727 high
= fold_convert (index_type
, high
);
2729 /* We may have folded a case range to a one-value case. */
2730 if (tree_int_cst_equal (low
, high
))
2735 CASE_LOW (elt
) = low
;
2736 CASE_HIGH (elt
) = high
;
2740 gcc_assert (!default_case
);
2742 /* The default case must be passed separately to the
2743 gimple_build_switch routine. But if DEFAULT_CASEP
2744 is NULL, we do not remove the default case (it would
2745 be completely lost). */
2747 remove_element
= TRUE
;
2751 labels
.ordered_remove (i
);
2757 if (!labels
.is_empty ())
2758 sort_case_labels (labels
);
2760 if (default_casep
&& !default_case
)
2762 /* If the switch has no default label, add one, so that we jump
2763 around the switch body. If the labels already cover the whole
2764 range of the switch index_type, add the default label pointing
2765 to one of the existing labels. */
2767 && TYPE_MIN_VALUE (index_type
)
2768 && TYPE_MAX_VALUE (index_type
)
2769 && tree_int_cst_equal (CASE_LOW (labels
[0]),
2770 TYPE_MIN_VALUE (index_type
)))
2772 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
2774 high
= CASE_LOW (labels
[len
- 1]);
2775 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
2777 for (i
= 1; i
< len
; i
++)
2779 high
= CASE_LOW (labels
[i
]);
2780 low
= CASE_HIGH (labels
[i
- 1]);
2782 low
= CASE_LOW (labels
[i
- 1]);
2783 if ((TREE_INT_CST_LOW (low
) + 1
2784 != TREE_INT_CST_LOW (high
))
2785 || (TREE_INT_CST_HIGH (low
)
2786 + (TREE_INT_CST_LOW (high
) == 0)
2787 != TREE_INT_CST_HIGH (high
)))
2792 tree label
= CASE_LABEL (labels
[0]);
2793 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
2801 *default_casep
= default_case
;
2804 /* Set the location of all statements in SEQ to LOC. */
2807 gimple_seq_set_location (gimple_seq seq
, location_t loc
)
2809 for (gimple_stmt_iterator i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
2810 gimple_set_location (gsi_stmt (i
), loc
);