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"
31 #include "diagnostic.h"
33 #include "fold-const.h"
36 #include "stor-layout.h"
37 #include "internal-fn.h"
39 #include "gimple-iterator.h"
40 #include "gimple-walk.h"
42 #include "value-prof.h"
45 #include "langhooks.h"
48 /* All the tuples have their operand vector (if present) at the very bottom
49 of the structure. Therefore, the offset required to find the
50 operands vector the size of the structure minus the size of the 1
51 element tree array at the end (see gimple_ops). */
52 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
53 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
54 EXPORTED_CONST
size_t gimple_ops_offset_
[] = {
55 #include "gsstruct.def"
59 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
60 static const size_t gsstruct_code_size
[] = {
61 #include "gsstruct.def"
65 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
66 const char *const gimple_code_name
[] = {
71 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
72 EXPORTED_CONST
enum gimple_statement_structure_enum gss_for_code_
[] = {
79 int gimple_alloc_counts
[(int) gimple_alloc_kind_all
];
80 int gimple_alloc_sizes
[(int) gimple_alloc_kind_all
];
82 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
83 static const char * const gimple_alloc_kind_names
[] = {
90 /* Static gimple tuple members. */
91 const enum gimple_code
gassign::code_
;
92 const enum gimple_code
gcall::code_
;
93 const enum gimple_code
gcond::code_
;
96 /* Gimple tuple constructors.
97 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
98 be passed a NULL to start with an empty sequence. */
100 /* Set the code for statement G to CODE. */
103 gimple_set_code (gimple
*g
, enum gimple_code code
)
108 /* Return the number of bytes needed to hold a GIMPLE statement with
112 gimple_size (enum gimple_code code
)
114 return gsstruct_code_size
[gss_for_code (code
)];
117 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
121 gimple_alloc_stat (enum gimple_code code
, unsigned num_ops MEM_STAT_DECL
)
126 size
= gimple_size (code
);
128 size
+= sizeof (tree
) * (num_ops
- 1);
130 if (GATHER_STATISTICS
)
132 enum gimple_alloc_kind kind
= gimple_alloc_kind (code
);
133 gimple_alloc_counts
[(int) kind
]++;
134 gimple_alloc_sizes
[(int) kind
] += size
;
137 stmt
= ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT
);
138 gimple_set_code (stmt
, code
);
139 gimple_set_num_ops (stmt
, num_ops
);
141 /* Do not call gimple_set_modified here as it has other side
142 effects and this tuple is still not completely built. */
144 gimple_init_singleton (stmt
);
149 /* Set SUBCODE to be the code of the expression computed by statement G. */
152 gimple_set_subcode (gimple
*g
, unsigned subcode
)
154 /* We only have 16 bits for the RHS code. Assert that we are not
156 gcc_assert (subcode
< (1 << 16));
157 g
->subcode
= subcode
;
162 /* Build a tuple with operands. CODE is the statement to build (which
163 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
164 for the new tuple. NUM_OPS is the number of operands to allocate. */
166 #define gimple_build_with_ops(c, s, n) \
167 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
170 gimple_build_with_ops_stat (enum gimple_code code
, unsigned subcode
,
171 unsigned num_ops MEM_STAT_DECL
)
173 gimple
*s
= gimple_alloc_stat (code
, num_ops PASS_MEM_STAT
);
174 gimple_set_subcode (s
, subcode
);
180 /* Build a GIMPLE_RETURN statement returning RETVAL. */
183 gimple_build_return (tree retval
)
186 = as_a
<greturn
*> (gimple_build_with_ops (GIMPLE_RETURN
, ERROR_MARK
,
189 gimple_return_set_retval (s
, retval
);
193 /* Reset alias information on call S. */
196 gimple_call_reset_alias_info (gcall
*s
)
198 if (gimple_call_flags (s
) & ECF_CONST
)
199 memset (gimple_call_use_set (s
), 0, sizeof (struct pt_solution
));
201 pt_solution_reset (gimple_call_use_set (s
));
202 if (gimple_call_flags (s
) & (ECF_CONST
|ECF_PURE
|ECF_NOVOPS
))
203 memset (gimple_call_clobber_set (s
), 0, sizeof (struct pt_solution
));
205 pt_solution_reset (gimple_call_clobber_set (s
));
208 /* Helper for gimple_build_call, gimple_build_call_valist,
209 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
210 components of a GIMPLE_CALL statement to function FN with NARGS
213 static inline gcall
*
214 gimple_build_call_1 (tree fn
, unsigned nargs
)
217 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
219 if (TREE_CODE (fn
) == FUNCTION_DECL
)
220 fn
= build_fold_addr_expr (fn
);
221 gimple_set_op (s
, 1, fn
);
222 gimple_call_set_fntype (s
, TREE_TYPE (TREE_TYPE (fn
)));
223 gimple_call_reset_alias_info (s
);
228 /* Build a GIMPLE_CALL statement to function FN with the arguments
229 specified in vector ARGS. */
232 gimple_build_call_vec (tree fn
, vec
<tree
> args
)
235 unsigned nargs
= args
.length ();
236 gcall
*call
= gimple_build_call_1 (fn
, nargs
);
238 for (i
= 0; i
< nargs
; i
++)
239 gimple_call_set_arg (call
, i
, args
[i
]);
245 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
246 arguments. The ... are the arguments. */
249 gimple_build_call (tree fn
, unsigned nargs
, ...)
255 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
257 call
= gimple_build_call_1 (fn
, nargs
);
259 va_start (ap
, nargs
);
260 for (i
= 0; i
< nargs
; i
++)
261 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
268 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
269 arguments. AP contains the arguments. */
272 gimple_build_call_valist (tree fn
, unsigned nargs
, va_list ap
)
277 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
279 call
= gimple_build_call_1 (fn
, nargs
);
281 for (i
= 0; i
< nargs
; i
++)
282 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
288 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
289 Build the basic components of a GIMPLE_CALL statement to internal
290 function FN with NARGS arguments. */
292 static inline gcall
*
293 gimple_build_call_internal_1 (enum internal_fn fn
, unsigned nargs
)
296 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
298 s
->subcode
|= GF_CALL_INTERNAL
;
299 gimple_call_set_internal_fn (s
, fn
);
300 gimple_call_reset_alias_info (s
);
305 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
306 the number of arguments. The ... are the arguments. */
309 gimple_build_call_internal (enum internal_fn fn
, unsigned nargs
, ...)
315 call
= gimple_build_call_internal_1 (fn
, nargs
);
316 va_start (ap
, nargs
);
317 for (i
= 0; i
< nargs
; i
++)
318 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
325 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
326 specified in vector ARGS. */
329 gimple_build_call_internal_vec (enum internal_fn fn
, vec
<tree
> args
)
334 nargs
= args
.length ();
335 call
= gimple_build_call_internal_1 (fn
, nargs
);
336 for (i
= 0; i
< nargs
; i
++)
337 gimple_call_set_arg (call
, i
, args
[i
]);
343 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
344 assumed to be in GIMPLE form already. Minimal checking is done of
348 gimple_build_call_from_tree (tree t
)
352 tree fndecl
= get_callee_fndecl (t
);
354 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
356 nargs
= call_expr_nargs (t
);
357 call
= gimple_build_call_1 (fndecl
? fndecl
: CALL_EXPR_FN (t
), nargs
);
359 for (i
= 0; i
< nargs
; i
++)
360 gimple_call_set_arg (call
, i
, CALL_EXPR_ARG (t
, i
));
362 gimple_set_block (call
, TREE_BLOCK (t
));
364 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
365 gimple_call_set_chain (call
, CALL_EXPR_STATIC_CHAIN (t
));
366 gimple_call_set_tail (call
, CALL_EXPR_TAILCALL (t
));
367 gimple_call_set_return_slot_opt (call
, CALL_EXPR_RETURN_SLOT_OPT (t
));
369 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
370 && (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA
371 || DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
372 gimple_call_set_alloca_for_var (call
, CALL_ALLOCA_FOR_VAR_P (t
));
374 gimple_call_set_from_thunk (call
, CALL_FROM_THUNK_P (t
));
375 gimple_call_set_va_arg_pack (call
, CALL_EXPR_VA_ARG_PACK (t
));
376 gimple_call_set_nothrow (call
, TREE_NOTHROW (t
));
377 gimple_set_no_warning (call
, TREE_NO_WARNING (t
));
378 gimple_call_set_with_bounds (call
, CALL_WITH_BOUNDS_P (t
));
384 /* Build a GIMPLE_ASSIGN statement.
386 LHS of the assignment.
387 RHS of the assignment which can be unary or binary. */
390 gimple_build_assign (tree lhs
, tree rhs MEM_STAT_DECL
)
392 enum tree_code subcode
;
395 extract_ops_from_tree_1 (rhs
, &subcode
, &op1
, &op2
, &op3
);
396 return gimple_build_assign (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
400 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
403 static inline gassign
*
404 gimple_build_assign_1 (tree lhs
, enum tree_code subcode
, tree op1
,
405 tree op2
, tree op3 MEM_STAT_DECL
)
410 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
412 num_ops
= get_gimple_rhs_num_ops (subcode
) + 1;
414 p
= as_a
<gassign
*> (
415 gimple_build_with_ops_stat (GIMPLE_ASSIGN
, (unsigned)subcode
, num_ops
417 gimple_assign_set_lhs (p
, lhs
);
418 gimple_assign_set_rhs1 (p
, op1
);
421 gcc_assert (num_ops
> 2);
422 gimple_assign_set_rhs2 (p
, op2
);
427 gcc_assert (num_ops
> 3);
428 gimple_assign_set_rhs3 (p
, op3
);
434 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
438 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
439 tree op2
, tree op3 MEM_STAT_DECL
)
441 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
444 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
448 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
449 tree op2 MEM_STAT_DECL
)
451 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, NULL_TREE
455 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
458 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1 MEM_STAT_DECL
)
460 return gimple_build_assign_1 (lhs
, subcode
, op1
, NULL_TREE
, NULL_TREE
465 /* Build a GIMPLE_COND statement.
467 PRED is the condition used to compare LHS and the RHS.
468 T_LABEL is the label to jump to if the condition is true.
469 F_LABEL is the label to jump to otherwise. */
472 gimple_build_cond (enum tree_code pred_code
, tree lhs
, tree rhs
,
473 tree t_label
, tree f_label
)
477 gcc_assert (TREE_CODE_CLASS (pred_code
) == tcc_comparison
);
478 p
= as_a
<gcond
*> (gimple_build_with_ops (GIMPLE_COND
, pred_code
, 4));
479 gimple_cond_set_lhs (p
, lhs
);
480 gimple_cond_set_rhs (p
, rhs
);
481 gimple_cond_set_true_label (p
, t_label
);
482 gimple_cond_set_false_label (p
, f_label
);
486 /* Build a GIMPLE_COND statement from the conditional expression tree
487 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
490 gimple_build_cond_from_tree (tree cond
, tree t_label
, tree f_label
)
495 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
496 return gimple_build_cond (code
, lhs
, rhs
, t_label
, f_label
);
499 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
500 boolean expression tree COND. */
503 gimple_cond_set_condition_from_tree (gcond
*stmt
, tree cond
)
508 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
509 gimple_cond_set_condition (stmt
, code
, lhs
, rhs
);
512 /* Build a GIMPLE_LABEL statement for LABEL. */
515 gimple_build_label (tree label
)
518 = as_a
<glabel
*> (gimple_build_with_ops (GIMPLE_LABEL
, ERROR_MARK
, 1));
519 gimple_label_set_label (p
, label
);
523 /* Build a GIMPLE_GOTO statement to label DEST. */
526 gimple_build_goto (tree dest
)
529 = as_a
<ggoto
*> (gimple_build_with_ops (GIMPLE_GOTO
, ERROR_MARK
, 1));
530 gimple_goto_set_dest (p
, dest
);
535 /* Build a GIMPLE_NOP statement. */
538 gimple_build_nop (void)
540 return gimple_alloc (GIMPLE_NOP
, 0);
544 /* Build a GIMPLE_BIND statement.
545 VARS are the variables in BODY.
546 BLOCK is the containing block. */
549 gimple_build_bind (tree vars
, gimple_seq body
, tree block
)
551 gbind
*p
= as_a
<gbind
*> (gimple_alloc (GIMPLE_BIND
, 0));
552 gimple_bind_set_vars (p
, vars
);
554 gimple_bind_set_body (p
, body
);
556 gimple_bind_set_block (p
, block
);
560 /* Helper function to set the simple fields of a asm stmt.
562 STRING is a pointer to a string that is the asm blocks assembly code.
563 NINPUT is the number of register inputs.
564 NOUTPUT is the number of register outputs.
565 NCLOBBERS is the number of clobbered registers.
569 gimple_build_asm_1 (const char *string
, unsigned ninputs
, unsigned noutputs
,
570 unsigned nclobbers
, unsigned nlabels
)
573 int size
= strlen (string
);
575 /* ASMs with labels cannot have outputs. This should have been
576 enforced by the front end. */
577 gcc_assert (nlabels
== 0 || noutputs
== 0);
580 gimple_build_with_ops (GIMPLE_ASM
, ERROR_MARK
,
581 ninputs
+ noutputs
+ nclobbers
+ nlabels
));
587 p
->string
= ggc_alloc_string (string
, size
);
589 if (GATHER_STATISTICS
)
590 gimple_alloc_sizes
[(int) gimple_alloc_kind (GIMPLE_ASM
)] += size
;
595 /* Build a GIMPLE_ASM statement.
597 STRING is the assembly code.
598 NINPUT is the number of register inputs.
599 NOUTPUT is the number of register outputs.
600 NCLOBBERS is the number of clobbered registers.
601 INPUTS is a vector of the input register parameters.
602 OUTPUTS is a vector of the output register parameters.
603 CLOBBERS is a vector of the clobbered register parameters.
604 LABELS is a vector of destination labels. */
607 gimple_build_asm_vec (const char *string
, vec
<tree
, va_gc
> *inputs
,
608 vec
<tree
, va_gc
> *outputs
, vec
<tree
, va_gc
> *clobbers
,
609 vec
<tree
, va_gc
> *labels
)
614 p
= gimple_build_asm_1 (string
,
615 vec_safe_length (inputs
),
616 vec_safe_length (outputs
),
617 vec_safe_length (clobbers
),
618 vec_safe_length (labels
));
620 for (i
= 0; i
< vec_safe_length (inputs
); i
++)
621 gimple_asm_set_input_op (p
, i
, (*inputs
)[i
]);
623 for (i
= 0; i
< vec_safe_length (outputs
); i
++)
624 gimple_asm_set_output_op (p
, i
, (*outputs
)[i
]);
626 for (i
= 0; i
< vec_safe_length (clobbers
); i
++)
627 gimple_asm_set_clobber_op (p
, i
, (*clobbers
)[i
]);
629 for (i
= 0; i
< vec_safe_length (labels
); i
++)
630 gimple_asm_set_label_op (p
, i
, (*labels
)[i
]);
635 /* Build a GIMPLE_CATCH statement.
637 TYPES are the catch types.
638 HANDLER is the exception handler. */
641 gimple_build_catch (tree types
, gimple_seq handler
)
643 gcatch
*p
= as_a
<gcatch
*> (gimple_alloc (GIMPLE_CATCH
, 0));
644 gimple_catch_set_types (p
, types
);
646 gimple_catch_set_handler (p
, handler
);
651 /* Build a GIMPLE_EH_FILTER statement.
653 TYPES are the filter's types.
654 FAILURE is the filter's failure action. */
657 gimple_build_eh_filter (tree types
, gimple_seq failure
)
659 geh_filter
*p
= as_a
<geh_filter
*> (gimple_alloc (GIMPLE_EH_FILTER
, 0));
660 gimple_eh_filter_set_types (p
, types
);
662 gimple_eh_filter_set_failure (p
, failure
);
667 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
670 gimple_build_eh_must_not_throw (tree decl
)
672 geh_mnt
*p
= as_a
<geh_mnt
*> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW
, 0));
674 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
675 gcc_assert (flags_from_decl_or_type (decl
) & ECF_NORETURN
);
676 gimple_eh_must_not_throw_set_fndecl (p
, decl
);
681 /* Build a GIMPLE_EH_ELSE statement. */
684 gimple_build_eh_else (gimple_seq n_body
, gimple_seq e_body
)
686 geh_else
*p
= as_a
<geh_else
*> (gimple_alloc (GIMPLE_EH_ELSE
, 0));
687 gimple_eh_else_set_n_body (p
, n_body
);
688 gimple_eh_else_set_e_body (p
, e_body
);
692 /* Build a GIMPLE_TRY statement.
694 EVAL is the expression to evaluate.
695 CLEANUP is the cleanup expression.
696 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
697 whether this is a try/catch or a try/finally respectively. */
700 gimple_build_try (gimple_seq eval
, gimple_seq cleanup
,
701 enum gimple_try_flags kind
)
705 gcc_assert (kind
== GIMPLE_TRY_CATCH
|| kind
== GIMPLE_TRY_FINALLY
);
706 p
= as_a
<gtry
*> (gimple_alloc (GIMPLE_TRY
, 0));
707 gimple_set_subcode (p
, kind
);
709 gimple_try_set_eval (p
, eval
);
711 gimple_try_set_cleanup (p
, cleanup
);
716 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
718 CLEANUP is the cleanup expression. */
721 gimple_build_wce (gimple_seq cleanup
)
723 gimple
*p
= gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR
, 0);
725 gimple_wce_set_cleanup (p
, cleanup
);
731 /* Build a GIMPLE_RESX statement. */
734 gimple_build_resx (int region
)
737 = as_a
<gresx
*> (gimple_build_with_ops (GIMPLE_RESX
, ERROR_MARK
, 0));
743 /* The helper for constructing a gimple switch statement.
744 INDEX is the switch's index.
745 NLABELS is the number of labels in the switch excluding the default.
746 DEFAULT_LABEL is the default label for the switch statement. */
749 gimple_build_switch_nlabels (unsigned nlabels
, tree index
, tree default_label
)
751 /* nlabels + 1 default label + 1 index. */
752 gcc_checking_assert (default_label
);
753 gswitch
*p
= as_a
<gswitch
*> (gimple_build_with_ops (GIMPLE_SWITCH
,
756 gimple_switch_set_index (p
, index
);
757 gimple_switch_set_default_label (p
, default_label
);
761 /* Build a GIMPLE_SWITCH statement.
763 INDEX is the switch's index.
764 DEFAULT_LABEL is the default label
765 ARGS is a vector of labels excluding the default. */
768 gimple_build_switch (tree index
, tree default_label
, vec
<tree
> args
)
770 unsigned i
, nlabels
= args
.length ();
772 gswitch
*p
= gimple_build_switch_nlabels (nlabels
, index
, default_label
);
774 /* Copy the labels from the vector to the switch statement. */
775 for (i
= 0; i
< nlabels
; i
++)
776 gimple_switch_set_label (p
, i
+ 1, args
[i
]);
781 /* Build a GIMPLE_EH_DISPATCH statement. */
784 gimple_build_eh_dispatch (int region
)
787 = as_a
<geh_dispatch
*> (
788 gimple_build_with_ops (GIMPLE_EH_DISPATCH
, ERROR_MARK
, 0));
793 /* Build a new GIMPLE_DEBUG_BIND statement.
795 VAR is bound to VALUE; block and location are taken from STMT. */
798 gimple_build_debug_bind_stat (tree var
, tree value
, gimple
*stmt MEM_STAT_DECL
)
801 = as_a
<gdebug
*> (gimple_build_with_ops_stat (GIMPLE_DEBUG
,
802 (unsigned)GIMPLE_DEBUG_BIND
, 2
804 gimple_debug_bind_set_var (p
, var
);
805 gimple_debug_bind_set_value (p
, value
);
807 gimple_set_location (p
, gimple_location (stmt
));
813 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
815 VAR is bound to VALUE; block and location are taken from STMT. */
818 gimple_build_debug_source_bind_stat (tree var
, tree value
,
819 gimple
*stmt MEM_STAT_DECL
)
823 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
824 (unsigned)GIMPLE_DEBUG_SOURCE_BIND
, 2
827 gimple_debug_source_bind_set_var (p
, var
);
828 gimple_debug_source_bind_set_value (p
, value
);
830 gimple_set_location (p
, gimple_location (stmt
));
836 /* Build a GIMPLE_OMP_CRITICAL statement.
838 BODY is the sequence of statements for which only one thread can execute.
839 NAME is optional identifier for this critical block.
840 CLAUSES are clauses for this critical block. */
843 gimple_build_omp_critical (gimple_seq body
, tree name
, tree clauses
)
846 = as_a
<gomp_critical
*> (gimple_alloc (GIMPLE_OMP_CRITICAL
, 0));
847 gimple_omp_critical_set_name (p
, name
);
848 gimple_omp_critical_set_clauses (p
, clauses
);
850 gimple_omp_set_body (p
, body
);
855 /* Build a GIMPLE_OMP_FOR statement.
857 BODY is sequence of statements inside the for loop.
858 KIND is the `for' variant.
859 CLAUSES, are any of the construct's clauses.
860 COLLAPSE is the collapse count.
861 PRE_BODY is the sequence of statements that are loop invariant. */
864 gimple_build_omp_for (gimple_seq body
, int kind
, tree clauses
, size_t collapse
,
867 gomp_for
*p
= as_a
<gomp_for
*> (gimple_alloc (GIMPLE_OMP_FOR
, 0));
869 gimple_omp_set_body (p
, body
);
870 gimple_omp_for_set_clauses (p
, clauses
);
871 gimple_omp_for_set_kind (p
, kind
);
872 p
->collapse
= collapse
;
873 p
->iter
= ggc_cleared_vec_alloc
<gimple_omp_for_iter
> (collapse
);
876 gimple_omp_for_set_pre_body (p
, pre_body
);
882 /* Build a GIMPLE_OMP_PARALLEL statement.
884 BODY is sequence of statements which are executed in parallel.
885 CLAUSES, are the OMP parallel construct's clauses.
886 CHILD_FN is the function created for the parallel threads to execute.
887 DATA_ARG are the shared data argument(s). */
890 gimple_build_omp_parallel (gimple_seq body
, tree clauses
, tree child_fn
,
894 = as_a
<gomp_parallel
*> (gimple_alloc (GIMPLE_OMP_PARALLEL
, 0));
896 gimple_omp_set_body (p
, body
);
897 gimple_omp_parallel_set_clauses (p
, clauses
);
898 gimple_omp_parallel_set_child_fn (p
, child_fn
);
899 gimple_omp_parallel_set_data_arg (p
, data_arg
);
905 /* Build a GIMPLE_OMP_TASK statement.
907 BODY is sequence of statements which are executed by the explicit task.
908 CLAUSES, are the OMP parallel construct's clauses.
909 CHILD_FN is the function created for the parallel threads to execute.
910 DATA_ARG are the shared data argument(s).
911 COPY_FN is the optional function for firstprivate initialization.
912 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
915 gimple_build_omp_task (gimple_seq body
, tree clauses
, tree child_fn
,
916 tree data_arg
, tree copy_fn
, tree arg_size
,
919 gomp_task
*p
= as_a
<gomp_task
*> (gimple_alloc (GIMPLE_OMP_TASK
, 0));
921 gimple_omp_set_body (p
, body
);
922 gimple_omp_task_set_clauses (p
, clauses
);
923 gimple_omp_task_set_child_fn (p
, child_fn
);
924 gimple_omp_task_set_data_arg (p
, data_arg
);
925 gimple_omp_task_set_copy_fn (p
, copy_fn
);
926 gimple_omp_task_set_arg_size (p
, arg_size
);
927 gimple_omp_task_set_arg_align (p
, arg_align
);
933 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
935 BODY is the sequence of statements in the section. */
938 gimple_build_omp_section (gimple_seq body
)
940 gimple
*p
= gimple_alloc (GIMPLE_OMP_SECTION
, 0);
942 gimple_omp_set_body (p
, body
);
948 /* Build a GIMPLE_OMP_MASTER statement.
950 BODY is the sequence of statements to be executed by just the master. */
953 gimple_build_omp_master (gimple_seq body
)
955 gimple
*p
= gimple_alloc (GIMPLE_OMP_MASTER
, 0);
957 gimple_omp_set_body (p
, body
);
963 /* Build a GIMPLE_OMP_TASKGROUP statement.
965 BODY is the sequence of statements to be executed by the taskgroup
969 gimple_build_omp_taskgroup (gimple_seq body
)
971 gimple
*p
= gimple_alloc (GIMPLE_OMP_TASKGROUP
, 0);
973 gimple_omp_set_body (p
, body
);
979 /* Build a GIMPLE_OMP_CONTINUE statement.
981 CONTROL_DEF is the definition of the control variable.
982 CONTROL_USE is the use of the control variable. */
985 gimple_build_omp_continue (tree control_def
, tree control_use
)
988 = as_a
<gomp_continue
*> (gimple_alloc (GIMPLE_OMP_CONTINUE
, 0));
989 gimple_omp_continue_set_control_def (p
, control_def
);
990 gimple_omp_continue_set_control_use (p
, control_use
);
994 /* Build a GIMPLE_OMP_ORDERED statement.
996 BODY is the sequence of statements inside a loop that will executed in
998 CLAUSES are clauses for this statement. */
1001 gimple_build_omp_ordered (gimple_seq body
, tree clauses
)
1004 = as_a
<gomp_ordered
*> (gimple_alloc (GIMPLE_OMP_ORDERED
, 0));
1005 gimple_omp_ordered_set_clauses (p
, clauses
);
1007 gimple_omp_set_body (p
, body
);
1013 /* Build a GIMPLE_OMP_RETURN statement.
1014 WAIT_P is true if this is a non-waiting return. */
1017 gimple_build_omp_return (bool wait_p
)
1019 gimple
*p
= gimple_alloc (GIMPLE_OMP_RETURN
, 0);
1021 gimple_omp_return_set_nowait (p
);
1027 /* Build a GIMPLE_OMP_SECTIONS statement.
1029 BODY is a sequence of section statements.
1030 CLAUSES are any of the OMP sections contsruct's clauses: private,
1031 firstprivate, lastprivate, reduction, and nowait. */
1034 gimple_build_omp_sections (gimple_seq body
, tree clauses
)
1037 = as_a
<gomp_sections
*> (gimple_alloc (GIMPLE_OMP_SECTIONS
, 0));
1039 gimple_omp_set_body (p
, body
);
1040 gimple_omp_sections_set_clauses (p
, clauses
);
1046 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1049 gimple_build_omp_sections_switch (void)
1051 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH
, 0);
1055 /* Build a GIMPLE_OMP_SINGLE statement.
1057 BODY is the sequence of statements that will be executed once.
1058 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1059 copyprivate, nowait. */
1062 gimple_build_omp_single (gimple_seq body
, tree clauses
)
1065 = as_a
<gomp_single
*> (gimple_alloc (GIMPLE_OMP_SINGLE
, 0));
1067 gimple_omp_set_body (p
, body
);
1068 gimple_omp_single_set_clauses (p
, clauses
);
1074 /* Build a GIMPLE_OMP_TARGET statement.
1076 BODY is the sequence of statements that will be executed.
1077 KIND is the kind of the region.
1078 CLAUSES are any of the construct's clauses. */
1081 gimple_build_omp_target (gimple_seq body
, int kind
, tree clauses
)
1084 = as_a
<gomp_target
*> (gimple_alloc (GIMPLE_OMP_TARGET
, 0));
1086 gimple_omp_set_body (p
, body
);
1087 gimple_omp_target_set_clauses (p
, clauses
);
1088 gimple_omp_target_set_kind (p
, kind
);
1094 /* Build a GIMPLE_OMP_TEAMS statement.
1096 BODY is the sequence of statements that will be executed.
1097 CLAUSES are any of the OMP teams construct's clauses. */
1100 gimple_build_omp_teams (gimple_seq body
, tree clauses
)
1102 gomp_teams
*p
= as_a
<gomp_teams
*> (gimple_alloc (GIMPLE_OMP_TEAMS
, 0));
1104 gimple_omp_set_body (p
, body
);
1105 gimple_omp_teams_set_clauses (p
, clauses
);
1111 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1114 gimple_build_omp_atomic_load (tree lhs
, tree rhs
)
1117 = as_a
<gomp_atomic_load
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD
, 0));
1118 gimple_omp_atomic_load_set_lhs (p
, lhs
);
1119 gimple_omp_atomic_load_set_rhs (p
, rhs
);
1123 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1125 VAL is the value we are storing. */
1128 gimple_build_omp_atomic_store (tree val
)
1130 gomp_atomic_store
*p
1131 = as_a
<gomp_atomic_store
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE
, 0));
1132 gimple_omp_atomic_store_set_val (p
, val
);
1136 /* Build a GIMPLE_TRANSACTION statement. */
1139 gimple_build_transaction (gimple_seq body
, tree label
)
1142 = as_a
<gtransaction
*> (gimple_alloc (GIMPLE_TRANSACTION
, 0));
1143 gimple_transaction_set_body (p
, body
);
1144 gimple_transaction_set_label (p
, label
);
1148 #if defined ENABLE_GIMPLE_CHECKING
1149 /* Complain of a gimple type mismatch and die. */
1152 gimple_check_failed (const gimple
*gs
, const char *file
, int line
,
1153 const char *function
, enum gimple_code code
,
1154 enum tree_code subcode
)
1156 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1157 gimple_code_name
[code
],
1158 get_tree_code_name (subcode
),
1159 gimple_code_name
[gimple_code (gs
)],
1161 ? get_tree_code_name ((enum tree_code
) gs
->subcode
)
1163 function
, trim_filename (file
), line
);
1165 #endif /* ENABLE_GIMPLE_CHECKING */
1168 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1169 *SEQ_P is NULL, a new sequence is allocated. */
1172 gimple_seq_add_stmt (gimple_seq
*seq_p
, gimple
*gs
)
1174 gimple_stmt_iterator si
;
1178 si
= gsi_last (*seq_p
);
1179 gsi_insert_after (&si
, gs
, GSI_NEW_STMT
);
1182 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1183 *SEQ_P is NULL, a new sequence is allocated. This function is
1184 similar to gimple_seq_add_stmt, but does not scan the operands.
1185 During gimplification, we need to manipulate statement sequences
1186 before the def/use vectors have been constructed. */
1189 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple
*gs
)
1191 gimple_stmt_iterator si
;
1196 si
= gsi_last (*seq_p
);
1197 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
1200 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1201 NULL, a new sequence is allocated. */
1204 gimple_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
1206 gimple_stmt_iterator si
;
1210 si
= gsi_last (*dst_p
);
1211 gsi_insert_seq_after (&si
, src
, GSI_NEW_STMT
);
1214 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1215 NULL, a new sequence is allocated. This function is
1216 similar to gimple_seq_add_seq, but does not scan the operands. */
1219 gimple_seq_add_seq_without_update (gimple_seq
*dst_p
, gimple_seq src
)
1221 gimple_stmt_iterator si
;
1225 si
= gsi_last (*dst_p
);
1226 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
1229 /* Determine whether to assign a location to the statement GS. */
1232 should_carry_location_p (gimple
*gs
)
1234 /* Don't emit a line note for a label. We particularly don't want to
1235 emit one for the break label, since it doesn't actually correspond
1236 to the beginning of the loop/switch. */
1237 if (gimple_code (gs
) == GIMPLE_LABEL
)
1243 /* Set the location for gimple statement GS to LOCATION. */
1246 annotate_one_with_location (gimple
*gs
, location_t location
)
1248 if (!gimple_has_location (gs
)
1249 && !gimple_do_not_emit_location_p (gs
)
1250 && should_carry_location_p (gs
))
1251 gimple_set_location (gs
, location
);
1254 /* Set LOCATION for all the statements after iterator GSI in sequence
1255 SEQ. If GSI is pointing to the end of the sequence, start with the
1256 first statement in SEQ. */
1259 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
1260 location_t location
)
1262 if (gsi_end_p (gsi
))
1263 gsi
= gsi_start (seq
);
1267 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
1268 annotate_one_with_location (gsi_stmt (gsi
), location
);
1271 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1274 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
1276 gimple_stmt_iterator i
;
1278 if (gimple_seq_empty_p (stmt_p
))
1281 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
1283 gimple
*gs
= gsi_stmt (i
);
1284 annotate_one_with_location (gs
, location
);
1288 /* Helper function of empty_body_p. Return true if STMT is an empty
1292 empty_stmt_p (gimple
*stmt
)
1294 if (gimple_code (stmt
) == GIMPLE_NOP
)
1296 if (gbind
*bind_stmt
= dyn_cast
<gbind
*> (stmt
))
1297 return empty_body_p (gimple_bind_body (bind_stmt
));
1302 /* Return true if BODY contains nothing but empty statements. */
1305 empty_body_p (gimple_seq body
)
1307 gimple_stmt_iterator i
;
1309 if (gimple_seq_empty_p (body
))
1311 for (i
= gsi_start (body
); !gsi_end_p (i
); gsi_next (&i
))
1312 if (!empty_stmt_p (gsi_stmt (i
))
1313 && !is_gimple_debug (gsi_stmt (i
)))
1320 /* Perform a deep copy of sequence SRC and return the result. */
1323 gimple_seq_copy (gimple_seq src
)
1325 gimple_stmt_iterator gsi
;
1326 gimple_seq new_seq
= NULL
;
1329 for (gsi
= gsi_start (src
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1331 stmt
= gimple_copy (gsi_stmt (gsi
));
1332 gimple_seq_add_stmt (&new_seq
, stmt
);
1340 /* Return true if calls C1 and C2 are known to go to the same function. */
1343 gimple_call_same_target_p (const gimple
*c1
, const gimple
*c2
)
1345 if (gimple_call_internal_p (c1
))
1346 return (gimple_call_internal_p (c2
)
1347 && gimple_call_internal_fn (c1
) == gimple_call_internal_fn (c2
)
1348 && !gimple_call_internal_unique_p (as_a
<const gcall
*> (c1
)));
1350 return (gimple_call_fn (c1
) == gimple_call_fn (c2
)
1351 || (gimple_call_fndecl (c1
)
1352 && gimple_call_fndecl (c1
) == gimple_call_fndecl (c2
)));
1355 /* Detect flags from a GIMPLE_CALL. This is just like
1356 call_expr_flags, but for gimple tuples. */
1359 gimple_call_flags (const gimple
*stmt
)
1362 tree decl
= gimple_call_fndecl (stmt
);
1365 flags
= flags_from_decl_or_type (decl
);
1366 else if (gimple_call_internal_p (stmt
))
1367 flags
= internal_fn_flags (gimple_call_internal_fn (stmt
));
1369 flags
= flags_from_decl_or_type (gimple_call_fntype (stmt
));
1371 if (stmt
->subcode
& GF_CALL_NOTHROW
)
1372 flags
|= ECF_NOTHROW
;
1377 /* Return the "fn spec" string for call STMT. */
1380 gimple_call_fnspec (const gcall
*stmt
)
1384 if (gimple_call_internal_p (stmt
))
1385 return internal_fn_fnspec (gimple_call_internal_fn (stmt
));
1387 type
= gimple_call_fntype (stmt
);
1391 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
1395 return TREE_VALUE (TREE_VALUE (attr
));
1398 /* Detects argument flags for argument number ARG on call STMT. */
1401 gimple_call_arg_flags (const gcall
*stmt
, unsigned arg
)
1403 const_tree attr
= gimple_call_fnspec (stmt
);
1405 if (!attr
|| 1 + arg
>= (unsigned) TREE_STRING_LENGTH (attr
))
1408 switch (TREE_STRING_POINTER (attr
)[1 + arg
])
1415 return EAF_DIRECT
| EAF_NOCLOBBER
| EAF_NOESCAPE
;
1418 return EAF_NOCLOBBER
| EAF_NOESCAPE
;
1421 return EAF_DIRECT
| EAF_NOESCAPE
;
1424 return EAF_NOESCAPE
;
1432 /* Detects return flags for the call STMT. */
1435 gimple_call_return_flags (const gcall
*stmt
)
1439 if (gimple_call_flags (stmt
) & ECF_MALLOC
)
1442 attr
= gimple_call_fnspec (stmt
);
1443 if (!attr
|| TREE_STRING_LENGTH (attr
) < 1)
1446 switch (TREE_STRING_POINTER (attr
)[0])
1452 return ERF_RETURNS_ARG
| (TREE_STRING_POINTER (attr
)[0] - '1');
1464 /* Return true if GS is a copy assignment. */
1467 gimple_assign_copy_p (gimple
*gs
)
1469 return (gimple_assign_single_p (gs
)
1470 && is_gimple_val (gimple_op (gs
, 1)));
1474 /* Return true if GS is a SSA_NAME copy assignment. */
1477 gimple_assign_ssa_name_copy_p (gimple
*gs
)
1479 return (gimple_assign_single_p (gs
)
1480 && TREE_CODE (gimple_assign_lhs (gs
)) == SSA_NAME
1481 && TREE_CODE (gimple_assign_rhs1 (gs
)) == SSA_NAME
);
1485 /* Return true if GS is an assignment with a unary RHS, but the
1486 operator has no effect on the assigned value. The logic is adapted
1487 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1488 instances in which STRIP_NOPS was previously applied to the RHS of
1491 NOTE: In the use cases that led to the creation of this function
1492 and of gimple_assign_single_p, it is typical to test for either
1493 condition and to proceed in the same manner. In each case, the
1494 assigned value is represented by the single RHS operand of the
1495 assignment. I suspect there may be cases where gimple_assign_copy_p,
1496 gimple_assign_single_p, or equivalent logic is used where a similar
1497 treatment of unary NOPs is appropriate. */
1500 gimple_assign_unary_nop_p (gimple
*gs
)
1502 return (is_gimple_assign (gs
)
1503 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs
))
1504 || gimple_assign_rhs_code (gs
) == NON_LVALUE_EXPR
)
1505 && gimple_assign_rhs1 (gs
) != error_mark_node
1506 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs
)))
1507 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs
)))));
1510 /* Set BB to be the basic block holding G. */
1513 gimple_set_bb (gimple
*stmt
, basic_block bb
)
1517 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1520 /* If the statement is a label, add the label to block-to-labels map
1521 so that we can speed up edge creation for GIMPLE_GOTOs. */
1527 t
= gimple_label_label (as_a
<glabel
*> (stmt
));
1528 uid
= LABEL_DECL_UID (t
);
1532 vec_safe_length (label_to_block_map_for_fn (cfun
));
1533 LABEL_DECL_UID (t
) = uid
= cfun
->cfg
->last_label_uid
++;
1534 if (old_len
<= (unsigned) uid
)
1536 unsigned new_len
= 3 * uid
/ 2 + 1;
1538 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun
),
1543 (*label_to_block_map_for_fn (cfun
))[uid
] = bb
;
1548 /* Modify the RHS of the assignment pointed-to by GSI using the
1549 operands in the expression tree EXPR.
1551 NOTE: The statement pointed-to by GSI may be reallocated if it
1552 did not have enough operand slots.
1554 This function is useful to convert an existing tree expression into
1555 the flat representation used for the RHS of a GIMPLE assignment.
1556 It will reallocate memory as needed to expand or shrink the number
1557 of operand slots needed to represent EXPR.
1559 NOTE: If you find yourself building a tree and then calling this
1560 function, you are most certainly doing it the slow way. It is much
1561 better to build a new assignment or to use the function
1562 gimple_assign_set_rhs_with_ops, which does not require an
1563 expression tree to be built. */
1566 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*gsi
, tree expr
)
1568 enum tree_code subcode
;
1571 extract_ops_from_tree_1 (expr
, &subcode
, &op1
, &op2
, &op3
);
1572 gimple_assign_set_rhs_with_ops (gsi
, subcode
, op1
, op2
, op3
);
1576 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1577 operands OP1, OP2 and OP3.
1579 NOTE: The statement pointed-to by GSI may be reallocated if it
1580 did not have enough operand slots. */
1583 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*gsi
, enum tree_code code
,
1584 tree op1
, tree op2
, tree op3
)
1586 unsigned new_rhs_ops
= get_gimple_rhs_num_ops (code
);
1587 gimple
*stmt
= gsi_stmt (*gsi
);
1589 /* If the new CODE needs more operands, allocate a new statement. */
1590 if (gimple_num_ops (stmt
) < new_rhs_ops
+ 1)
1592 tree lhs
= gimple_assign_lhs (stmt
);
1593 gimple
*new_stmt
= gimple_alloc (gimple_code (stmt
), new_rhs_ops
+ 1);
1594 memcpy (new_stmt
, stmt
, gimple_size (gimple_code (stmt
)));
1595 gimple_init_singleton (new_stmt
);
1596 gsi_replace (gsi
, new_stmt
, true);
1599 /* The LHS needs to be reset as this also changes the SSA name
1601 gimple_assign_set_lhs (stmt
, lhs
);
1604 gimple_set_num_ops (stmt
, new_rhs_ops
+ 1);
1605 gimple_set_subcode (stmt
, code
);
1606 gimple_assign_set_rhs1 (stmt
, op1
);
1607 if (new_rhs_ops
> 1)
1608 gimple_assign_set_rhs2 (stmt
, op2
);
1609 if (new_rhs_ops
> 2)
1610 gimple_assign_set_rhs3 (stmt
, op3
);
1614 /* Return the LHS of a statement that performs an assignment,
1615 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1616 for a call to a function that returns no value, or for a
1617 statement other than an assignment or a call. */
1620 gimple_get_lhs (const gimple
*stmt
)
1622 enum gimple_code code
= gimple_code (stmt
);
1624 if (code
== GIMPLE_ASSIGN
)
1625 return gimple_assign_lhs (stmt
);
1626 else if (code
== GIMPLE_CALL
)
1627 return gimple_call_lhs (stmt
);
1633 /* Set the LHS of a statement that performs an assignment,
1634 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1637 gimple_set_lhs (gimple
*stmt
, tree lhs
)
1639 enum gimple_code code
= gimple_code (stmt
);
1641 if (code
== GIMPLE_ASSIGN
)
1642 gimple_assign_set_lhs (stmt
, lhs
);
1643 else if (code
== GIMPLE_CALL
)
1644 gimple_call_set_lhs (stmt
, lhs
);
1650 /* Return a deep copy of statement STMT. All the operands from STMT
1651 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1652 and VUSE operand arrays are set to empty in the new copy. The new
1653 copy isn't part of any sequence. */
1656 gimple_copy (gimple
*stmt
)
1658 enum gimple_code code
= gimple_code (stmt
);
1659 unsigned num_ops
= gimple_num_ops (stmt
);
1660 gimple
*copy
= gimple_alloc (code
, num_ops
);
1663 /* Shallow copy all the fields from STMT. */
1664 memcpy (copy
, stmt
, gimple_size (code
));
1665 gimple_init_singleton (copy
);
1667 /* If STMT has sub-statements, deep-copy them as well. */
1668 if (gimple_has_substatements (stmt
))
1673 switch (gimple_code (stmt
))
1677 gbind
*bind_stmt
= as_a
<gbind
*> (stmt
);
1678 gbind
*bind_copy
= as_a
<gbind
*> (copy
);
1679 new_seq
= gimple_seq_copy (gimple_bind_body (bind_stmt
));
1680 gimple_bind_set_body (bind_copy
, new_seq
);
1681 gimple_bind_set_vars (bind_copy
,
1682 unshare_expr (gimple_bind_vars (bind_stmt
)));
1683 gimple_bind_set_block (bind_copy
, gimple_bind_block (bind_stmt
));
1689 gcatch
*catch_stmt
= as_a
<gcatch
*> (stmt
);
1690 gcatch
*catch_copy
= as_a
<gcatch
*> (copy
);
1691 new_seq
= gimple_seq_copy (gimple_catch_handler (catch_stmt
));
1692 gimple_catch_set_handler (catch_copy
, new_seq
);
1693 t
= unshare_expr (gimple_catch_types (catch_stmt
));
1694 gimple_catch_set_types (catch_copy
, t
);
1698 case GIMPLE_EH_FILTER
:
1700 geh_filter
*eh_filter_stmt
= as_a
<geh_filter
*> (stmt
);
1701 geh_filter
*eh_filter_copy
= as_a
<geh_filter
*> (copy
);
1703 = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt
));
1704 gimple_eh_filter_set_failure (eh_filter_copy
, new_seq
);
1705 t
= unshare_expr (gimple_eh_filter_types (eh_filter_stmt
));
1706 gimple_eh_filter_set_types (eh_filter_copy
, t
);
1710 case GIMPLE_EH_ELSE
:
1712 geh_else
*eh_else_stmt
= as_a
<geh_else
*> (stmt
);
1713 geh_else
*eh_else_copy
= as_a
<geh_else
*> (copy
);
1714 new_seq
= gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt
));
1715 gimple_eh_else_set_n_body (eh_else_copy
, new_seq
);
1716 new_seq
= gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt
));
1717 gimple_eh_else_set_e_body (eh_else_copy
, new_seq
);
1723 gtry
*try_stmt
= as_a
<gtry
*> (stmt
);
1724 gtry
*try_copy
= as_a
<gtry
*> (copy
);
1725 new_seq
= gimple_seq_copy (gimple_try_eval (try_stmt
));
1726 gimple_try_set_eval (try_copy
, new_seq
);
1727 new_seq
= gimple_seq_copy (gimple_try_cleanup (try_stmt
));
1728 gimple_try_set_cleanup (try_copy
, new_seq
);
1732 case GIMPLE_OMP_FOR
:
1733 new_seq
= gimple_seq_copy (gimple_omp_for_pre_body (stmt
));
1734 gimple_omp_for_set_pre_body (copy
, new_seq
);
1735 t
= unshare_expr (gimple_omp_for_clauses (stmt
));
1736 gimple_omp_for_set_clauses (copy
, t
);
1738 gomp_for
*omp_for_copy
= as_a
<gomp_for
*> (copy
);
1739 omp_for_copy
->iter
= ggc_vec_alloc
<gimple_omp_for_iter
>
1740 ( gimple_omp_for_collapse (stmt
));
1742 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1744 gimple_omp_for_set_cond (copy
, i
,
1745 gimple_omp_for_cond (stmt
, i
));
1746 gimple_omp_for_set_index (copy
, i
,
1747 gimple_omp_for_index (stmt
, i
));
1748 t
= unshare_expr (gimple_omp_for_initial (stmt
, i
));
1749 gimple_omp_for_set_initial (copy
, i
, t
);
1750 t
= unshare_expr (gimple_omp_for_final (stmt
, i
));
1751 gimple_omp_for_set_final (copy
, i
, t
);
1752 t
= unshare_expr (gimple_omp_for_incr (stmt
, i
));
1753 gimple_omp_for_set_incr (copy
, i
, t
);
1757 case GIMPLE_OMP_PARALLEL
:
1759 gomp_parallel
*omp_par_stmt
= as_a
<gomp_parallel
*> (stmt
);
1760 gomp_parallel
*omp_par_copy
= as_a
<gomp_parallel
*> (copy
);
1761 t
= unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt
));
1762 gimple_omp_parallel_set_clauses (omp_par_copy
, t
);
1763 t
= unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt
));
1764 gimple_omp_parallel_set_child_fn (omp_par_copy
, t
);
1765 t
= unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt
));
1766 gimple_omp_parallel_set_data_arg (omp_par_copy
, t
);
1770 case GIMPLE_OMP_TASK
:
1771 t
= unshare_expr (gimple_omp_task_clauses (stmt
));
1772 gimple_omp_task_set_clauses (copy
, t
);
1773 t
= unshare_expr (gimple_omp_task_child_fn (stmt
));
1774 gimple_omp_task_set_child_fn (copy
, t
);
1775 t
= unshare_expr (gimple_omp_task_data_arg (stmt
));
1776 gimple_omp_task_set_data_arg (copy
, t
);
1777 t
= unshare_expr (gimple_omp_task_copy_fn (stmt
));
1778 gimple_omp_task_set_copy_fn (copy
, t
);
1779 t
= unshare_expr (gimple_omp_task_arg_size (stmt
));
1780 gimple_omp_task_set_arg_size (copy
, t
);
1781 t
= unshare_expr (gimple_omp_task_arg_align (stmt
));
1782 gimple_omp_task_set_arg_align (copy
, t
);
1785 case GIMPLE_OMP_CRITICAL
:
1786 t
= unshare_expr (gimple_omp_critical_name
1787 (as_a
<gomp_critical
*> (stmt
)));
1788 gimple_omp_critical_set_name (as_a
<gomp_critical
*> (copy
), t
);
1789 t
= unshare_expr (gimple_omp_critical_clauses
1790 (as_a
<gomp_critical
*> (stmt
)));
1791 gimple_omp_critical_set_clauses (as_a
<gomp_critical
*> (copy
), t
);
1794 case GIMPLE_OMP_ORDERED
:
1795 t
= unshare_expr (gimple_omp_ordered_clauses
1796 (as_a
<gomp_ordered
*> (stmt
)));
1797 gimple_omp_ordered_set_clauses (as_a
<gomp_ordered
*> (copy
), t
);
1800 case GIMPLE_OMP_SECTIONS
:
1801 t
= unshare_expr (gimple_omp_sections_clauses (stmt
));
1802 gimple_omp_sections_set_clauses (copy
, t
);
1803 t
= unshare_expr (gimple_omp_sections_control (stmt
));
1804 gimple_omp_sections_set_control (copy
, t
);
1807 case GIMPLE_OMP_SINGLE
:
1808 case GIMPLE_OMP_TARGET
:
1809 case GIMPLE_OMP_TEAMS
:
1810 case GIMPLE_OMP_SECTION
:
1811 case GIMPLE_OMP_MASTER
:
1812 case GIMPLE_OMP_TASKGROUP
:
1814 new_seq
= gimple_seq_copy (gimple_omp_body (stmt
));
1815 gimple_omp_set_body (copy
, new_seq
);
1818 case GIMPLE_TRANSACTION
:
1819 new_seq
= gimple_seq_copy (gimple_transaction_body (
1820 as_a
<gtransaction
*> (stmt
)));
1821 gimple_transaction_set_body (as_a
<gtransaction
*> (copy
),
1825 case GIMPLE_WITH_CLEANUP_EXPR
:
1826 new_seq
= gimple_seq_copy (gimple_wce_cleanup (stmt
));
1827 gimple_wce_set_cleanup (copy
, new_seq
);
1835 /* Make copy of operands. */
1836 for (i
= 0; i
< num_ops
; i
++)
1837 gimple_set_op (copy
, i
, unshare_expr (gimple_op (stmt
, i
)));
1839 if (gimple_has_mem_ops (stmt
))
1841 gimple_set_vdef (copy
, gimple_vdef (stmt
));
1842 gimple_set_vuse (copy
, gimple_vuse (stmt
));
1845 /* Clear out SSA operand vectors on COPY. */
1846 if (gimple_has_ops (stmt
))
1848 gimple_set_use_ops (copy
, NULL
);
1850 /* SSA operands need to be updated. */
1851 gimple_set_modified (copy
, true);
1858 /* Return true if statement S has side-effects. We consider a
1859 statement to have side effects if:
1861 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
1862 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
1865 gimple_has_side_effects (const gimple
*s
)
1867 if (is_gimple_debug (s
))
1870 /* We don't have to scan the arguments to check for
1871 volatile arguments, though, at present, we still
1872 do a scan to check for TREE_SIDE_EFFECTS. */
1873 if (gimple_has_volatile_ops (s
))
1876 if (gimple_code (s
) == GIMPLE_ASM
1877 && gimple_asm_volatile_p (as_a
<const gasm
*> (s
)))
1880 if (is_gimple_call (s
))
1882 int flags
= gimple_call_flags (s
);
1884 /* An infinite loop is considered a side effect. */
1885 if (!(flags
& (ECF_CONST
| ECF_PURE
))
1886 || (flags
& ECF_LOOPING_CONST_OR_PURE
))
1895 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
1896 Return true if S can trap. When INCLUDE_MEM is true, check whether
1897 the memory operations could trap. When INCLUDE_STORES is true and
1898 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
1901 gimple_could_trap_p_1 (gimple
*s
, bool include_mem
, bool include_stores
)
1903 tree t
, div
= NULL_TREE
;
1908 unsigned i
, start
= (is_gimple_assign (s
) && !include_stores
) ? 1 : 0;
1910 for (i
= start
; i
< gimple_num_ops (s
); i
++)
1911 if (tree_could_trap_p (gimple_op (s
, i
)))
1915 switch (gimple_code (s
))
1918 return gimple_asm_volatile_p (as_a
<gasm
*> (s
));
1921 t
= gimple_call_fndecl (s
);
1922 /* Assume that calls to weak functions may trap. */
1923 if (!t
|| !DECL_P (t
) || DECL_WEAK (t
))
1928 t
= gimple_expr_type (s
);
1929 op
= gimple_assign_rhs_code (s
);
1930 if (get_gimple_rhs_class (op
) == GIMPLE_BINARY_RHS
)
1931 div
= gimple_assign_rhs2 (s
);
1932 return (operation_could_trap_p (op
, FLOAT_TYPE_P (t
),
1933 (INTEGRAL_TYPE_P (t
)
1934 && TYPE_OVERFLOW_TRAPS (t
)),
1944 /* Return true if statement S can trap. */
1947 gimple_could_trap_p (gimple
*s
)
1949 return gimple_could_trap_p_1 (s
, true, true);
1952 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
1955 gimple_assign_rhs_could_trap_p (gimple
*s
)
1957 gcc_assert (is_gimple_assign (s
));
1958 return gimple_could_trap_p_1 (s
, true, false);
1962 /* Print debugging information for gimple stmts generated. */
1965 dump_gimple_statistics (void)
1967 int i
, total_tuples
= 0, total_bytes
= 0;
1969 if (! GATHER_STATISTICS
)
1971 fprintf (stderr
, "No gimple statistics\n");
1975 fprintf (stderr
, "\nGIMPLE statements\n");
1976 fprintf (stderr
, "Kind Stmts Bytes\n");
1977 fprintf (stderr
, "---------------------------------------\n");
1978 for (i
= 0; i
< (int) gimple_alloc_kind_all
; ++i
)
1980 fprintf (stderr
, "%-20s %7d %10d\n", gimple_alloc_kind_names
[i
],
1981 gimple_alloc_counts
[i
], gimple_alloc_sizes
[i
]);
1982 total_tuples
+= gimple_alloc_counts
[i
];
1983 total_bytes
+= gimple_alloc_sizes
[i
];
1985 fprintf (stderr
, "---------------------------------------\n");
1986 fprintf (stderr
, "%-20s %7d %10d\n", "Total", total_tuples
, total_bytes
);
1987 fprintf (stderr
, "---------------------------------------\n");
1991 /* Return the number of operands needed on the RHS of a GIMPLE
1992 assignment for an expression with tree code CODE. */
1995 get_gimple_rhs_num_ops (enum tree_code code
)
1997 enum gimple_rhs_class rhs_class
= get_gimple_rhs_class (code
);
1999 if (rhs_class
== GIMPLE_UNARY_RHS
|| rhs_class
== GIMPLE_SINGLE_RHS
)
2001 else if (rhs_class
== GIMPLE_BINARY_RHS
)
2003 else if (rhs_class
== GIMPLE_TERNARY_RHS
)
2009 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2011 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2012 : ((TYPE) == tcc_binary \
2013 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2014 : ((TYPE) == tcc_constant \
2015 || (TYPE) == tcc_declaration \
2016 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2017 : ((SYM) == TRUTH_AND_EXPR \
2018 || (SYM) == TRUTH_OR_EXPR \
2019 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2020 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2021 : ((SYM) == COND_EXPR \
2022 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2023 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2024 || (SYM) == DOT_PROD_EXPR \
2025 || (SYM) == SAD_EXPR \
2026 || (SYM) == REALIGN_LOAD_EXPR \
2027 || (SYM) == VEC_COND_EXPR \
2028 || (SYM) == VEC_PERM_EXPR \
2029 || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS \
2030 : ((SYM) == CONSTRUCTOR \
2031 || (SYM) == OBJ_TYPE_REF \
2032 || (SYM) == ASSERT_EXPR \
2033 || (SYM) == ADDR_EXPR \
2034 || (SYM) == WITH_SIZE_EXPR \
2035 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2036 : GIMPLE_INVALID_RHS),
2037 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2039 const unsigned char gimple_rhs_class_table
[] = {
2040 #include "all-tree.def"
2044 #undef END_OF_BASE_TREE_CODES
2046 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2047 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2048 we failed to create one. */
2051 canonicalize_cond_expr_cond (tree t
)
2053 /* Strip conversions around boolean operations. */
2054 if (CONVERT_EXPR_P (t
)
2055 && (truth_value_p (TREE_CODE (TREE_OPERAND (t
, 0)))
2056 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
2058 t
= TREE_OPERAND (t
, 0);
2060 /* For !x use x == 0. */
2061 if (TREE_CODE (t
) == TRUTH_NOT_EXPR
)
2063 tree top0
= TREE_OPERAND (t
, 0);
2064 t
= build2 (EQ_EXPR
, TREE_TYPE (t
),
2065 top0
, build_int_cst (TREE_TYPE (top0
), 0));
2067 /* For cmp ? 1 : 0 use cmp. */
2068 else if (TREE_CODE (t
) == COND_EXPR
2069 && COMPARISON_CLASS_P (TREE_OPERAND (t
, 0))
2070 && integer_onep (TREE_OPERAND (t
, 1))
2071 && integer_zerop (TREE_OPERAND (t
, 2)))
2073 tree top0
= TREE_OPERAND (t
, 0);
2074 t
= build2 (TREE_CODE (top0
), TREE_TYPE (t
),
2075 TREE_OPERAND (top0
, 0), TREE_OPERAND (top0
, 1));
2077 /* For x ^ y use x != y. */
2078 else if (TREE_CODE (t
) == BIT_XOR_EXPR
)
2079 t
= build2 (NE_EXPR
, TREE_TYPE (t
),
2080 TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1));
2082 if (is_gimple_condexpr (t
))
2088 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2089 the positions marked by the set ARGS_TO_SKIP. */
2092 gimple_call_copy_skip_args (gcall
*stmt
, bitmap args_to_skip
)
2095 int nargs
= gimple_call_num_args (stmt
);
2096 auto_vec
<tree
> vargs (nargs
);
2099 for (i
= 0; i
< nargs
; i
++)
2100 if (!bitmap_bit_p (args_to_skip
, i
))
2101 vargs
.quick_push (gimple_call_arg (stmt
, i
));
2103 if (gimple_call_internal_p (stmt
))
2104 new_stmt
= gimple_build_call_internal_vec (gimple_call_internal_fn (stmt
),
2107 new_stmt
= gimple_build_call_vec (gimple_call_fn (stmt
), vargs
);
2109 if (gimple_call_lhs (stmt
))
2110 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2112 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2113 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
2115 if (gimple_has_location (stmt
))
2116 gimple_set_location (new_stmt
, gimple_location (stmt
));
2117 gimple_call_copy_flags (new_stmt
, stmt
);
2118 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2120 gimple_set_modified (new_stmt
, true);
2127 /* Return true if the field decls F1 and F2 are at the same offset.
2129 This is intended to be used on GIMPLE types only. */
2132 gimple_compare_field_offset (tree f1
, tree f2
)
2134 if (DECL_OFFSET_ALIGN (f1
) == DECL_OFFSET_ALIGN (f2
))
2136 tree offset1
= DECL_FIELD_OFFSET (f1
);
2137 tree offset2
= DECL_FIELD_OFFSET (f2
);
2138 return ((offset1
== offset2
2139 /* Once gimplification is done, self-referential offsets are
2140 instantiated as operand #2 of the COMPONENT_REF built for
2141 each access and reset. Therefore, they are not relevant
2142 anymore and fields are interchangeable provided that they
2143 represent the same access. */
2144 || (TREE_CODE (offset1
) == PLACEHOLDER_EXPR
2145 && TREE_CODE (offset2
) == PLACEHOLDER_EXPR
2146 && (DECL_SIZE (f1
) == DECL_SIZE (f2
)
2147 || (TREE_CODE (DECL_SIZE (f1
)) == PLACEHOLDER_EXPR
2148 && TREE_CODE (DECL_SIZE (f2
)) == PLACEHOLDER_EXPR
)
2149 || operand_equal_p (DECL_SIZE (f1
), DECL_SIZE (f2
), 0))
2150 && DECL_ALIGN (f1
) == DECL_ALIGN (f2
))
2151 || operand_equal_p (offset1
, offset2
, 0))
2152 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1
),
2153 DECL_FIELD_BIT_OFFSET (f2
)));
2156 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2157 should be, so handle differing ones specially by decomposing
2158 the offset into a byte and bit offset manually. */
2159 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1
))
2160 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2
)))
2162 unsigned HOST_WIDE_INT byte_offset1
, byte_offset2
;
2163 unsigned HOST_WIDE_INT bit_offset1
, bit_offset2
;
2164 bit_offset1
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1
));
2165 byte_offset1
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1
))
2166 + bit_offset1
/ BITS_PER_UNIT
);
2167 bit_offset2
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2
));
2168 byte_offset2
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2
))
2169 + bit_offset2
/ BITS_PER_UNIT
);
2170 if (byte_offset1
!= byte_offset2
)
2172 return bit_offset1
% BITS_PER_UNIT
== bit_offset2
% BITS_PER_UNIT
;
2179 /* Return a type the same as TYPE except unsigned or
2180 signed according to UNSIGNEDP. */
2183 gimple_signed_or_unsigned_type (bool unsignedp
, tree type
)
2188 type1
= TYPE_MAIN_VARIANT (type
);
2189 if (type1
== signed_char_type_node
2190 || type1
== char_type_node
2191 || type1
== unsigned_char_type_node
)
2192 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2193 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2194 return unsignedp
? unsigned_type_node
: integer_type_node
;
2195 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2196 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2197 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2198 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2199 if (type1
== long_long_integer_type_node
2200 || type1
== long_long_unsigned_type_node
)
2202 ? long_long_unsigned_type_node
2203 : long_long_integer_type_node
;
2205 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2206 if (int_n_enabled_p
[i
]
2207 && (type1
== int_n_trees
[i
].unsigned_type
2208 || type1
== int_n_trees
[i
].signed_type
))
2210 ? int_n_trees
[i
].unsigned_type
2211 : int_n_trees
[i
].signed_type
;
2213 #if HOST_BITS_PER_WIDE_INT >= 64
2214 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2215 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2217 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2218 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2219 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2220 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2221 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2222 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2223 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2224 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2226 #define GIMPLE_FIXED_TYPES(NAME) \
2227 if (type1 == short_ ## NAME ## _type_node \
2228 || type1 == unsigned_short_ ## NAME ## _type_node) \
2229 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2230 : short_ ## NAME ## _type_node; \
2231 if (type1 == NAME ## _type_node \
2232 || type1 == unsigned_ ## NAME ## _type_node) \
2233 return unsignedp ? unsigned_ ## NAME ## _type_node \
2234 : NAME ## _type_node; \
2235 if (type1 == long_ ## NAME ## _type_node \
2236 || type1 == unsigned_long_ ## NAME ## _type_node) \
2237 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2238 : long_ ## NAME ## _type_node; \
2239 if (type1 == long_long_ ## NAME ## _type_node \
2240 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2241 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2242 : long_long_ ## NAME ## _type_node;
2244 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2245 if (type1 == NAME ## _type_node \
2246 || type1 == u ## NAME ## _type_node) \
2247 return unsignedp ? u ## NAME ## _type_node \
2248 : NAME ## _type_node;
2250 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2251 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2252 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2253 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2254 : sat_ ## short_ ## NAME ## _type_node; \
2255 if (type1 == sat_ ## NAME ## _type_node \
2256 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2257 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2258 : sat_ ## NAME ## _type_node; \
2259 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2260 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2261 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2262 : sat_ ## long_ ## NAME ## _type_node; \
2263 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2264 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2265 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2266 : sat_ ## long_long_ ## NAME ## _type_node;
2268 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2269 if (type1 == sat_ ## NAME ## _type_node \
2270 || type1 == sat_ ## u ## NAME ## _type_node) \
2271 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2272 : sat_ ## NAME ## _type_node;
2274 GIMPLE_FIXED_TYPES (fract
);
2275 GIMPLE_FIXED_TYPES_SAT (fract
);
2276 GIMPLE_FIXED_TYPES (accum
);
2277 GIMPLE_FIXED_TYPES_SAT (accum
);
2279 GIMPLE_FIXED_MODE_TYPES (qq
);
2280 GIMPLE_FIXED_MODE_TYPES (hq
);
2281 GIMPLE_FIXED_MODE_TYPES (sq
);
2282 GIMPLE_FIXED_MODE_TYPES (dq
);
2283 GIMPLE_FIXED_MODE_TYPES (tq
);
2284 GIMPLE_FIXED_MODE_TYPES_SAT (qq
);
2285 GIMPLE_FIXED_MODE_TYPES_SAT (hq
);
2286 GIMPLE_FIXED_MODE_TYPES_SAT (sq
);
2287 GIMPLE_FIXED_MODE_TYPES_SAT (dq
);
2288 GIMPLE_FIXED_MODE_TYPES_SAT (tq
);
2289 GIMPLE_FIXED_MODE_TYPES (ha
);
2290 GIMPLE_FIXED_MODE_TYPES (sa
);
2291 GIMPLE_FIXED_MODE_TYPES (da
);
2292 GIMPLE_FIXED_MODE_TYPES (ta
);
2293 GIMPLE_FIXED_MODE_TYPES_SAT (ha
);
2294 GIMPLE_FIXED_MODE_TYPES_SAT (sa
);
2295 GIMPLE_FIXED_MODE_TYPES_SAT (da
);
2296 GIMPLE_FIXED_MODE_TYPES_SAT (ta
);
2298 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2299 the precision; they have precision set to match their range, but
2300 may use a wider mode to match an ABI. If we change modes, we may
2301 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2302 the precision as well, so as to yield correct results for
2303 bit-field types. C++ does not have these separate bit-field
2304 types, and producing a signed or unsigned variant of an
2305 ENUMERAL_TYPE may cause other problems as well. */
2306 if (!INTEGRAL_TYPE_P (type
)
2307 || TYPE_UNSIGNED (type
) == unsignedp
)
2310 #define TYPE_OK(node) \
2311 (TYPE_MODE (type) == TYPE_MODE (node) \
2312 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2313 if (TYPE_OK (signed_char_type_node
))
2314 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2315 if (TYPE_OK (integer_type_node
))
2316 return unsignedp
? unsigned_type_node
: integer_type_node
;
2317 if (TYPE_OK (short_integer_type_node
))
2318 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2319 if (TYPE_OK (long_integer_type_node
))
2320 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2321 if (TYPE_OK (long_long_integer_type_node
))
2323 ? long_long_unsigned_type_node
2324 : long_long_integer_type_node
);
2326 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2327 if (int_n_enabled_p
[i
]
2328 && TYPE_MODE (type
) == int_n_data
[i
].m
2329 && TYPE_PRECISION (type
) == int_n_data
[i
].bitsize
)
2331 ? int_n_trees
[i
].unsigned_type
2332 : int_n_trees
[i
].signed_type
;
2334 #if HOST_BITS_PER_WIDE_INT >= 64
2335 if (TYPE_OK (intTI_type_node
))
2336 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2338 if (TYPE_OK (intDI_type_node
))
2339 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2340 if (TYPE_OK (intSI_type_node
))
2341 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2342 if (TYPE_OK (intHI_type_node
))
2343 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2344 if (TYPE_OK (intQI_type_node
))
2345 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2347 #undef GIMPLE_FIXED_TYPES
2348 #undef GIMPLE_FIXED_MODE_TYPES
2349 #undef GIMPLE_FIXED_TYPES_SAT
2350 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2353 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2357 /* Return an unsigned type the same as TYPE in other respects. */
2360 gimple_unsigned_type (tree type
)
2362 return gimple_signed_or_unsigned_type (true, type
);
2366 /* Return a signed type the same as TYPE in other respects. */
2369 gimple_signed_type (tree type
)
2371 return gimple_signed_or_unsigned_type (false, type
);
2375 /* Return the typed-based alias set for T, which may be an expression
2376 or a type. Return -1 if we don't do anything special. */
2379 gimple_get_alias_set (tree t
)
2383 /* Permit type-punning when accessing a union, provided the access
2384 is directly through the union. For example, this code does not
2385 permit taking the address of a union member and then storing
2386 through it. Even the type-punning allowed here is a GCC
2387 extension, albeit a common and useful one; the C standard says
2388 that such accesses have implementation-defined behavior. */
2390 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2391 u
= TREE_OPERAND (u
, 0))
2392 if (TREE_CODE (u
) == COMPONENT_REF
2393 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2396 /* That's all the expressions we handle specially. */
2400 /* For convenience, follow the C standard when dealing with
2401 character types. Any object may be accessed via an lvalue that
2402 has character type. */
2403 if (t
== char_type_node
2404 || t
== signed_char_type_node
2405 || t
== unsigned_char_type_node
)
2408 /* Allow aliasing between signed and unsigned variants of the same
2409 type. We treat the signed variant as canonical. */
2410 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2412 tree t1
= gimple_signed_type (t
);
2414 /* t1 == t can happen for boolean nodes which are always unsigned. */
2416 return get_alias_set (t1
);
2423 /* Helper for gimple_ior_addresses_taken_1. */
2426 gimple_ior_addresses_taken_1 (gimple
*, tree addr
, tree
, void *data
)
2428 bitmap addresses_taken
= (bitmap
)data
;
2429 addr
= get_base_address (addr
);
2433 bitmap_set_bit (addresses_taken
, DECL_UID (addr
));
2439 /* Set the bit for the uid of all decls that have their address taken
2440 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2441 were any in this stmt. */
2444 gimple_ior_addresses_taken (bitmap addresses_taken
, gimple
*stmt
)
2446 return walk_stmt_load_store_addr_ops (stmt
, addresses_taken
, NULL
, NULL
,
2447 gimple_ior_addresses_taken_1
);
2451 /* Return true if TYPE1 and TYPE2 are compatible enough for builtin
2455 validate_type (tree type1
, tree type2
)
2457 if (INTEGRAL_TYPE_P (type1
)
2458 && INTEGRAL_TYPE_P (type2
))
2460 else if (POINTER_TYPE_P (type1
)
2461 && POINTER_TYPE_P (type2
))
2463 else if (TREE_CODE (type1
)
2464 != TREE_CODE (type2
))
2469 /* Return true when STMTs arguments and return value match those of FNDECL,
2470 a decl of a builtin function. */
2473 gimple_builtin_call_types_compatible_p (const gimple
*stmt
, tree fndecl
)
2475 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
);
2477 tree ret
= gimple_call_lhs (stmt
);
2479 && !validate_type (TREE_TYPE (ret
), TREE_TYPE (TREE_TYPE (fndecl
))))
2482 tree targs
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2483 unsigned nargs
= gimple_call_num_args (stmt
);
2484 for (unsigned i
= 0; i
< nargs
; ++i
)
2486 /* Variadic args follow. */
2489 tree arg
= gimple_call_arg (stmt
, i
);
2490 if (!validate_type (TREE_TYPE (arg
), TREE_VALUE (targs
)))
2492 targs
= TREE_CHAIN (targs
);
2494 if (targs
&& !VOID_TYPE_P (TREE_VALUE (targs
)))
2499 /* Return true when STMT is builtins call. */
2502 gimple_call_builtin_p (const gimple
*stmt
)
2505 if (is_gimple_call (stmt
)
2506 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2507 && DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
)
2508 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2512 /* Return true when STMT is builtins call to CLASS. */
2515 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_class klass
)
2518 if (is_gimple_call (stmt
)
2519 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2520 && DECL_BUILT_IN_CLASS (fndecl
) == klass
)
2521 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2525 /* Return true when STMT is builtins call to CODE of CLASS. */
2528 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_function code
)
2531 if (is_gimple_call (stmt
)
2532 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2533 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
2534 && DECL_FUNCTION_CODE (fndecl
) == code
)
2535 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2539 /* Return true if STMT clobbers memory. STMT is required to be a
2543 gimple_asm_clobbers_memory_p (const gasm
*stmt
)
2547 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
2549 tree op
= gimple_asm_clobber_op (stmt
, i
);
2550 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op
)), "memory") == 0)
2557 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2560 dump_decl_set (FILE *file
, bitmap set
)
2567 fprintf (file
, "{ ");
2569 EXECUTE_IF_SET_IN_BITMAP (set
, 0, i
, bi
)
2571 fprintf (file
, "D.%u", i
);
2572 fprintf (file
, " ");
2575 fprintf (file
, "}");
2578 fprintf (file
, "NIL");
2581 /* Return true when CALL is a call stmt that definitely doesn't
2582 free any memory or makes it unavailable otherwise. */
2584 nonfreeing_call_p (gimple
*call
)
2586 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2587 && gimple_call_flags (call
) & ECF_LEAF
)
2588 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call
)))
2590 /* Just in case these become ECF_LEAF in the future. */
2592 case BUILT_IN_TM_FREE
:
2593 case BUILT_IN_REALLOC
:
2594 case BUILT_IN_STACK_RESTORE
:
2599 else if (gimple_call_internal_p (call
))
2600 switch (gimple_call_internal_fn (call
))
2602 case IFN_ABNORMAL_DISPATCHER
:
2605 if (gimple_call_flags (call
) & ECF_LEAF
)
2610 tree fndecl
= gimple_call_fndecl (call
);
2613 struct cgraph_node
*n
= cgraph_node::get (fndecl
);
2616 enum availability availability
;
2617 n
= n
->function_symbol (&availability
);
2618 if (!n
|| availability
<= AVAIL_INTERPOSABLE
)
2620 return n
->nonfreeing_fn
;
2623 /* Callback for walk_stmt_load_store_ops.
2625 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2628 This routine only makes a superficial check for a dereference. Thus
2629 it must only be used if it is safe to return a false negative. */
2631 check_loadstore (gimple
*, tree op
, tree
, void *data
)
2633 if ((TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
2634 && operand_equal_p (TREE_OPERAND (op
, 0), (tree
)data
, 0))
2640 /* Return true if OP can be inferred to be non-NULL after STMT executes,
2641 either by using a pointer dereference or attributes. */
2643 infer_nonnull_range (gimple
*stmt
, tree op
)
2645 return infer_nonnull_range_by_dereference (stmt
, op
)
2646 || infer_nonnull_range_by_attribute (stmt
, op
);
2649 /* Return true if OP can be inferred to be non-NULL after STMT
2650 executes by using a pointer dereference. */
2652 infer_nonnull_range_by_dereference (gimple
*stmt
, tree op
)
2654 /* We can only assume that a pointer dereference will yield
2655 non-NULL if -fdelete-null-pointer-checks is enabled. */
2656 if (!flag_delete_null_pointer_checks
2657 || !POINTER_TYPE_P (TREE_TYPE (op
))
2658 || gimple_code (stmt
) == GIMPLE_ASM
)
2661 if (walk_stmt_load_store_ops (stmt
, (void *)op
,
2662 check_loadstore
, check_loadstore
))
2668 /* Return true if OP can be inferred to be a non-NULL after STMT
2669 executes by using attributes. */
2671 infer_nonnull_range_by_attribute (gimple
*stmt
, tree op
)
2673 /* We can only assume that a pointer dereference will yield
2674 non-NULL if -fdelete-null-pointer-checks is enabled. */
2675 if (!flag_delete_null_pointer_checks
2676 || !POINTER_TYPE_P (TREE_TYPE (op
))
2677 || gimple_code (stmt
) == GIMPLE_ASM
)
2680 if (is_gimple_call (stmt
) && !gimple_call_internal_p (stmt
))
2682 tree fntype
= gimple_call_fntype (stmt
);
2683 tree attrs
= TYPE_ATTRIBUTES (fntype
);
2684 for (; attrs
; attrs
= TREE_CHAIN (attrs
))
2686 attrs
= lookup_attribute ("nonnull", attrs
);
2688 /* If "nonnull" wasn't specified, we know nothing about
2690 if (attrs
== NULL_TREE
)
2693 /* If "nonnull" applies to all the arguments, then ARG
2694 is non-null if it's in the argument list. */
2695 if (TREE_VALUE (attrs
) == NULL_TREE
)
2697 for (unsigned int i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2699 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt
, i
)))
2700 && operand_equal_p (op
, gimple_call_arg (stmt
, i
), 0))
2706 /* Now see if op appears in the nonnull list. */
2707 for (tree t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
2709 unsigned int idx
= TREE_INT_CST_LOW (TREE_VALUE (t
)) - 1;
2710 if (idx
< gimple_call_num_args (stmt
))
2712 tree arg
= gimple_call_arg (stmt
, idx
);
2713 if (operand_equal_p (op
, arg
, 0))
2720 /* If this function is marked as returning non-null, then we can
2721 infer OP is non-null if it is used in the return statement. */
2722 if (greturn
*return_stmt
= dyn_cast
<greturn
*> (stmt
))
2723 if (gimple_return_retval (return_stmt
)
2724 && operand_equal_p (gimple_return_retval (return_stmt
), op
, 0)
2725 && lookup_attribute ("returns_nonnull",
2726 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
))))
2732 /* Compare two case labels. Because the front end should already have
2733 made sure that case ranges do not overlap, it is enough to only compare
2734 the CASE_LOW values of each case label. */
2737 compare_case_labels (const void *p1
, const void *p2
)
2739 const_tree
const case1
= *(const_tree
const*)p1
;
2740 const_tree
const case2
= *(const_tree
const*)p2
;
2742 /* The 'default' case label always goes first. */
2743 if (!CASE_LOW (case1
))
2745 else if (!CASE_LOW (case2
))
2748 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
2751 /* Sort the case labels in LABEL_VEC in place in ascending order. */
2754 sort_case_labels (vec
<tree
> label_vec
)
2756 label_vec
.qsort (compare_case_labels
);
2759 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2761 LABELS is a vector that contains all case labels to look at.
2763 INDEX_TYPE is the type of the switch index expression. Case labels
2764 in LABELS are discarded if their values are not in the value range
2765 covered by INDEX_TYPE. The remaining case label values are folded
2768 If a default case exists in LABELS, it is removed from LABELS and
2769 returned in DEFAULT_CASEP. If no default case exists, but the
2770 case labels already cover the whole range of INDEX_TYPE, a default
2771 case is returned pointing to one of the existing case labels.
2772 Otherwise DEFAULT_CASEP is set to NULL_TREE.
2774 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2775 apply and no action is taken regardless of whether a default case is
2779 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
2781 tree
*default_casep
)
2783 tree min_value
, max_value
;
2784 tree default_case
= NULL_TREE
;
2788 min_value
= TYPE_MIN_VALUE (index_type
);
2789 max_value
= TYPE_MAX_VALUE (index_type
);
2790 while (i
< labels
.length ())
2792 tree elt
= labels
[i
];
2793 tree low
= CASE_LOW (elt
);
2794 tree high
= CASE_HIGH (elt
);
2795 bool remove_element
= FALSE
;
2799 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
2800 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
2802 /* This is a non-default case label, i.e. it has a value.
2804 See if the case label is reachable within the range of
2805 the index type. Remove out-of-range case values. Turn
2806 case ranges into a canonical form (high > low strictly)
2807 and convert the case label values to the index type.
2809 NB: The type of gimple_switch_index() may be the promoted
2810 type, but the case labels retain the original type. */
2814 /* This is a case range. Discard empty ranges.
2815 If the bounds or the range are equal, turn this
2816 into a simple (one-value) case. */
2817 int cmp
= tree_int_cst_compare (high
, low
);
2819 remove_element
= TRUE
;
2826 /* If the simple case value is unreachable, ignore it. */
2827 if ((TREE_CODE (min_value
) == INTEGER_CST
2828 && tree_int_cst_compare (low
, min_value
) < 0)
2829 || (TREE_CODE (max_value
) == INTEGER_CST
2830 && tree_int_cst_compare (low
, max_value
) > 0))
2831 remove_element
= TRUE
;
2833 low
= fold_convert (index_type
, low
);
2837 /* If the entire case range is unreachable, ignore it. */
2838 if ((TREE_CODE (min_value
) == INTEGER_CST
2839 && tree_int_cst_compare (high
, min_value
) < 0)
2840 || (TREE_CODE (max_value
) == INTEGER_CST
2841 && tree_int_cst_compare (low
, max_value
) > 0))
2842 remove_element
= TRUE
;
2845 /* If the lower bound is less than the index type's
2846 minimum value, truncate the range bounds. */
2847 if (TREE_CODE (min_value
) == INTEGER_CST
2848 && tree_int_cst_compare (low
, min_value
) < 0)
2850 low
= fold_convert (index_type
, low
);
2852 /* If the upper bound is greater than the index type's
2853 maximum value, truncate the range bounds. */
2854 if (TREE_CODE (max_value
) == INTEGER_CST
2855 && tree_int_cst_compare (high
, max_value
) > 0)
2857 high
= fold_convert (index_type
, high
);
2859 /* We may have folded a case range to a one-value case. */
2860 if (tree_int_cst_equal (low
, high
))
2865 CASE_LOW (elt
) = low
;
2866 CASE_HIGH (elt
) = high
;
2870 gcc_assert (!default_case
);
2872 /* The default case must be passed separately to the
2873 gimple_build_switch routine. But if DEFAULT_CASEP
2874 is NULL, we do not remove the default case (it would
2875 be completely lost). */
2877 remove_element
= TRUE
;
2881 labels
.ordered_remove (i
);
2887 if (!labels
.is_empty ())
2888 sort_case_labels (labels
);
2890 if (default_casep
&& !default_case
)
2892 /* If the switch has no default label, add one, so that we jump
2893 around the switch body. If the labels already cover the whole
2894 range of the switch index_type, add the default label pointing
2895 to one of the existing labels. */
2897 && TYPE_MIN_VALUE (index_type
)
2898 && TYPE_MAX_VALUE (index_type
)
2899 && tree_int_cst_equal (CASE_LOW (labels
[0]),
2900 TYPE_MIN_VALUE (index_type
)))
2902 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
2904 high
= CASE_LOW (labels
[len
- 1]);
2905 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
2907 for (i
= 1; i
< len
; i
++)
2909 high
= CASE_LOW (labels
[i
]);
2910 low
= CASE_HIGH (labels
[i
- 1]);
2912 low
= CASE_LOW (labels
[i
- 1]);
2913 if (wi::add (low
, 1) != high
)
2918 tree label
= CASE_LABEL (labels
[0]);
2919 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
2927 *default_casep
= default_case
;
2930 /* Set the location of all statements in SEQ to LOC. */
2933 gimple_seq_set_location (gimple_seq seq
, location_t loc
)
2935 for (gimple_stmt_iterator i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
2936 gimple_set_location (gsi_stmt (i
), loc
);
2939 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
2942 gimple_seq_discard (gimple_seq seq
)
2944 gimple_stmt_iterator gsi
;
2946 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); )
2948 gimple
*stmt
= gsi_stmt (gsi
);
2949 gsi_remove (&gsi
, true);
2950 release_defs (stmt
);
2955 /* See if STMT now calls function that takes no parameters and if so, drop
2956 call arguments. This is used when devirtualization machinery redirects
2957 to __builtiln_unreacahble or __cxa_pure_virutal. */
2960 maybe_remove_unused_call_args (struct function
*fn
, gimple
*stmt
)
2962 tree decl
= gimple_call_fndecl (stmt
);
2963 if (TYPE_ARG_TYPES (TREE_TYPE (decl
))
2964 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
))) == void_type_node
2965 && gimple_call_num_args (stmt
))
2967 gimple_set_num_ops (stmt
, 3);
2968 update_stmt_fn (fn
, stmt
);