1 /* Gimple IR support functions.
3 Copyright (C) 2007-2015 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"
28 #include "hard-reg-set.h"
32 #include "fold-const.h"
35 #include "stor-layout.h"
36 #include "internal-fn.h"
38 #include "gimple-iterator.h"
39 #include "gimple-walk.h"
41 #include "diagnostic.h"
42 #include "value-prof.h"
46 #include "langhooks.h"
50 /* All the tuples have their operand vector (if present) at the very bottom
51 of the structure. Therefore, the offset required to find the
52 operands vector the size of the structure minus the size of the 1
53 element tree array at the end (see gimple_ops). */
54 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
55 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
56 EXPORTED_CONST
size_t gimple_ops_offset_
[] = {
57 #include "gsstruct.def"
61 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
62 static const size_t gsstruct_code_size
[] = {
63 #include "gsstruct.def"
67 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
68 const char *const gimple_code_name
[] = {
73 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
74 EXPORTED_CONST
enum gimple_statement_structure_enum gss_for_code_
[] = {
81 int gimple_alloc_counts
[(int) gimple_alloc_kind_all
];
82 int gimple_alloc_sizes
[(int) gimple_alloc_kind_all
];
84 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
85 static const char * const gimple_alloc_kind_names
[] = {
92 /* Static gimple tuple members. */
93 const enum gimple_code
gassign::code_
;
94 const enum gimple_code
gcall::code_
;
95 const enum gimple_code
gcond::code_
;
98 /* Gimple tuple constructors.
99 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
100 be passed a NULL to start with an empty sequence. */
102 /* Set the code for statement G to CODE. */
105 gimple_set_code (gimple
*g
, enum gimple_code code
)
110 /* Return the number of bytes needed to hold a GIMPLE statement with
114 gimple_size (enum gimple_code code
)
116 return gsstruct_code_size
[gss_for_code (code
)];
119 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
123 gimple_alloc_stat (enum gimple_code code
, unsigned num_ops MEM_STAT_DECL
)
128 size
= gimple_size (code
);
130 size
+= sizeof (tree
) * (num_ops
- 1);
132 if (GATHER_STATISTICS
)
134 enum gimple_alloc_kind kind
= gimple_alloc_kind (code
);
135 gimple_alloc_counts
[(int) kind
]++;
136 gimple_alloc_sizes
[(int) kind
] += size
;
139 stmt
= ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT
);
140 gimple_set_code (stmt
, code
);
141 gimple_set_num_ops (stmt
, num_ops
);
143 /* Do not call gimple_set_modified here as it has other side
144 effects and this tuple is still not completely built. */
146 gimple_init_singleton (stmt
);
151 /* Set SUBCODE to be the code of the expression computed by statement G. */
154 gimple_set_subcode (gimple
*g
, unsigned subcode
)
156 /* We only have 16 bits for the RHS code. Assert that we are not
158 gcc_assert (subcode
< (1 << 16));
159 g
->subcode
= subcode
;
164 /* Build a tuple with operands. CODE is the statement to build (which
165 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
166 for the new tuple. NUM_OPS is the number of operands to allocate. */
168 #define gimple_build_with_ops(c, s, n) \
169 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
172 gimple_build_with_ops_stat (enum gimple_code code
, unsigned subcode
,
173 unsigned num_ops MEM_STAT_DECL
)
175 gimple
*s
= gimple_alloc_stat (code
, num_ops PASS_MEM_STAT
);
176 gimple_set_subcode (s
, subcode
);
182 /* Build a GIMPLE_RETURN statement returning RETVAL. */
185 gimple_build_return (tree retval
)
188 = as_a
<greturn
*> (gimple_build_with_ops (GIMPLE_RETURN
, ERROR_MARK
,
191 gimple_return_set_retval (s
, retval
);
195 /* Reset alias information on call S. */
198 gimple_call_reset_alias_info (gcall
*s
)
200 if (gimple_call_flags (s
) & ECF_CONST
)
201 memset (gimple_call_use_set (s
), 0, sizeof (struct pt_solution
));
203 pt_solution_reset (gimple_call_use_set (s
));
204 if (gimple_call_flags (s
) & (ECF_CONST
|ECF_PURE
|ECF_NOVOPS
))
205 memset (gimple_call_clobber_set (s
), 0, sizeof (struct pt_solution
));
207 pt_solution_reset (gimple_call_clobber_set (s
));
210 /* Helper for gimple_build_call, gimple_build_call_valist,
211 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
212 components of a GIMPLE_CALL statement to function FN with NARGS
215 static inline gcall
*
216 gimple_build_call_1 (tree fn
, unsigned nargs
)
219 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
221 if (TREE_CODE (fn
) == FUNCTION_DECL
)
222 fn
= build_fold_addr_expr (fn
);
223 gimple_set_op (s
, 1, fn
);
224 gimple_call_set_fntype (s
, TREE_TYPE (TREE_TYPE (fn
)));
225 gimple_call_reset_alias_info (s
);
230 /* Build a GIMPLE_CALL statement to function FN with the arguments
231 specified in vector ARGS. */
234 gimple_build_call_vec (tree fn
, vec
<tree
> args
)
237 unsigned nargs
= args
.length ();
238 gcall
*call
= gimple_build_call_1 (fn
, nargs
);
240 for (i
= 0; i
< nargs
; i
++)
241 gimple_call_set_arg (call
, i
, args
[i
]);
247 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
248 arguments. The ... are the arguments. */
251 gimple_build_call (tree fn
, unsigned nargs
, ...)
257 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
259 call
= gimple_build_call_1 (fn
, nargs
);
261 va_start (ap
, nargs
);
262 for (i
= 0; i
< nargs
; i
++)
263 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
270 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
271 arguments. AP contains the arguments. */
274 gimple_build_call_valist (tree fn
, unsigned nargs
, va_list ap
)
279 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
281 call
= gimple_build_call_1 (fn
, nargs
);
283 for (i
= 0; i
< nargs
; i
++)
284 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
290 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
291 Build the basic components of a GIMPLE_CALL statement to internal
292 function FN with NARGS arguments. */
294 static inline gcall
*
295 gimple_build_call_internal_1 (enum internal_fn fn
, unsigned nargs
)
298 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
300 s
->subcode
|= GF_CALL_INTERNAL
;
301 gimple_call_set_internal_fn (s
, fn
);
302 gimple_call_reset_alias_info (s
);
307 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
308 the number of arguments. The ... are the arguments. */
311 gimple_build_call_internal (enum internal_fn fn
, unsigned nargs
, ...)
317 call
= gimple_build_call_internal_1 (fn
, nargs
);
318 va_start (ap
, nargs
);
319 for (i
= 0; i
< nargs
; i
++)
320 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
327 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
328 specified in vector ARGS. */
331 gimple_build_call_internal_vec (enum internal_fn fn
, vec
<tree
> args
)
336 nargs
= args
.length ();
337 call
= gimple_build_call_internal_1 (fn
, nargs
);
338 for (i
= 0; i
< nargs
; i
++)
339 gimple_call_set_arg (call
, i
, args
[i
]);
345 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
346 assumed to be in GIMPLE form already. Minimal checking is done of
350 gimple_build_call_from_tree (tree t
)
354 tree fndecl
= get_callee_fndecl (t
);
356 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
358 nargs
= call_expr_nargs (t
);
359 call
= gimple_build_call_1 (fndecl
? fndecl
: CALL_EXPR_FN (t
), nargs
);
361 for (i
= 0; i
< nargs
; i
++)
362 gimple_call_set_arg (call
, i
, CALL_EXPR_ARG (t
, i
));
364 gimple_set_block (call
, TREE_BLOCK (t
));
366 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
367 gimple_call_set_chain (call
, CALL_EXPR_STATIC_CHAIN (t
));
368 gimple_call_set_tail (call
, CALL_EXPR_TAILCALL (t
));
369 gimple_call_set_return_slot_opt (call
, CALL_EXPR_RETURN_SLOT_OPT (t
));
371 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
372 && (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA
373 || DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
374 gimple_call_set_alloca_for_var (call
, CALL_ALLOCA_FOR_VAR_P (t
));
376 gimple_call_set_from_thunk (call
, CALL_FROM_THUNK_P (t
));
377 gimple_call_set_va_arg_pack (call
, CALL_EXPR_VA_ARG_PACK (t
));
378 gimple_call_set_nothrow (call
, TREE_NOTHROW (t
));
379 gimple_set_no_warning (call
, TREE_NO_WARNING (t
));
380 gimple_call_set_with_bounds (call
, CALL_WITH_BOUNDS_P (t
));
386 /* Build a GIMPLE_ASSIGN statement.
388 LHS of the assignment.
389 RHS of the assignment which can be unary or binary. */
392 gimple_build_assign (tree lhs
, tree rhs MEM_STAT_DECL
)
394 enum tree_code subcode
;
397 extract_ops_from_tree_1 (rhs
, &subcode
, &op1
, &op2
, &op3
);
398 return gimple_build_assign (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
402 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
405 static inline gassign
*
406 gimple_build_assign_1 (tree lhs
, enum tree_code subcode
, tree op1
,
407 tree op2
, tree op3 MEM_STAT_DECL
)
412 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
414 num_ops
= get_gimple_rhs_num_ops (subcode
) + 1;
416 p
= as_a
<gassign
*> (
417 gimple_build_with_ops_stat (GIMPLE_ASSIGN
, (unsigned)subcode
, num_ops
419 gimple_assign_set_lhs (p
, lhs
);
420 gimple_assign_set_rhs1 (p
, op1
);
423 gcc_assert (num_ops
> 2);
424 gimple_assign_set_rhs2 (p
, op2
);
429 gcc_assert (num_ops
> 3);
430 gimple_assign_set_rhs3 (p
, op3
);
436 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
440 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
441 tree op2
, tree op3 MEM_STAT_DECL
)
443 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
446 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
450 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
451 tree op2 MEM_STAT_DECL
)
453 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, NULL_TREE
457 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
460 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1 MEM_STAT_DECL
)
462 return gimple_build_assign_1 (lhs
, subcode
, op1
, NULL_TREE
, NULL_TREE
467 /* Build a GIMPLE_COND statement.
469 PRED is the condition used to compare LHS and the RHS.
470 T_LABEL is the label to jump to if the condition is true.
471 F_LABEL is the label to jump to otherwise. */
474 gimple_build_cond (enum tree_code pred_code
, tree lhs
, tree rhs
,
475 tree t_label
, tree f_label
)
479 gcc_assert (TREE_CODE_CLASS (pred_code
) == tcc_comparison
);
480 p
= as_a
<gcond
*> (gimple_build_with_ops (GIMPLE_COND
, pred_code
, 4));
481 gimple_cond_set_lhs (p
, lhs
);
482 gimple_cond_set_rhs (p
, rhs
);
483 gimple_cond_set_true_label (p
, t_label
);
484 gimple_cond_set_false_label (p
, f_label
);
488 /* Build a GIMPLE_COND statement from the conditional expression tree
489 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
492 gimple_build_cond_from_tree (tree cond
, tree t_label
, tree f_label
)
497 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
498 return gimple_build_cond (code
, lhs
, rhs
, t_label
, f_label
);
501 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
502 boolean expression tree COND. */
505 gimple_cond_set_condition_from_tree (gcond
*stmt
, tree cond
)
510 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
511 gimple_cond_set_condition (stmt
, code
, lhs
, rhs
);
514 /* Build a GIMPLE_LABEL statement for LABEL. */
517 gimple_build_label (tree label
)
520 = as_a
<glabel
*> (gimple_build_with_ops (GIMPLE_LABEL
, ERROR_MARK
, 1));
521 gimple_label_set_label (p
, label
);
525 /* Build a GIMPLE_GOTO statement to label DEST. */
528 gimple_build_goto (tree dest
)
531 = as_a
<ggoto
*> (gimple_build_with_ops (GIMPLE_GOTO
, ERROR_MARK
, 1));
532 gimple_goto_set_dest (p
, dest
);
537 /* Build a GIMPLE_NOP statement. */
540 gimple_build_nop (void)
542 return gimple_alloc (GIMPLE_NOP
, 0);
546 /* Build a GIMPLE_BIND statement.
547 VARS are the variables in BODY.
548 BLOCK is the containing block. */
551 gimple_build_bind (tree vars
, gimple_seq body
, tree block
)
553 gbind
*p
= as_a
<gbind
*> (gimple_alloc (GIMPLE_BIND
, 0));
554 gimple_bind_set_vars (p
, vars
);
556 gimple_bind_set_body (p
, body
);
558 gimple_bind_set_block (p
, block
);
562 /* Helper function to set the simple fields of a asm stmt.
564 STRING is a pointer to a string that is the asm blocks assembly code.
565 NINPUT is the number of register inputs.
566 NOUTPUT is the number of register outputs.
567 NCLOBBERS is the number of clobbered registers.
571 gimple_build_asm_1 (const char *string
, unsigned ninputs
, unsigned noutputs
,
572 unsigned nclobbers
, unsigned nlabels
)
575 int size
= strlen (string
);
577 /* ASMs with labels cannot have outputs. This should have been
578 enforced by the front end. */
579 gcc_assert (nlabels
== 0 || noutputs
== 0);
582 gimple_build_with_ops (GIMPLE_ASM
, ERROR_MARK
,
583 ninputs
+ noutputs
+ nclobbers
+ nlabels
));
589 p
->string
= ggc_alloc_string (string
, size
);
591 if (GATHER_STATISTICS
)
592 gimple_alloc_sizes
[(int) gimple_alloc_kind (GIMPLE_ASM
)] += size
;
597 /* Build a GIMPLE_ASM statement.
599 STRING is the assembly code.
600 NINPUT is the number of register inputs.
601 NOUTPUT is the number of register outputs.
602 NCLOBBERS is the number of clobbered registers.
603 INPUTS is a vector of the input register parameters.
604 OUTPUTS is a vector of the output register parameters.
605 CLOBBERS is a vector of the clobbered register parameters.
606 LABELS is a vector of destination labels. */
609 gimple_build_asm_vec (const char *string
, vec
<tree
, va_gc
> *inputs
,
610 vec
<tree
, va_gc
> *outputs
, vec
<tree
, va_gc
> *clobbers
,
611 vec
<tree
, va_gc
> *labels
)
616 p
= gimple_build_asm_1 (string
,
617 vec_safe_length (inputs
),
618 vec_safe_length (outputs
),
619 vec_safe_length (clobbers
),
620 vec_safe_length (labels
));
622 for (i
= 0; i
< vec_safe_length (inputs
); i
++)
623 gimple_asm_set_input_op (p
, i
, (*inputs
)[i
]);
625 for (i
= 0; i
< vec_safe_length (outputs
); i
++)
626 gimple_asm_set_output_op (p
, i
, (*outputs
)[i
]);
628 for (i
= 0; i
< vec_safe_length (clobbers
); i
++)
629 gimple_asm_set_clobber_op (p
, i
, (*clobbers
)[i
]);
631 for (i
= 0; i
< vec_safe_length (labels
); i
++)
632 gimple_asm_set_label_op (p
, i
, (*labels
)[i
]);
637 /* Build a GIMPLE_CATCH statement.
639 TYPES are the catch types.
640 HANDLER is the exception handler. */
643 gimple_build_catch (tree types
, gimple_seq handler
)
645 gcatch
*p
= as_a
<gcatch
*> (gimple_alloc (GIMPLE_CATCH
, 0));
646 gimple_catch_set_types (p
, types
);
648 gimple_catch_set_handler (p
, handler
);
653 /* Build a GIMPLE_EH_FILTER statement.
655 TYPES are the filter's types.
656 FAILURE is the filter's failure action. */
659 gimple_build_eh_filter (tree types
, gimple_seq failure
)
661 geh_filter
*p
= as_a
<geh_filter
*> (gimple_alloc (GIMPLE_EH_FILTER
, 0));
662 gimple_eh_filter_set_types (p
, types
);
664 gimple_eh_filter_set_failure (p
, failure
);
669 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
672 gimple_build_eh_must_not_throw (tree decl
)
674 geh_mnt
*p
= as_a
<geh_mnt
*> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW
, 0));
676 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
677 gcc_assert (flags_from_decl_or_type (decl
) & ECF_NORETURN
);
678 gimple_eh_must_not_throw_set_fndecl (p
, decl
);
683 /* Build a GIMPLE_EH_ELSE statement. */
686 gimple_build_eh_else (gimple_seq n_body
, gimple_seq e_body
)
688 geh_else
*p
= as_a
<geh_else
*> (gimple_alloc (GIMPLE_EH_ELSE
, 0));
689 gimple_eh_else_set_n_body (p
, n_body
);
690 gimple_eh_else_set_e_body (p
, e_body
);
694 /* Build a GIMPLE_TRY statement.
696 EVAL is the expression to evaluate.
697 CLEANUP is the cleanup expression.
698 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
699 whether this is a try/catch or a try/finally respectively. */
702 gimple_build_try (gimple_seq eval
, gimple_seq cleanup
,
703 enum gimple_try_flags kind
)
707 gcc_assert (kind
== GIMPLE_TRY_CATCH
|| kind
== GIMPLE_TRY_FINALLY
);
708 p
= as_a
<gtry
*> (gimple_alloc (GIMPLE_TRY
, 0));
709 gimple_set_subcode (p
, kind
);
711 gimple_try_set_eval (p
, eval
);
713 gimple_try_set_cleanup (p
, cleanup
);
718 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
720 CLEANUP is the cleanup expression. */
723 gimple_build_wce (gimple_seq cleanup
)
725 gimple
*p
= gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR
, 0);
727 gimple_wce_set_cleanup (p
, cleanup
);
733 /* Build a GIMPLE_RESX statement. */
736 gimple_build_resx (int region
)
739 = as_a
<gresx
*> (gimple_build_with_ops (GIMPLE_RESX
, ERROR_MARK
, 0));
745 /* The helper for constructing a gimple switch statement.
746 INDEX is the switch's index.
747 NLABELS is the number of labels in the switch excluding the default.
748 DEFAULT_LABEL is the default label for the switch statement. */
751 gimple_build_switch_nlabels (unsigned nlabels
, tree index
, tree default_label
)
753 /* nlabels + 1 default label + 1 index. */
754 gcc_checking_assert (default_label
);
755 gswitch
*p
= as_a
<gswitch
*> (gimple_build_with_ops (GIMPLE_SWITCH
,
758 gimple_switch_set_index (p
, index
);
759 gimple_switch_set_default_label (p
, default_label
);
763 /* Build a GIMPLE_SWITCH statement.
765 INDEX is the switch's index.
766 DEFAULT_LABEL is the default label
767 ARGS is a vector of labels excluding the default. */
770 gimple_build_switch (tree index
, tree default_label
, vec
<tree
> args
)
772 unsigned i
, nlabels
= args
.length ();
774 gswitch
*p
= gimple_build_switch_nlabels (nlabels
, index
, default_label
);
776 /* Copy the labels from the vector to the switch statement. */
777 for (i
= 0; i
< nlabels
; i
++)
778 gimple_switch_set_label (p
, i
+ 1, args
[i
]);
783 /* Build a GIMPLE_EH_DISPATCH statement. */
786 gimple_build_eh_dispatch (int region
)
789 = as_a
<geh_dispatch
*> (
790 gimple_build_with_ops (GIMPLE_EH_DISPATCH
, ERROR_MARK
, 0));
795 /* Build a new GIMPLE_DEBUG_BIND statement.
797 VAR is bound to VALUE; block and location are taken from STMT. */
800 gimple_build_debug_bind_stat (tree var
, tree value
, gimple
*stmt MEM_STAT_DECL
)
803 = as_a
<gdebug
*> (gimple_build_with_ops_stat (GIMPLE_DEBUG
,
804 (unsigned)GIMPLE_DEBUG_BIND
, 2
806 gimple_debug_bind_set_var (p
, var
);
807 gimple_debug_bind_set_value (p
, value
);
809 gimple_set_location (p
, gimple_location (stmt
));
815 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
817 VAR is bound to VALUE; block and location are taken from STMT. */
820 gimple_build_debug_source_bind_stat (tree var
, tree value
,
821 gimple
*stmt MEM_STAT_DECL
)
825 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
826 (unsigned)GIMPLE_DEBUG_SOURCE_BIND
, 2
829 gimple_debug_source_bind_set_var (p
, var
);
830 gimple_debug_source_bind_set_value (p
, value
);
832 gimple_set_location (p
, gimple_location (stmt
));
838 /* Build a GIMPLE_OMP_CRITICAL statement.
840 BODY is the sequence of statements for which only one thread can execute.
841 NAME is optional identifier for this critical block.
842 CLAUSES are clauses for this critical block. */
845 gimple_build_omp_critical (gimple_seq body
, tree name
, tree clauses
)
848 = as_a
<gomp_critical
*> (gimple_alloc (GIMPLE_OMP_CRITICAL
, 0));
849 gimple_omp_critical_set_name (p
, name
);
850 gimple_omp_critical_set_clauses (p
, clauses
);
852 gimple_omp_set_body (p
, body
);
857 /* Build a GIMPLE_OMP_FOR statement.
859 BODY is sequence of statements inside the for loop.
860 KIND is the `for' variant.
861 CLAUSES, are any of the construct's clauses.
862 COLLAPSE is the collapse count.
863 PRE_BODY is the sequence of statements that are loop invariant. */
866 gimple_build_omp_for (gimple_seq body
, int kind
, tree clauses
, size_t collapse
,
869 gomp_for
*p
= as_a
<gomp_for
*> (gimple_alloc (GIMPLE_OMP_FOR
, 0));
871 gimple_omp_set_body (p
, body
);
872 gimple_omp_for_set_clauses (p
, clauses
);
873 gimple_omp_for_set_kind (p
, kind
);
874 p
->collapse
= collapse
;
875 p
->iter
= ggc_cleared_vec_alloc
<gimple_omp_for_iter
> (collapse
);
878 gimple_omp_for_set_pre_body (p
, pre_body
);
884 /* Build a GIMPLE_OMP_PARALLEL statement.
886 BODY is sequence of statements which are executed in parallel.
887 CLAUSES, are the OMP parallel construct's clauses.
888 CHILD_FN is the function created for the parallel threads to execute.
889 DATA_ARG are the shared data argument(s). */
892 gimple_build_omp_parallel (gimple_seq body
, tree clauses
, tree child_fn
,
896 = as_a
<gomp_parallel
*> (gimple_alloc (GIMPLE_OMP_PARALLEL
, 0));
898 gimple_omp_set_body (p
, body
);
899 gimple_omp_parallel_set_clauses (p
, clauses
);
900 gimple_omp_parallel_set_child_fn (p
, child_fn
);
901 gimple_omp_parallel_set_data_arg (p
, data_arg
);
907 /* Build a GIMPLE_OMP_TASK statement.
909 BODY is sequence of statements which are executed by the explicit task.
910 CLAUSES, are the OMP parallel construct's clauses.
911 CHILD_FN is the function created for the parallel threads to execute.
912 DATA_ARG are the shared data argument(s).
913 COPY_FN is the optional function for firstprivate initialization.
914 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
917 gimple_build_omp_task (gimple_seq body
, tree clauses
, tree child_fn
,
918 tree data_arg
, tree copy_fn
, tree arg_size
,
921 gomp_task
*p
= as_a
<gomp_task
*> (gimple_alloc (GIMPLE_OMP_TASK
, 0));
923 gimple_omp_set_body (p
, body
);
924 gimple_omp_task_set_clauses (p
, clauses
);
925 gimple_omp_task_set_child_fn (p
, child_fn
);
926 gimple_omp_task_set_data_arg (p
, data_arg
);
927 gimple_omp_task_set_copy_fn (p
, copy_fn
);
928 gimple_omp_task_set_arg_size (p
, arg_size
);
929 gimple_omp_task_set_arg_align (p
, arg_align
);
935 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
937 BODY is the sequence of statements in the section. */
940 gimple_build_omp_section (gimple_seq body
)
942 gimple
*p
= gimple_alloc (GIMPLE_OMP_SECTION
, 0);
944 gimple_omp_set_body (p
, body
);
950 /* Build a GIMPLE_OMP_MASTER statement.
952 BODY is the sequence of statements to be executed by just the master. */
955 gimple_build_omp_master (gimple_seq body
)
957 gimple
*p
= gimple_alloc (GIMPLE_OMP_MASTER
, 0);
959 gimple_omp_set_body (p
, body
);
965 /* Build a GIMPLE_OMP_TASKGROUP statement.
967 BODY is the sequence of statements to be executed by the taskgroup
971 gimple_build_omp_taskgroup (gimple_seq body
)
973 gimple
*p
= gimple_alloc (GIMPLE_OMP_TASKGROUP
, 0);
975 gimple_omp_set_body (p
, body
);
981 /* Build a GIMPLE_OMP_CONTINUE statement.
983 CONTROL_DEF is the definition of the control variable.
984 CONTROL_USE is the use of the control variable. */
987 gimple_build_omp_continue (tree control_def
, tree control_use
)
990 = as_a
<gomp_continue
*> (gimple_alloc (GIMPLE_OMP_CONTINUE
, 0));
991 gimple_omp_continue_set_control_def (p
, control_def
);
992 gimple_omp_continue_set_control_use (p
, control_use
);
996 /* Build a GIMPLE_OMP_ORDERED statement.
998 BODY is the sequence of statements inside a loop that will executed in
1000 CLAUSES are clauses for this statement. */
1003 gimple_build_omp_ordered (gimple_seq body
, tree clauses
)
1006 = as_a
<gomp_ordered
*> (gimple_alloc (GIMPLE_OMP_ORDERED
, 0));
1007 gimple_omp_ordered_set_clauses (p
, clauses
);
1009 gimple_omp_set_body (p
, body
);
1015 /* Build a GIMPLE_OMP_RETURN statement.
1016 WAIT_P is true if this is a non-waiting return. */
1019 gimple_build_omp_return (bool wait_p
)
1021 gimple
*p
= gimple_alloc (GIMPLE_OMP_RETURN
, 0);
1023 gimple_omp_return_set_nowait (p
);
1029 /* Build a GIMPLE_OMP_SECTIONS statement.
1031 BODY is a sequence of section statements.
1032 CLAUSES are any of the OMP sections contsruct's clauses: private,
1033 firstprivate, lastprivate, reduction, and nowait. */
1036 gimple_build_omp_sections (gimple_seq body
, tree clauses
)
1039 = as_a
<gomp_sections
*> (gimple_alloc (GIMPLE_OMP_SECTIONS
, 0));
1041 gimple_omp_set_body (p
, body
);
1042 gimple_omp_sections_set_clauses (p
, clauses
);
1048 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1051 gimple_build_omp_sections_switch (void)
1053 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH
, 0);
1057 /* Build a GIMPLE_OMP_SINGLE statement.
1059 BODY is the sequence of statements that will be executed once.
1060 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1061 copyprivate, nowait. */
1064 gimple_build_omp_single (gimple_seq body
, tree clauses
)
1067 = as_a
<gomp_single
*> (gimple_alloc (GIMPLE_OMP_SINGLE
, 0));
1069 gimple_omp_set_body (p
, body
);
1070 gimple_omp_single_set_clauses (p
, clauses
);
1076 /* Build a GIMPLE_OMP_TARGET statement.
1078 BODY is the sequence of statements that will be executed.
1079 KIND is the kind of the region.
1080 CLAUSES are any of the construct's clauses. */
1083 gimple_build_omp_target (gimple_seq body
, int kind
, tree clauses
)
1086 = as_a
<gomp_target
*> (gimple_alloc (GIMPLE_OMP_TARGET
, 0));
1088 gimple_omp_set_body (p
, body
);
1089 gimple_omp_target_set_clauses (p
, clauses
);
1090 gimple_omp_target_set_kind (p
, kind
);
1096 /* Build a GIMPLE_OMP_TEAMS statement.
1098 BODY is the sequence of statements that will be executed.
1099 CLAUSES are any of the OMP teams construct's clauses. */
1102 gimple_build_omp_teams (gimple_seq body
, tree clauses
)
1104 gomp_teams
*p
= as_a
<gomp_teams
*> (gimple_alloc (GIMPLE_OMP_TEAMS
, 0));
1106 gimple_omp_set_body (p
, body
);
1107 gimple_omp_teams_set_clauses (p
, clauses
);
1113 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1116 gimple_build_omp_atomic_load (tree lhs
, tree rhs
)
1119 = as_a
<gomp_atomic_load
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD
, 0));
1120 gimple_omp_atomic_load_set_lhs (p
, lhs
);
1121 gimple_omp_atomic_load_set_rhs (p
, rhs
);
1125 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1127 VAL is the value we are storing. */
1130 gimple_build_omp_atomic_store (tree val
)
1132 gomp_atomic_store
*p
1133 = as_a
<gomp_atomic_store
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE
, 0));
1134 gimple_omp_atomic_store_set_val (p
, val
);
1138 /* Build a GIMPLE_TRANSACTION statement. */
1141 gimple_build_transaction (gimple_seq body
, tree label
)
1144 = as_a
<gtransaction
*> (gimple_alloc (GIMPLE_TRANSACTION
, 0));
1145 gimple_transaction_set_body (p
, body
);
1146 gimple_transaction_set_label (p
, label
);
1150 #if defined ENABLE_GIMPLE_CHECKING
1151 /* Complain of a gimple type mismatch and die. */
1154 gimple_check_failed (const gimple
*gs
, const char *file
, int line
,
1155 const char *function
, enum gimple_code code
,
1156 enum tree_code subcode
)
1158 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1159 gimple_code_name
[code
],
1160 get_tree_code_name (subcode
),
1161 gimple_code_name
[gimple_code (gs
)],
1163 ? get_tree_code_name ((enum tree_code
) gs
->subcode
)
1165 function
, trim_filename (file
), line
);
1167 #endif /* ENABLE_GIMPLE_CHECKING */
1170 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1171 *SEQ_P is NULL, a new sequence is allocated. */
1174 gimple_seq_add_stmt (gimple_seq
*seq_p
, gimple
*gs
)
1176 gimple_stmt_iterator si
;
1180 si
= gsi_last (*seq_p
);
1181 gsi_insert_after (&si
, gs
, GSI_NEW_STMT
);
1184 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1185 *SEQ_P is NULL, a new sequence is allocated. This function is
1186 similar to gimple_seq_add_stmt, but does not scan the operands.
1187 During gimplification, we need to manipulate statement sequences
1188 before the def/use vectors have been constructed. */
1191 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple
*gs
)
1193 gimple_stmt_iterator si
;
1198 si
= gsi_last (*seq_p
);
1199 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
1202 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1203 NULL, a new sequence is allocated. */
1206 gimple_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
1208 gimple_stmt_iterator si
;
1212 si
= gsi_last (*dst_p
);
1213 gsi_insert_seq_after (&si
, src
, GSI_NEW_STMT
);
1216 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1217 NULL, a new sequence is allocated. This function is
1218 similar to gimple_seq_add_seq, but does not scan the operands. */
1221 gimple_seq_add_seq_without_update (gimple_seq
*dst_p
, gimple_seq src
)
1223 gimple_stmt_iterator si
;
1227 si
= gsi_last (*dst_p
);
1228 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
1231 /* Determine whether to assign a location to the statement GS. */
1234 should_carry_location_p (gimple
*gs
)
1236 /* Don't emit a line note for a label. We particularly don't want to
1237 emit one for the break label, since it doesn't actually correspond
1238 to the beginning of the loop/switch. */
1239 if (gimple_code (gs
) == GIMPLE_LABEL
)
1245 /* Set the location for gimple statement GS to LOCATION. */
1248 annotate_one_with_location (gimple
*gs
, location_t location
)
1250 if (!gimple_has_location (gs
)
1251 && !gimple_do_not_emit_location_p (gs
)
1252 && should_carry_location_p (gs
))
1253 gimple_set_location (gs
, location
);
1256 /* Set LOCATION for all the statements after iterator GSI in sequence
1257 SEQ. If GSI is pointing to the end of the sequence, start with the
1258 first statement in SEQ. */
1261 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
1262 location_t location
)
1264 if (gsi_end_p (gsi
))
1265 gsi
= gsi_start (seq
);
1269 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
1270 annotate_one_with_location (gsi_stmt (gsi
), location
);
1273 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1276 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
1278 gimple_stmt_iterator i
;
1280 if (gimple_seq_empty_p (stmt_p
))
1283 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
1285 gimple
*gs
= gsi_stmt (i
);
1286 annotate_one_with_location (gs
, location
);
1290 /* Helper function of empty_body_p. Return true if STMT is an empty
1294 empty_stmt_p (gimple
*stmt
)
1296 if (gimple_code (stmt
) == GIMPLE_NOP
)
1298 if (gbind
*bind_stmt
= dyn_cast
<gbind
*> (stmt
))
1299 return empty_body_p (gimple_bind_body (bind_stmt
));
1304 /* Return true if BODY contains nothing but empty statements. */
1307 empty_body_p (gimple_seq body
)
1309 gimple_stmt_iterator i
;
1311 if (gimple_seq_empty_p (body
))
1313 for (i
= gsi_start (body
); !gsi_end_p (i
); gsi_next (&i
))
1314 if (!empty_stmt_p (gsi_stmt (i
))
1315 && !is_gimple_debug (gsi_stmt (i
)))
1322 /* Perform a deep copy of sequence SRC and return the result. */
1325 gimple_seq_copy (gimple_seq src
)
1327 gimple_stmt_iterator gsi
;
1328 gimple_seq new_seq
= NULL
;
1331 for (gsi
= gsi_start (src
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1333 stmt
= gimple_copy (gsi_stmt (gsi
));
1334 gimple_seq_add_stmt (&new_seq
, stmt
);
1342 /* Return true if calls C1 and C2 are known to go to the same function. */
1345 gimple_call_same_target_p (const gimple
*c1
, const gimple
*c2
)
1347 if (gimple_call_internal_p (c1
))
1348 return (gimple_call_internal_p (c2
)
1349 && gimple_call_internal_fn (c1
) == gimple_call_internal_fn (c2
));
1351 return (gimple_call_fn (c1
) == gimple_call_fn (c2
)
1352 || (gimple_call_fndecl (c1
)
1353 && gimple_call_fndecl (c1
) == gimple_call_fndecl (c2
)));
1356 /* Detect flags from a GIMPLE_CALL. This is just like
1357 call_expr_flags, but for gimple tuples. */
1360 gimple_call_flags (const gimple
*stmt
)
1363 tree decl
= gimple_call_fndecl (stmt
);
1366 flags
= flags_from_decl_or_type (decl
);
1367 else if (gimple_call_internal_p (stmt
))
1368 flags
= internal_fn_flags (gimple_call_internal_fn (stmt
));
1370 flags
= flags_from_decl_or_type (gimple_call_fntype (stmt
));
1372 if (stmt
->subcode
& GF_CALL_NOTHROW
)
1373 flags
|= ECF_NOTHROW
;
1378 /* Return the "fn spec" string for call STMT. */
1381 gimple_call_fnspec (const gcall
*stmt
)
1385 if (gimple_call_internal_p (stmt
))
1386 return internal_fn_fnspec (gimple_call_internal_fn (stmt
));
1388 type
= gimple_call_fntype (stmt
);
1392 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
1396 return TREE_VALUE (TREE_VALUE (attr
));
1399 /* Detects argument flags for argument number ARG on call STMT. */
1402 gimple_call_arg_flags (const gcall
*stmt
, unsigned arg
)
1404 const_tree attr
= gimple_call_fnspec (stmt
);
1406 if (!attr
|| 1 + arg
>= (unsigned) TREE_STRING_LENGTH (attr
))
1409 switch (TREE_STRING_POINTER (attr
)[1 + arg
])
1416 return EAF_DIRECT
| EAF_NOCLOBBER
| EAF_NOESCAPE
;
1419 return EAF_NOCLOBBER
| EAF_NOESCAPE
;
1422 return EAF_DIRECT
| EAF_NOESCAPE
;
1425 return EAF_NOESCAPE
;
1433 /* Detects return flags for the call STMT. */
1436 gimple_call_return_flags (const gcall
*stmt
)
1440 if (gimple_call_flags (stmt
) & ECF_MALLOC
)
1443 attr
= gimple_call_fnspec (stmt
);
1444 if (!attr
|| TREE_STRING_LENGTH (attr
) < 1)
1447 switch (TREE_STRING_POINTER (attr
)[0])
1453 return ERF_RETURNS_ARG
| (TREE_STRING_POINTER (attr
)[0] - '1');
1465 /* Return true if GS is a copy assignment. */
1468 gimple_assign_copy_p (gimple
*gs
)
1470 return (gimple_assign_single_p (gs
)
1471 && is_gimple_val (gimple_op (gs
, 1)));
1475 /* Return true if GS is a SSA_NAME copy assignment. */
1478 gimple_assign_ssa_name_copy_p (gimple
*gs
)
1480 return (gimple_assign_single_p (gs
)
1481 && TREE_CODE (gimple_assign_lhs (gs
)) == SSA_NAME
1482 && TREE_CODE (gimple_assign_rhs1 (gs
)) == SSA_NAME
);
1486 /* Return true if GS is an assignment with a unary RHS, but the
1487 operator has no effect on the assigned value. The logic is adapted
1488 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1489 instances in which STRIP_NOPS was previously applied to the RHS of
1492 NOTE: In the use cases that led to the creation of this function
1493 and of gimple_assign_single_p, it is typical to test for either
1494 condition and to proceed in the same manner. In each case, the
1495 assigned value is represented by the single RHS operand of the
1496 assignment. I suspect there may be cases where gimple_assign_copy_p,
1497 gimple_assign_single_p, or equivalent logic is used where a similar
1498 treatment of unary NOPs is appropriate. */
1501 gimple_assign_unary_nop_p (gimple
*gs
)
1503 return (is_gimple_assign (gs
)
1504 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs
))
1505 || gimple_assign_rhs_code (gs
) == NON_LVALUE_EXPR
)
1506 && gimple_assign_rhs1 (gs
) != error_mark_node
1507 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs
)))
1508 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs
)))));
1511 /* Set BB to be the basic block holding G. */
1514 gimple_set_bb (gimple
*stmt
, basic_block bb
)
1518 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1521 /* If the statement is a label, add the label to block-to-labels map
1522 so that we can speed up edge creation for GIMPLE_GOTOs. */
1528 t
= gimple_label_label (as_a
<glabel
*> (stmt
));
1529 uid
= LABEL_DECL_UID (t
);
1533 vec_safe_length (label_to_block_map_for_fn (cfun
));
1534 LABEL_DECL_UID (t
) = uid
= cfun
->cfg
->last_label_uid
++;
1535 if (old_len
<= (unsigned) uid
)
1537 unsigned new_len
= 3 * uid
/ 2 + 1;
1539 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun
),
1544 (*label_to_block_map_for_fn (cfun
))[uid
] = bb
;
1549 /* Modify the RHS of the assignment pointed-to by GSI using the
1550 operands in the expression tree EXPR.
1552 NOTE: The statement pointed-to by GSI may be reallocated if it
1553 did not have enough operand slots.
1555 This function is useful to convert an existing tree expression into
1556 the flat representation used for the RHS of a GIMPLE assignment.
1557 It will reallocate memory as needed to expand or shrink the number
1558 of operand slots needed to represent EXPR.
1560 NOTE: If you find yourself building a tree and then calling this
1561 function, you are most certainly doing it the slow way. It is much
1562 better to build a new assignment or to use the function
1563 gimple_assign_set_rhs_with_ops, which does not require an
1564 expression tree to be built. */
1567 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*gsi
, tree expr
)
1569 enum tree_code subcode
;
1572 extract_ops_from_tree_1 (expr
, &subcode
, &op1
, &op2
, &op3
);
1573 gimple_assign_set_rhs_with_ops (gsi
, subcode
, op1
, op2
, op3
);
1577 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1578 operands OP1, OP2 and OP3.
1580 NOTE: The statement pointed-to by GSI may be reallocated if it
1581 did not have enough operand slots. */
1584 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*gsi
, enum tree_code code
,
1585 tree op1
, tree op2
, tree op3
)
1587 unsigned new_rhs_ops
= get_gimple_rhs_num_ops (code
);
1588 gimple
*stmt
= gsi_stmt (*gsi
);
1590 /* If the new CODE needs more operands, allocate a new statement. */
1591 if (gimple_num_ops (stmt
) < new_rhs_ops
+ 1)
1593 tree lhs
= gimple_assign_lhs (stmt
);
1594 gimple
*new_stmt
= gimple_alloc (gimple_code (stmt
), new_rhs_ops
+ 1);
1595 memcpy (new_stmt
, stmt
, gimple_size (gimple_code (stmt
)));
1596 gimple_init_singleton (new_stmt
);
1597 gsi_replace (gsi
, new_stmt
, true);
1600 /* The LHS needs to be reset as this also changes the SSA name
1602 gimple_assign_set_lhs (stmt
, lhs
);
1605 gimple_set_num_ops (stmt
, new_rhs_ops
+ 1);
1606 gimple_set_subcode (stmt
, code
);
1607 gimple_assign_set_rhs1 (stmt
, op1
);
1608 if (new_rhs_ops
> 1)
1609 gimple_assign_set_rhs2 (stmt
, op2
);
1610 if (new_rhs_ops
> 2)
1611 gimple_assign_set_rhs3 (stmt
, op3
);
1615 /* Return the LHS of a statement that performs an assignment,
1616 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1617 for a call to a function that returns no value, or for a
1618 statement other than an assignment or a call. */
1621 gimple_get_lhs (const gimple
*stmt
)
1623 enum gimple_code code
= gimple_code (stmt
);
1625 if (code
== GIMPLE_ASSIGN
)
1626 return gimple_assign_lhs (stmt
);
1627 else if (code
== GIMPLE_CALL
)
1628 return gimple_call_lhs (stmt
);
1634 /* Set the LHS of a statement that performs an assignment,
1635 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1638 gimple_set_lhs (gimple
*stmt
, tree lhs
)
1640 enum gimple_code code
= gimple_code (stmt
);
1642 if (code
== GIMPLE_ASSIGN
)
1643 gimple_assign_set_lhs (stmt
, lhs
);
1644 else if (code
== GIMPLE_CALL
)
1645 gimple_call_set_lhs (stmt
, lhs
);
1651 /* Return a deep copy of statement STMT. All the operands from STMT
1652 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1653 and VUSE operand arrays are set to empty in the new copy. The new
1654 copy isn't part of any sequence. */
1657 gimple_copy (gimple
*stmt
)
1659 enum gimple_code code
= gimple_code (stmt
);
1660 unsigned num_ops
= gimple_num_ops (stmt
);
1661 gimple
*copy
= gimple_alloc (code
, num_ops
);
1664 /* Shallow copy all the fields from STMT. */
1665 memcpy (copy
, stmt
, gimple_size (code
));
1666 gimple_init_singleton (copy
);
1668 /* If STMT has sub-statements, deep-copy them as well. */
1669 if (gimple_has_substatements (stmt
))
1674 switch (gimple_code (stmt
))
1678 gbind
*bind_stmt
= as_a
<gbind
*> (stmt
);
1679 gbind
*bind_copy
= as_a
<gbind
*> (copy
);
1680 new_seq
= gimple_seq_copy (gimple_bind_body (bind_stmt
));
1681 gimple_bind_set_body (bind_copy
, new_seq
);
1682 gimple_bind_set_vars (bind_copy
,
1683 unshare_expr (gimple_bind_vars (bind_stmt
)));
1684 gimple_bind_set_block (bind_copy
, gimple_bind_block (bind_stmt
));
1690 gcatch
*catch_stmt
= as_a
<gcatch
*> (stmt
);
1691 gcatch
*catch_copy
= as_a
<gcatch
*> (copy
);
1692 new_seq
= gimple_seq_copy (gimple_catch_handler (catch_stmt
));
1693 gimple_catch_set_handler (catch_copy
, new_seq
);
1694 t
= unshare_expr (gimple_catch_types (catch_stmt
));
1695 gimple_catch_set_types (catch_copy
, t
);
1699 case GIMPLE_EH_FILTER
:
1701 geh_filter
*eh_filter_stmt
= as_a
<geh_filter
*> (stmt
);
1702 geh_filter
*eh_filter_copy
= as_a
<geh_filter
*> (copy
);
1704 = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt
));
1705 gimple_eh_filter_set_failure (eh_filter_copy
, new_seq
);
1706 t
= unshare_expr (gimple_eh_filter_types (eh_filter_stmt
));
1707 gimple_eh_filter_set_types (eh_filter_copy
, t
);
1711 case GIMPLE_EH_ELSE
:
1713 geh_else
*eh_else_stmt
= as_a
<geh_else
*> (stmt
);
1714 geh_else
*eh_else_copy
= as_a
<geh_else
*> (copy
);
1715 new_seq
= gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt
));
1716 gimple_eh_else_set_n_body (eh_else_copy
, new_seq
);
1717 new_seq
= gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt
));
1718 gimple_eh_else_set_e_body (eh_else_copy
, new_seq
);
1724 gtry
*try_stmt
= as_a
<gtry
*> (stmt
);
1725 gtry
*try_copy
= as_a
<gtry
*> (copy
);
1726 new_seq
= gimple_seq_copy (gimple_try_eval (try_stmt
));
1727 gimple_try_set_eval (try_copy
, new_seq
);
1728 new_seq
= gimple_seq_copy (gimple_try_cleanup (try_stmt
));
1729 gimple_try_set_cleanup (try_copy
, new_seq
);
1733 case GIMPLE_OMP_FOR
:
1734 new_seq
= gimple_seq_copy (gimple_omp_for_pre_body (stmt
));
1735 gimple_omp_for_set_pre_body (copy
, new_seq
);
1736 t
= unshare_expr (gimple_omp_for_clauses (stmt
));
1737 gimple_omp_for_set_clauses (copy
, t
);
1739 gomp_for
*omp_for_copy
= as_a
<gomp_for
*> (copy
);
1740 omp_for_copy
->iter
= ggc_vec_alloc
<gimple_omp_for_iter
>
1741 ( gimple_omp_for_collapse (stmt
));
1743 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1745 gimple_omp_for_set_cond (copy
, i
,
1746 gimple_omp_for_cond (stmt
, i
));
1747 gimple_omp_for_set_index (copy
, i
,
1748 gimple_omp_for_index (stmt
, i
));
1749 t
= unshare_expr (gimple_omp_for_initial (stmt
, i
));
1750 gimple_omp_for_set_initial (copy
, i
, t
);
1751 t
= unshare_expr (gimple_omp_for_final (stmt
, i
));
1752 gimple_omp_for_set_final (copy
, i
, t
);
1753 t
= unshare_expr (gimple_omp_for_incr (stmt
, i
));
1754 gimple_omp_for_set_incr (copy
, i
, t
);
1758 case GIMPLE_OMP_PARALLEL
:
1760 gomp_parallel
*omp_par_stmt
= as_a
<gomp_parallel
*> (stmt
);
1761 gomp_parallel
*omp_par_copy
= as_a
<gomp_parallel
*> (copy
);
1762 t
= unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt
));
1763 gimple_omp_parallel_set_clauses (omp_par_copy
, t
);
1764 t
= unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt
));
1765 gimple_omp_parallel_set_child_fn (omp_par_copy
, t
);
1766 t
= unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt
));
1767 gimple_omp_parallel_set_data_arg (omp_par_copy
, t
);
1771 case GIMPLE_OMP_TASK
:
1772 t
= unshare_expr (gimple_omp_task_clauses (stmt
));
1773 gimple_omp_task_set_clauses (copy
, t
);
1774 t
= unshare_expr (gimple_omp_task_child_fn (stmt
));
1775 gimple_omp_task_set_child_fn (copy
, t
);
1776 t
= unshare_expr (gimple_omp_task_data_arg (stmt
));
1777 gimple_omp_task_set_data_arg (copy
, t
);
1778 t
= unshare_expr (gimple_omp_task_copy_fn (stmt
));
1779 gimple_omp_task_set_copy_fn (copy
, t
);
1780 t
= unshare_expr (gimple_omp_task_arg_size (stmt
));
1781 gimple_omp_task_set_arg_size (copy
, t
);
1782 t
= unshare_expr (gimple_omp_task_arg_align (stmt
));
1783 gimple_omp_task_set_arg_align (copy
, t
);
1786 case GIMPLE_OMP_CRITICAL
:
1787 t
= unshare_expr (gimple_omp_critical_name
1788 (as_a
<gomp_critical
*> (stmt
)));
1789 gimple_omp_critical_set_name (as_a
<gomp_critical
*> (copy
), t
);
1790 t
= unshare_expr (gimple_omp_critical_clauses
1791 (as_a
<gomp_critical
*> (stmt
)));
1792 gimple_omp_critical_set_clauses (as_a
<gomp_critical
*> (copy
), t
);
1795 case GIMPLE_OMP_ORDERED
:
1796 t
= unshare_expr (gimple_omp_ordered_clauses
1797 (as_a
<gomp_ordered
*> (stmt
)));
1798 gimple_omp_ordered_set_clauses (as_a
<gomp_ordered
*> (copy
), t
);
1801 case GIMPLE_OMP_SECTIONS
:
1802 t
= unshare_expr (gimple_omp_sections_clauses (stmt
));
1803 gimple_omp_sections_set_clauses (copy
, t
);
1804 t
= unshare_expr (gimple_omp_sections_control (stmt
));
1805 gimple_omp_sections_set_control (copy
, t
);
1808 case GIMPLE_OMP_SINGLE
:
1809 case GIMPLE_OMP_TARGET
:
1810 case GIMPLE_OMP_TEAMS
:
1811 case GIMPLE_OMP_SECTION
:
1812 case GIMPLE_OMP_MASTER
:
1813 case GIMPLE_OMP_TASKGROUP
:
1815 new_seq
= gimple_seq_copy (gimple_omp_body (stmt
));
1816 gimple_omp_set_body (copy
, new_seq
);
1819 case GIMPLE_TRANSACTION
:
1820 new_seq
= gimple_seq_copy (gimple_transaction_body (
1821 as_a
<gtransaction
*> (stmt
)));
1822 gimple_transaction_set_body (as_a
<gtransaction
*> (copy
),
1826 case GIMPLE_WITH_CLEANUP_EXPR
:
1827 new_seq
= gimple_seq_copy (gimple_wce_cleanup (stmt
));
1828 gimple_wce_set_cleanup (copy
, new_seq
);
1836 /* Make copy of operands. */
1837 for (i
= 0; i
< num_ops
; i
++)
1838 gimple_set_op (copy
, i
, unshare_expr (gimple_op (stmt
, i
)));
1840 if (gimple_has_mem_ops (stmt
))
1842 gimple_set_vdef (copy
, gimple_vdef (stmt
));
1843 gimple_set_vuse (copy
, gimple_vuse (stmt
));
1846 /* Clear out SSA operand vectors on COPY. */
1847 if (gimple_has_ops (stmt
))
1849 gimple_set_use_ops (copy
, NULL
);
1851 /* SSA operands need to be updated. */
1852 gimple_set_modified (copy
, true);
1859 /* Return true if statement S has side-effects. We consider a
1860 statement to have side effects if:
1862 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
1863 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
1866 gimple_has_side_effects (const gimple
*s
)
1868 if (is_gimple_debug (s
))
1871 /* We don't have to scan the arguments to check for
1872 volatile arguments, though, at present, we still
1873 do a scan to check for TREE_SIDE_EFFECTS. */
1874 if (gimple_has_volatile_ops (s
))
1877 if (gimple_code (s
) == GIMPLE_ASM
1878 && gimple_asm_volatile_p (as_a
<const gasm
*> (s
)))
1881 if (is_gimple_call (s
))
1883 int flags
= gimple_call_flags (s
);
1885 /* An infinite loop is considered a side effect. */
1886 if (!(flags
& (ECF_CONST
| ECF_PURE
))
1887 || (flags
& ECF_LOOPING_CONST_OR_PURE
))
1896 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
1897 Return true if S can trap. When INCLUDE_MEM is true, check whether
1898 the memory operations could trap. When INCLUDE_STORES is true and
1899 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
1902 gimple_could_trap_p_1 (gimple
*s
, bool include_mem
, bool include_stores
)
1904 tree t
, div
= NULL_TREE
;
1909 unsigned i
, start
= (is_gimple_assign (s
) && !include_stores
) ? 1 : 0;
1911 for (i
= start
; i
< gimple_num_ops (s
); i
++)
1912 if (tree_could_trap_p (gimple_op (s
, i
)))
1916 switch (gimple_code (s
))
1919 return gimple_asm_volatile_p (as_a
<gasm
*> (s
));
1922 t
= gimple_call_fndecl (s
);
1923 /* Assume that calls to weak functions may trap. */
1924 if (!t
|| !DECL_P (t
) || DECL_WEAK (t
))
1929 t
= gimple_expr_type (s
);
1930 op
= gimple_assign_rhs_code (s
);
1931 if (get_gimple_rhs_class (op
) == GIMPLE_BINARY_RHS
)
1932 div
= gimple_assign_rhs2 (s
);
1933 return (operation_could_trap_p (op
, FLOAT_TYPE_P (t
),
1934 (INTEGRAL_TYPE_P (t
)
1935 && TYPE_OVERFLOW_TRAPS (t
)),
1945 /* Return true if statement S can trap. */
1948 gimple_could_trap_p (gimple
*s
)
1950 return gimple_could_trap_p_1 (s
, true, true);
1953 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
1956 gimple_assign_rhs_could_trap_p (gimple
*s
)
1958 gcc_assert (is_gimple_assign (s
));
1959 return gimple_could_trap_p_1 (s
, true, false);
1963 /* Print debugging information for gimple stmts generated. */
1966 dump_gimple_statistics (void)
1968 int i
, total_tuples
= 0, total_bytes
= 0;
1970 if (! GATHER_STATISTICS
)
1972 fprintf (stderr
, "No gimple statistics\n");
1976 fprintf (stderr
, "\nGIMPLE statements\n");
1977 fprintf (stderr
, "Kind Stmts Bytes\n");
1978 fprintf (stderr
, "---------------------------------------\n");
1979 for (i
= 0; i
< (int) gimple_alloc_kind_all
; ++i
)
1981 fprintf (stderr
, "%-20s %7d %10d\n", gimple_alloc_kind_names
[i
],
1982 gimple_alloc_counts
[i
], gimple_alloc_sizes
[i
]);
1983 total_tuples
+= gimple_alloc_counts
[i
];
1984 total_bytes
+= gimple_alloc_sizes
[i
];
1986 fprintf (stderr
, "---------------------------------------\n");
1987 fprintf (stderr
, "%-20s %7d %10d\n", "Total", total_tuples
, total_bytes
);
1988 fprintf (stderr
, "---------------------------------------\n");
1992 /* Return the number of operands needed on the RHS of a GIMPLE
1993 assignment for an expression with tree code CODE. */
1996 get_gimple_rhs_num_ops (enum tree_code code
)
1998 enum gimple_rhs_class rhs_class
= get_gimple_rhs_class (code
);
2000 if (rhs_class
== GIMPLE_UNARY_RHS
|| rhs_class
== GIMPLE_SINGLE_RHS
)
2002 else if (rhs_class
== GIMPLE_BINARY_RHS
)
2004 else if (rhs_class
== GIMPLE_TERNARY_RHS
)
2010 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2012 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2013 : ((TYPE) == tcc_binary \
2014 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2015 : ((TYPE) == tcc_constant \
2016 || (TYPE) == tcc_declaration \
2017 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2018 : ((SYM) == TRUTH_AND_EXPR \
2019 || (SYM) == TRUTH_OR_EXPR \
2020 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2021 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2022 : ((SYM) == COND_EXPR \
2023 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2024 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2025 || (SYM) == DOT_PROD_EXPR \
2026 || (SYM) == SAD_EXPR \
2027 || (SYM) == REALIGN_LOAD_EXPR \
2028 || (SYM) == VEC_COND_EXPR \
2029 || (SYM) == VEC_PERM_EXPR \
2030 || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS \
2031 : ((SYM) == CONSTRUCTOR \
2032 || (SYM) == OBJ_TYPE_REF \
2033 || (SYM) == ASSERT_EXPR \
2034 || (SYM) == ADDR_EXPR \
2035 || (SYM) == WITH_SIZE_EXPR \
2036 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2037 : GIMPLE_INVALID_RHS),
2038 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2040 const unsigned char gimple_rhs_class_table
[] = {
2041 #include "all-tree.def"
2045 #undef END_OF_BASE_TREE_CODES
2047 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2048 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2049 we failed to create one. */
2052 canonicalize_cond_expr_cond (tree t
)
2054 /* Strip conversions around boolean operations. */
2055 if (CONVERT_EXPR_P (t
)
2056 && (truth_value_p (TREE_CODE (TREE_OPERAND (t
, 0)))
2057 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
2059 t
= TREE_OPERAND (t
, 0);
2061 /* For !x use x == 0. */
2062 if (TREE_CODE (t
) == TRUTH_NOT_EXPR
)
2064 tree top0
= TREE_OPERAND (t
, 0);
2065 t
= build2 (EQ_EXPR
, TREE_TYPE (t
),
2066 top0
, build_int_cst (TREE_TYPE (top0
), 0));
2068 /* For cmp ? 1 : 0 use cmp. */
2069 else if (TREE_CODE (t
) == COND_EXPR
2070 && COMPARISON_CLASS_P (TREE_OPERAND (t
, 0))
2071 && integer_onep (TREE_OPERAND (t
, 1))
2072 && integer_zerop (TREE_OPERAND (t
, 2)))
2074 tree top0
= TREE_OPERAND (t
, 0);
2075 t
= build2 (TREE_CODE (top0
), TREE_TYPE (t
),
2076 TREE_OPERAND (top0
, 0), TREE_OPERAND (top0
, 1));
2078 /* For x ^ y use x != y. */
2079 else if (TREE_CODE (t
) == BIT_XOR_EXPR
)
2080 t
= build2 (NE_EXPR
, TREE_TYPE (t
),
2081 TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1));
2083 if (is_gimple_condexpr (t
))
2089 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2090 the positions marked by the set ARGS_TO_SKIP. */
2093 gimple_call_copy_skip_args (gcall
*stmt
, bitmap args_to_skip
)
2096 int nargs
= gimple_call_num_args (stmt
);
2097 auto_vec
<tree
> vargs (nargs
);
2100 for (i
= 0; i
< nargs
; i
++)
2101 if (!bitmap_bit_p (args_to_skip
, i
))
2102 vargs
.quick_push (gimple_call_arg (stmt
, i
));
2104 if (gimple_call_internal_p (stmt
))
2105 new_stmt
= gimple_build_call_internal_vec (gimple_call_internal_fn (stmt
),
2108 new_stmt
= gimple_build_call_vec (gimple_call_fn (stmt
), vargs
);
2110 if (gimple_call_lhs (stmt
))
2111 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2113 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2114 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
2116 if (gimple_has_location (stmt
))
2117 gimple_set_location (new_stmt
, gimple_location (stmt
));
2118 gimple_call_copy_flags (new_stmt
, stmt
);
2119 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2121 gimple_set_modified (new_stmt
, true);
2128 /* Return true if the field decls F1 and F2 are at the same offset.
2130 This is intended to be used on GIMPLE types only. */
2133 gimple_compare_field_offset (tree f1
, tree f2
)
2135 if (DECL_OFFSET_ALIGN (f1
) == DECL_OFFSET_ALIGN (f2
))
2137 tree offset1
= DECL_FIELD_OFFSET (f1
);
2138 tree offset2
= DECL_FIELD_OFFSET (f2
);
2139 return ((offset1
== offset2
2140 /* Once gimplification is done, self-referential offsets are
2141 instantiated as operand #2 of the COMPONENT_REF built for
2142 each access and reset. Therefore, they are not relevant
2143 anymore and fields are interchangeable provided that they
2144 represent the same access. */
2145 || (TREE_CODE (offset1
) == PLACEHOLDER_EXPR
2146 && TREE_CODE (offset2
) == PLACEHOLDER_EXPR
2147 && (DECL_SIZE (f1
) == DECL_SIZE (f2
)
2148 || (TREE_CODE (DECL_SIZE (f1
)) == PLACEHOLDER_EXPR
2149 && TREE_CODE (DECL_SIZE (f2
)) == PLACEHOLDER_EXPR
)
2150 || operand_equal_p (DECL_SIZE (f1
), DECL_SIZE (f2
), 0))
2151 && DECL_ALIGN (f1
) == DECL_ALIGN (f2
))
2152 || operand_equal_p (offset1
, offset2
, 0))
2153 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1
),
2154 DECL_FIELD_BIT_OFFSET (f2
)));
2157 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2158 should be, so handle differing ones specially by decomposing
2159 the offset into a byte and bit offset manually. */
2160 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1
))
2161 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2
)))
2163 unsigned HOST_WIDE_INT byte_offset1
, byte_offset2
;
2164 unsigned HOST_WIDE_INT bit_offset1
, bit_offset2
;
2165 bit_offset1
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1
));
2166 byte_offset1
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1
))
2167 + bit_offset1
/ BITS_PER_UNIT
);
2168 bit_offset2
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2
));
2169 byte_offset2
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2
))
2170 + bit_offset2
/ BITS_PER_UNIT
);
2171 if (byte_offset1
!= byte_offset2
)
2173 return bit_offset1
% BITS_PER_UNIT
== bit_offset2
% BITS_PER_UNIT
;
2180 /* Return a type the same as TYPE except unsigned or
2181 signed according to UNSIGNEDP. */
2184 gimple_signed_or_unsigned_type (bool unsignedp
, tree type
)
2189 type1
= TYPE_MAIN_VARIANT (type
);
2190 if (type1
== signed_char_type_node
2191 || type1
== char_type_node
2192 || type1
== unsigned_char_type_node
)
2193 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2194 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2195 return unsignedp
? unsigned_type_node
: integer_type_node
;
2196 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2197 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2198 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2199 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2200 if (type1
== long_long_integer_type_node
2201 || type1
== long_long_unsigned_type_node
)
2203 ? long_long_unsigned_type_node
2204 : long_long_integer_type_node
;
2206 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2207 if (int_n_enabled_p
[i
]
2208 && (type1
== int_n_trees
[i
].unsigned_type
2209 || type1
== int_n_trees
[i
].signed_type
))
2211 ? int_n_trees
[i
].unsigned_type
2212 : int_n_trees
[i
].signed_type
;
2214 #if HOST_BITS_PER_WIDE_INT >= 64
2215 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2216 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2218 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2219 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2220 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2221 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2222 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2223 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2224 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2225 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2227 #define GIMPLE_FIXED_TYPES(NAME) \
2228 if (type1 == short_ ## NAME ## _type_node \
2229 || type1 == unsigned_short_ ## NAME ## _type_node) \
2230 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2231 : short_ ## NAME ## _type_node; \
2232 if (type1 == NAME ## _type_node \
2233 || type1 == unsigned_ ## NAME ## _type_node) \
2234 return unsignedp ? unsigned_ ## NAME ## _type_node \
2235 : NAME ## _type_node; \
2236 if (type1 == long_ ## NAME ## _type_node \
2237 || type1 == unsigned_long_ ## NAME ## _type_node) \
2238 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2239 : long_ ## NAME ## _type_node; \
2240 if (type1 == long_long_ ## NAME ## _type_node \
2241 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2242 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2243 : long_long_ ## NAME ## _type_node;
2245 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2246 if (type1 == NAME ## _type_node \
2247 || type1 == u ## NAME ## _type_node) \
2248 return unsignedp ? u ## NAME ## _type_node \
2249 : NAME ## _type_node;
2251 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2252 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2253 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2254 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2255 : sat_ ## short_ ## NAME ## _type_node; \
2256 if (type1 == sat_ ## NAME ## _type_node \
2257 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2258 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2259 : sat_ ## NAME ## _type_node; \
2260 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2261 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2262 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2263 : sat_ ## long_ ## NAME ## _type_node; \
2264 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2265 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2266 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2267 : sat_ ## long_long_ ## NAME ## _type_node;
2269 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2270 if (type1 == sat_ ## NAME ## _type_node \
2271 || type1 == sat_ ## u ## NAME ## _type_node) \
2272 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2273 : sat_ ## NAME ## _type_node;
2275 GIMPLE_FIXED_TYPES (fract
);
2276 GIMPLE_FIXED_TYPES_SAT (fract
);
2277 GIMPLE_FIXED_TYPES (accum
);
2278 GIMPLE_FIXED_TYPES_SAT (accum
);
2280 GIMPLE_FIXED_MODE_TYPES (qq
);
2281 GIMPLE_FIXED_MODE_TYPES (hq
);
2282 GIMPLE_FIXED_MODE_TYPES (sq
);
2283 GIMPLE_FIXED_MODE_TYPES (dq
);
2284 GIMPLE_FIXED_MODE_TYPES (tq
);
2285 GIMPLE_FIXED_MODE_TYPES_SAT (qq
);
2286 GIMPLE_FIXED_MODE_TYPES_SAT (hq
);
2287 GIMPLE_FIXED_MODE_TYPES_SAT (sq
);
2288 GIMPLE_FIXED_MODE_TYPES_SAT (dq
);
2289 GIMPLE_FIXED_MODE_TYPES_SAT (tq
);
2290 GIMPLE_FIXED_MODE_TYPES (ha
);
2291 GIMPLE_FIXED_MODE_TYPES (sa
);
2292 GIMPLE_FIXED_MODE_TYPES (da
);
2293 GIMPLE_FIXED_MODE_TYPES (ta
);
2294 GIMPLE_FIXED_MODE_TYPES_SAT (ha
);
2295 GIMPLE_FIXED_MODE_TYPES_SAT (sa
);
2296 GIMPLE_FIXED_MODE_TYPES_SAT (da
);
2297 GIMPLE_FIXED_MODE_TYPES_SAT (ta
);
2299 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2300 the precision; they have precision set to match their range, but
2301 may use a wider mode to match an ABI. If we change modes, we may
2302 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2303 the precision as well, so as to yield correct results for
2304 bit-field types. C++ does not have these separate bit-field
2305 types, and producing a signed or unsigned variant of an
2306 ENUMERAL_TYPE may cause other problems as well. */
2307 if (!INTEGRAL_TYPE_P (type
)
2308 || TYPE_UNSIGNED (type
) == unsignedp
)
2311 #define TYPE_OK(node) \
2312 (TYPE_MODE (type) == TYPE_MODE (node) \
2313 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2314 if (TYPE_OK (signed_char_type_node
))
2315 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2316 if (TYPE_OK (integer_type_node
))
2317 return unsignedp
? unsigned_type_node
: integer_type_node
;
2318 if (TYPE_OK (short_integer_type_node
))
2319 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2320 if (TYPE_OK (long_integer_type_node
))
2321 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2322 if (TYPE_OK (long_long_integer_type_node
))
2324 ? long_long_unsigned_type_node
2325 : long_long_integer_type_node
);
2327 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2328 if (int_n_enabled_p
[i
]
2329 && TYPE_MODE (type
) == int_n_data
[i
].m
2330 && TYPE_PRECISION (type
) == int_n_data
[i
].bitsize
)
2332 ? int_n_trees
[i
].unsigned_type
2333 : int_n_trees
[i
].signed_type
;
2335 #if HOST_BITS_PER_WIDE_INT >= 64
2336 if (TYPE_OK (intTI_type_node
))
2337 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2339 if (TYPE_OK (intDI_type_node
))
2340 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2341 if (TYPE_OK (intSI_type_node
))
2342 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2343 if (TYPE_OK (intHI_type_node
))
2344 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2345 if (TYPE_OK (intQI_type_node
))
2346 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2348 #undef GIMPLE_FIXED_TYPES
2349 #undef GIMPLE_FIXED_MODE_TYPES
2350 #undef GIMPLE_FIXED_TYPES_SAT
2351 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2354 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2358 /* Return an unsigned type the same as TYPE in other respects. */
2361 gimple_unsigned_type (tree type
)
2363 return gimple_signed_or_unsigned_type (true, type
);
2367 /* Return a signed type the same as TYPE in other respects. */
2370 gimple_signed_type (tree type
)
2372 return gimple_signed_or_unsigned_type (false, type
);
2376 /* Return the typed-based alias set for T, which may be an expression
2377 or a type. Return -1 if we don't do anything special. */
2380 gimple_get_alias_set (tree t
)
2384 /* Permit type-punning when accessing a union, provided the access
2385 is directly through the union. For example, this code does not
2386 permit taking the address of a union member and then storing
2387 through it. Even the type-punning allowed here is a GCC
2388 extension, albeit a common and useful one; the C standard says
2389 that such accesses have implementation-defined behavior. */
2391 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2392 u
= TREE_OPERAND (u
, 0))
2393 if (TREE_CODE (u
) == COMPONENT_REF
2394 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2397 /* That's all the expressions we handle specially. */
2401 /* For convenience, follow the C standard when dealing with
2402 character types. Any object may be accessed via an lvalue that
2403 has character type. */
2404 if (t
== char_type_node
2405 || t
== signed_char_type_node
2406 || t
== unsigned_char_type_node
)
2409 /* Allow aliasing between signed and unsigned variants of the same
2410 type. We treat the signed variant as canonical. */
2411 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2413 tree t1
= gimple_signed_type (t
);
2415 /* t1 == t can happen for boolean nodes which are always unsigned. */
2417 return get_alias_set (t1
);
2424 /* Helper for gimple_ior_addresses_taken_1. */
2427 gimple_ior_addresses_taken_1 (gimple
*, tree addr
, tree
, void *data
)
2429 bitmap addresses_taken
= (bitmap
)data
;
2430 addr
= get_base_address (addr
);
2434 bitmap_set_bit (addresses_taken
, DECL_UID (addr
));
2440 /* Set the bit for the uid of all decls that have their address taken
2441 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2442 were any in this stmt. */
2445 gimple_ior_addresses_taken (bitmap addresses_taken
, gimple
*stmt
)
2447 return walk_stmt_load_store_addr_ops (stmt
, addresses_taken
, NULL
, NULL
,
2448 gimple_ior_addresses_taken_1
);
2452 /* Return true if TYPE1 and TYPE2 are compatible enough for builtin
2456 validate_type (tree type1
, tree type2
)
2458 if (INTEGRAL_TYPE_P (type1
)
2459 && INTEGRAL_TYPE_P (type2
))
2461 else if (POINTER_TYPE_P (type1
)
2462 && POINTER_TYPE_P (type2
))
2464 else if (TREE_CODE (type1
)
2465 != TREE_CODE (type2
))
2470 /* Return true when STMTs arguments and return value match those of FNDECL,
2471 a decl of a builtin function. */
2474 gimple_builtin_call_types_compatible_p (const gimple
*stmt
, tree fndecl
)
2476 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
);
2478 tree ret
= gimple_call_lhs (stmt
);
2480 && !validate_type (TREE_TYPE (ret
), TREE_TYPE (TREE_TYPE (fndecl
))))
2483 tree targs
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2484 unsigned nargs
= gimple_call_num_args (stmt
);
2485 for (unsigned i
= 0; i
< nargs
; ++i
)
2487 /* Variadic args follow. */
2490 tree arg
= gimple_call_arg (stmt
, i
);
2491 if (!validate_type (TREE_TYPE (arg
), TREE_VALUE (targs
)))
2493 targs
= TREE_CHAIN (targs
);
2495 if (targs
&& !VOID_TYPE_P (TREE_VALUE (targs
)))
2500 /* Return true when STMT is builtins call. */
2503 gimple_call_builtin_p (const gimple
*stmt
)
2506 if (is_gimple_call (stmt
)
2507 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2508 && DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
)
2509 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2513 /* Return true when STMT is builtins call to CLASS. */
2516 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_class klass
)
2519 if (is_gimple_call (stmt
)
2520 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2521 && DECL_BUILT_IN_CLASS (fndecl
) == klass
)
2522 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2526 /* Return true when STMT is builtins call to CODE of CLASS. */
2529 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_function code
)
2532 if (is_gimple_call (stmt
)
2533 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2534 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
2535 && DECL_FUNCTION_CODE (fndecl
) == code
)
2536 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2540 /* Return true if STMT clobbers memory. STMT is required to be a
2544 gimple_asm_clobbers_memory_p (const gasm
*stmt
)
2548 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
2550 tree op
= gimple_asm_clobber_op (stmt
, i
);
2551 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op
)), "memory") == 0)
2558 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2561 dump_decl_set (FILE *file
, bitmap set
)
2568 fprintf (file
, "{ ");
2570 EXECUTE_IF_SET_IN_BITMAP (set
, 0, i
, bi
)
2572 fprintf (file
, "D.%u", i
);
2573 fprintf (file
, " ");
2576 fprintf (file
, "}");
2579 fprintf (file
, "NIL");
2582 /* Return true when CALL is a call stmt that definitely doesn't
2583 free any memory or makes it unavailable otherwise. */
2585 nonfreeing_call_p (gimple
*call
)
2587 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2588 && gimple_call_flags (call
) & ECF_LEAF
)
2589 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call
)))
2591 /* Just in case these become ECF_LEAF in the future. */
2593 case BUILT_IN_TM_FREE
:
2594 case BUILT_IN_REALLOC
:
2595 case BUILT_IN_STACK_RESTORE
:
2600 else if (gimple_call_internal_p (call
))
2601 switch (gimple_call_internal_fn (call
))
2603 case IFN_ABNORMAL_DISPATCHER
:
2606 if (gimple_call_flags (call
) & ECF_LEAF
)
2611 tree fndecl
= gimple_call_fndecl (call
);
2614 struct cgraph_node
*n
= cgraph_node::get (fndecl
);
2617 enum availability availability
;
2618 n
= n
->function_symbol (&availability
);
2619 if (!n
|| availability
<= AVAIL_INTERPOSABLE
)
2621 return n
->nonfreeing_fn
;
2624 /* Callback for walk_stmt_load_store_ops.
2626 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2629 This routine only makes a superficial check for a dereference. Thus
2630 it must only be used if it is safe to return a false negative. */
2632 check_loadstore (gimple
*, tree op
, tree
, void *data
)
2634 if ((TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
2635 && operand_equal_p (TREE_OPERAND (op
, 0), (tree
)data
, 0))
2641 /* Return true if OP can be inferred to be non-NULL after STMT executes,
2642 either by using a pointer dereference or attributes. */
2644 infer_nonnull_range (gimple
*stmt
, tree op
)
2646 return infer_nonnull_range_by_dereference (stmt
, op
)
2647 || infer_nonnull_range_by_attribute (stmt
, op
);
2650 /* Return true if OP can be inferred to be non-NULL after STMT
2651 executes by using a pointer dereference. */
2653 infer_nonnull_range_by_dereference (gimple
*stmt
, tree op
)
2655 /* We can only assume that a pointer dereference will yield
2656 non-NULL if -fdelete-null-pointer-checks is enabled. */
2657 if (!flag_delete_null_pointer_checks
2658 || !POINTER_TYPE_P (TREE_TYPE (op
))
2659 || gimple_code (stmt
) == GIMPLE_ASM
)
2662 if (walk_stmt_load_store_ops (stmt
, (void *)op
,
2663 check_loadstore
, check_loadstore
))
2669 /* Return true if OP can be inferred to be a non-NULL after STMT
2670 executes by using attributes. */
2672 infer_nonnull_range_by_attribute (gimple
*stmt
, tree op
)
2674 /* We can only assume that a pointer dereference will yield
2675 non-NULL if -fdelete-null-pointer-checks is enabled. */
2676 if (!flag_delete_null_pointer_checks
2677 || !POINTER_TYPE_P (TREE_TYPE (op
))
2678 || gimple_code (stmt
) == GIMPLE_ASM
)
2681 if (is_gimple_call (stmt
) && !gimple_call_internal_p (stmt
))
2683 tree fntype
= gimple_call_fntype (stmt
);
2684 tree attrs
= TYPE_ATTRIBUTES (fntype
);
2685 for (; attrs
; attrs
= TREE_CHAIN (attrs
))
2687 attrs
= lookup_attribute ("nonnull", attrs
);
2689 /* If "nonnull" wasn't specified, we know nothing about
2691 if (attrs
== NULL_TREE
)
2694 /* If "nonnull" applies to all the arguments, then ARG
2695 is non-null if it's in the argument list. */
2696 if (TREE_VALUE (attrs
) == NULL_TREE
)
2698 for (unsigned int i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2700 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt
, i
)))
2701 && operand_equal_p (op
, gimple_call_arg (stmt
, i
), 0))
2707 /* Now see if op appears in the nonnull list. */
2708 for (tree t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
2710 unsigned int idx
= TREE_INT_CST_LOW (TREE_VALUE (t
)) - 1;
2711 if (idx
< gimple_call_num_args (stmt
))
2713 tree arg
= gimple_call_arg (stmt
, idx
);
2714 if (operand_equal_p (op
, arg
, 0))
2721 /* If this function is marked as returning non-null, then we can
2722 infer OP is non-null if it is used in the return statement. */
2723 if (greturn
*return_stmt
= dyn_cast
<greturn
*> (stmt
))
2724 if (gimple_return_retval (return_stmt
)
2725 && operand_equal_p (gimple_return_retval (return_stmt
), op
, 0)
2726 && lookup_attribute ("returns_nonnull",
2727 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
))))
2733 /* Compare two case labels. Because the front end should already have
2734 made sure that case ranges do not overlap, it is enough to only compare
2735 the CASE_LOW values of each case label. */
2738 compare_case_labels (const void *p1
, const void *p2
)
2740 const_tree
const case1
= *(const_tree
const*)p1
;
2741 const_tree
const case2
= *(const_tree
const*)p2
;
2743 /* The 'default' case label always goes first. */
2744 if (!CASE_LOW (case1
))
2746 else if (!CASE_LOW (case2
))
2749 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
2752 /* Sort the case labels in LABEL_VEC in place in ascending order. */
2755 sort_case_labels (vec
<tree
> label_vec
)
2757 label_vec
.qsort (compare_case_labels
);
2760 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2762 LABELS is a vector that contains all case labels to look at.
2764 INDEX_TYPE is the type of the switch index expression. Case labels
2765 in LABELS are discarded if their values are not in the value range
2766 covered by INDEX_TYPE. The remaining case label values are folded
2769 If a default case exists in LABELS, it is removed from LABELS and
2770 returned in DEFAULT_CASEP. If no default case exists, but the
2771 case labels already cover the whole range of INDEX_TYPE, a default
2772 case is returned pointing to one of the existing case labels.
2773 Otherwise DEFAULT_CASEP is set to NULL_TREE.
2775 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2776 apply and no action is taken regardless of whether a default case is
2780 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
2782 tree
*default_casep
)
2784 tree min_value
, max_value
;
2785 tree default_case
= NULL_TREE
;
2789 min_value
= TYPE_MIN_VALUE (index_type
);
2790 max_value
= TYPE_MAX_VALUE (index_type
);
2791 while (i
< labels
.length ())
2793 tree elt
= labels
[i
];
2794 tree low
= CASE_LOW (elt
);
2795 tree high
= CASE_HIGH (elt
);
2796 bool remove_element
= FALSE
;
2800 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
2801 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
2803 /* This is a non-default case label, i.e. it has a value.
2805 See if the case label is reachable within the range of
2806 the index type. Remove out-of-range case values. Turn
2807 case ranges into a canonical form (high > low strictly)
2808 and convert the case label values to the index type.
2810 NB: The type of gimple_switch_index() may be the promoted
2811 type, but the case labels retain the original type. */
2815 /* This is a case range. Discard empty ranges.
2816 If the bounds or the range are equal, turn this
2817 into a simple (one-value) case. */
2818 int cmp
= tree_int_cst_compare (high
, low
);
2820 remove_element
= TRUE
;
2827 /* If the simple case value is unreachable, ignore it. */
2828 if ((TREE_CODE (min_value
) == INTEGER_CST
2829 && tree_int_cst_compare (low
, min_value
) < 0)
2830 || (TREE_CODE (max_value
) == INTEGER_CST
2831 && tree_int_cst_compare (low
, max_value
) > 0))
2832 remove_element
= TRUE
;
2834 low
= fold_convert (index_type
, low
);
2838 /* If the entire case range is unreachable, ignore it. */
2839 if ((TREE_CODE (min_value
) == INTEGER_CST
2840 && tree_int_cst_compare (high
, min_value
) < 0)
2841 || (TREE_CODE (max_value
) == INTEGER_CST
2842 && tree_int_cst_compare (low
, max_value
) > 0))
2843 remove_element
= TRUE
;
2846 /* If the lower bound is less than the index type's
2847 minimum value, truncate the range bounds. */
2848 if (TREE_CODE (min_value
) == INTEGER_CST
2849 && tree_int_cst_compare (low
, min_value
) < 0)
2851 low
= fold_convert (index_type
, low
);
2853 /* If the upper bound is greater than the index type's
2854 maximum value, truncate the range bounds. */
2855 if (TREE_CODE (max_value
) == INTEGER_CST
2856 && tree_int_cst_compare (high
, max_value
) > 0)
2858 high
= fold_convert (index_type
, high
);
2860 /* We may have folded a case range to a one-value case. */
2861 if (tree_int_cst_equal (low
, high
))
2866 CASE_LOW (elt
) = low
;
2867 CASE_HIGH (elt
) = high
;
2871 gcc_assert (!default_case
);
2873 /* The default case must be passed separately to the
2874 gimple_build_switch routine. But if DEFAULT_CASEP
2875 is NULL, we do not remove the default case (it would
2876 be completely lost). */
2878 remove_element
= TRUE
;
2882 labels
.ordered_remove (i
);
2888 if (!labels
.is_empty ())
2889 sort_case_labels (labels
);
2891 if (default_casep
&& !default_case
)
2893 /* If the switch has no default label, add one, so that we jump
2894 around the switch body. If the labels already cover the whole
2895 range of the switch index_type, add the default label pointing
2896 to one of the existing labels. */
2898 && TYPE_MIN_VALUE (index_type
)
2899 && TYPE_MAX_VALUE (index_type
)
2900 && tree_int_cst_equal (CASE_LOW (labels
[0]),
2901 TYPE_MIN_VALUE (index_type
)))
2903 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
2905 high
= CASE_LOW (labels
[len
- 1]);
2906 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
2908 for (i
= 1; i
< len
; i
++)
2910 high
= CASE_LOW (labels
[i
]);
2911 low
= CASE_HIGH (labels
[i
- 1]);
2913 low
= CASE_LOW (labels
[i
- 1]);
2914 if (wi::add (low
, 1) != high
)
2919 tree label
= CASE_LABEL (labels
[0]);
2920 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
2928 *default_casep
= default_case
;
2931 /* Set the location of all statements in SEQ to LOC. */
2934 gimple_seq_set_location (gimple_seq seq
, location_t loc
)
2936 for (gimple_stmt_iterator i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
2937 gimple_set_location (gsi_stmt (i
), loc
);
2940 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
2943 gimple_seq_discard (gimple_seq seq
)
2945 gimple_stmt_iterator gsi
;
2947 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); )
2949 gimple
*stmt
= gsi_stmt (gsi
);
2950 gsi_remove (&gsi
, true);
2951 release_defs (stmt
);
2956 /* See if STMT now calls function that takes no parameters and if so, drop
2957 call arguments. This is used when devirtualization machinery redirects
2958 to __builtiln_unreacahble or __cxa_pure_virutal. */
2961 maybe_remove_unused_call_args (struct function
*fn
, gimple
*stmt
)
2963 tree decl
= gimple_call_fndecl (stmt
);
2964 if (TYPE_ARG_TYPES (TREE_TYPE (decl
))
2965 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
))) == void_type_node
2966 && gimple_call_num_args (stmt
))
2968 gimple_set_num_ops (stmt
, 3);
2969 update_stmt_fn (fn
, stmt
);