1 /* Gimple IR support functions.
3 Copyright (C) 2007-2016 Free Software Foundation, Inc.
4 Contributed by Aldy Hernandez <aldyh@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
30 #include "diagnostic.h"
32 #include "fold-const.h"
34 #include "stor-layout.h"
35 #include "internal-fn.h"
37 #include "gimple-iterator.h"
38 #include "gimple-walk.h"
43 /* All the tuples have their operand vector (if present) at the very bottom
44 of the structure. Therefore, the offset required to find the
45 operands vector the size of the structure minus the size of the 1
46 element tree array at the end (see gimple_ops). */
47 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
48 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
49 EXPORTED_CONST
size_t gimple_ops_offset_
[] = {
50 #include "gsstruct.def"
54 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
55 static const size_t gsstruct_code_size
[] = {
56 #include "gsstruct.def"
60 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
61 const char *const gimple_code_name
[] = {
66 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
67 EXPORTED_CONST
enum gimple_statement_structure_enum gss_for_code_
[] = {
74 int gimple_alloc_counts
[(int) gimple_alloc_kind_all
];
75 int gimple_alloc_sizes
[(int) gimple_alloc_kind_all
];
77 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
78 static const char * const gimple_alloc_kind_names
[] = {
85 /* Static gimple tuple members. */
86 const enum gimple_code
gassign::code_
;
87 const enum gimple_code
gcall::code_
;
88 const enum gimple_code
gcond::code_
;
91 /* Gimple tuple constructors.
92 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
93 be passed a NULL to start with an empty sequence. */
95 /* Set the code for statement G to CODE. */
98 gimple_set_code (gimple
*g
, enum gimple_code code
)
103 /* Return the number of bytes needed to hold a GIMPLE statement with
107 gimple_size (enum gimple_code code
)
109 return gsstruct_code_size
[gss_for_code (code
)];
112 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
116 gimple_alloc_stat (enum gimple_code code
, unsigned num_ops MEM_STAT_DECL
)
121 size
= gimple_size (code
);
123 size
+= sizeof (tree
) * (num_ops
- 1);
125 if (GATHER_STATISTICS
)
127 enum gimple_alloc_kind kind
= gimple_alloc_kind (code
);
128 gimple_alloc_counts
[(int) kind
]++;
129 gimple_alloc_sizes
[(int) kind
] += size
;
132 stmt
= ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT
);
133 gimple_set_code (stmt
, code
);
134 gimple_set_num_ops (stmt
, num_ops
);
136 /* Do not call gimple_set_modified here as it has other side
137 effects and this tuple is still not completely built. */
139 gimple_init_singleton (stmt
);
144 /* Set SUBCODE to be the code of the expression computed by statement G. */
147 gimple_set_subcode (gimple
*g
, unsigned subcode
)
149 /* We only have 16 bits for the RHS code. Assert that we are not
151 gcc_assert (subcode
< (1 << 16));
152 g
->subcode
= subcode
;
157 /* Build a tuple with operands. CODE is the statement to build (which
158 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
159 for the new tuple. NUM_OPS is the number of operands to allocate. */
161 #define gimple_build_with_ops(c, s, n) \
162 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
165 gimple_build_with_ops_stat (enum gimple_code code
, unsigned subcode
,
166 unsigned num_ops MEM_STAT_DECL
)
168 gimple
*s
= gimple_alloc_stat (code
, num_ops PASS_MEM_STAT
);
169 gimple_set_subcode (s
, subcode
);
175 /* Build a GIMPLE_RETURN statement returning RETVAL. */
178 gimple_build_return (tree retval
)
181 = as_a
<greturn
*> (gimple_build_with_ops (GIMPLE_RETURN
, ERROR_MARK
,
184 gimple_return_set_retval (s
, retval
);
188 /* Reset alias information on call S. */
191 gimple_call_reset_alias_info (gcall
*s
)
193 if (gimple_call_flags (s
) & ECF_CONST
)
194 memset (gimple_call_use_set (s
), 0, sizeof (struct pt_solution
));
196 pt_solution_reset (gimple_call_use_set (s
));
197 if (gimple_call_flags (s
) & (ECF_CONST
|ECF_PURE
|ECF_NOVOPS
))
198 memset (gimple_call_clobber_set (s
), 0, sizeof (struct pt_solution
));
200 pt_solution_reset (gimple_call_clobber_set (s
));
203 /* Helper for gimple_build_call, gimple_build_call_valist,
204 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
205 components of a GIMPLE_CALL statement to function FN with NARGS
208 static inline gcall
*
209 gimple_build_call_1 (tree fn
, unsigned nargs
)
212 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
214 if (TREE_CODE (fn
) == FUNCTION_DECL
)
215 fn
= build_fold_addr_expr (fn
);
216 gimple_set_op (s
, 1, fn
);
217 gimple_call_set_fntype (s
, TREE_TYPE (TREE_TYPE (fn
)));
218 gimple_call_reset_alias_info (s
);
223 /* Build a GIMPLE_CALL statement to function FN with the arguments
224 specified in vector ARGS. */
227 gimple_build_call_vec (tree fn
, vec
<tree
> args
)
230 unsigned nargs
= args
.length ();
231 gcall
*call
= gimple_build_call_1 (fn
, nargs
);
233 for (i
= 0; i
< nargs
; i
++)
234 gimple_call_set_arg (call
, i
, args
[i
]);
240 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
241 arguments. The ... are the arguments. */
244 gimple_build_call (tree fn
, unsigned nargs
, ...)
250 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
252 call
= gimple_build_call_1 (fn
, nargs
);
254 va_start (ap
, nargs
);
255 for (i
= 0; i
< nargs
; i
++)
256 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
263 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
264 arguments. AP contains the arguments. */
267 gimple_build_call_valist (tree fn
, unsigned nargs
, va_list ap
)
272 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
274 call
= gimple_build_call_1 (fn
, nargs
);
276 for (i
= 0; i
< nargs
; i
++)
277 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
283 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
284 Build the basic components of a GIMPLE_CALL statement to internal
285 function FN with NARGS arguments. */
287 static inline gcall
*
288 gimple_build_call_internal_1 (enum internal_fn fn
, unsigned nargs
)
291 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
293 s
->subcode
|= GF_CALL_INTERNAL
;
294 gimple_call_set_internal_fn (s
, fn
);
295 gimple_call_reset_alias_info (s
);
300 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
301 the number of arguments. The ... are the arguments. */
304 gimple_build_call_internal (enum internal_fn fn
, unsigned nargs
, ...)
310 call
= gimple_build_call_internal_1 (fn
, nargs
);
311 va_start (ap
, nargs
);
312 for (i
= 0; i
< nargs
; i
++)
313 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
320 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
321 specified in vector ARGS. */
324 gimple_build_call_internal_vec (enum internal_fn fn
, vec
<tree
> args
)
329 nargs
= args
.length ();
330 call
= gimple_build_call_internal_1 (fn
, nargs
);
331 for (i
= 0; i
< nargs
; i
++)
332 gimple_call_set_arg (call
, i
, args
[i
]);
338 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
339 assumed to be in GIMPLE form already. Minimal checking is done of
343 gimple_build_call_from_tree (tree t
)
347 tree fndecl
= get_callee_fndecl (t
);
349 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
351 nargs
= call_expr_nargs (t
);
352 call
= gimple_build_call_1 (fndecl
? fndecl
: CALL_EXPR_FN (t
), nargs
);
354 for (i
= 0; i
< nargs
; i
++)
355 gimple_call_set_arg (call
, i
, CALL_EXPR_ARG (t
, i
));
357 gimple_set_block (call
, TREE_BLOCK (t
));
359 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
360 gimple_call_set_chain (call
, CALL_EXPR_STATIC_CHAIN (t
));
361 gimple_call_set_tail (call
, CALL_EXPR_TAILCALL (t
));
362 gimple_call_set_return_slot_opt (call
, CALL_EXPR_RETURN_SLOT_OPT (t
));
364 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
365 && (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA
366 || DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
367 gimple_call_set_alloca_for_var (call
, CALL_ALLOCA_FOR_VAR_P (t
));
369 gimple_call_set_from_thunk (call
, CALL_FROM_THUNK_P (t
));
370 gimple_call_set_va_arg_pack (call
, CALL_EXPR_VA_ARG_PACK (t
));
371 gimple_call_set_nothrow (call
, TREE_NOTHROW (t
));
372 gimple_set_no_warning (call
, TREE_NO_WARNING (t
));
373 gimple_call_set_with_bounds (call
, CALL_WITH_BOUNDS_P (t
));
379 /* Build a GIMPLE_ASSIGN statement.
381 LHS of the assignment.
382 RHS of the assignment which can be unary or binary. */
385 gimple_build_assign (tree lhs
, tree rhs MEM_STAT_DECL
)
387 enum tree_code subcode
;
390 extract_ops_from_tree (rhs
, &subcode
, &op1
, &op2
, &op3
);
391 return gimple_build_assign (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
395 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
398 static inline gassign
*
399 gimple_build_assign_1 (tree lhs
, enum tree_code subcode
, tree op1
,
400 tree op2
, tree op3 MEM_STAT_DECL
)
405 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
407 num_ops
= get_gimple_rhs_num_ops (subcode
) + 1;
409 p
= as_a
<gassign
*> (
410 gimple_build_with_ops_stat (GIMPLE_ASSIGN
, (unsigned)subcode
, num_ops
412 gimple_assign_set_lhs (p
, lhs
);
413 gimple_assign_set_rhs1 (p
, op1
);
416 gcc_assert (num_ops
> 2);
417 gimple_assign_set_rhs2 (p
, op2
);
422 gcc_assert (num_ops
> 3);
423 gimple_assign_set_rhs3 (p
, op3
);
429 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
433 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
434 tree op2
, tree op3 MEM_STAT_DECL
)
436 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
439 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
443 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
444 tree op2 MEM_STAT_DECL
)
446 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, NULL_TREE
450 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
453 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1 MEM_STAT_DECL
)
455 return gimple_build_assign_1 (lhs
, subcode
, op1
, NULL_TREE
, NULL_TREE
460 /* Build a GIMPLE_COND statement.
462 PRED is the condition used to compare LHS and the RHS.
463 T_LABEL is the label to jump to if the condition is true.
464 F_LABEL is the label to jump to otherwise. */
467 gimple_build_cond (enum tree_code pred_code
, tree lhs
, tree rhs
,
468 tree t_label
, tree f_label
)
472 gcc_assert (TREE_CODE_CLASS (pred_code
) == tcc_comparison
);
473 p
= as_a
<gcond
*> (gimple_build_with_ops (GIMPLE_COND
, pred_code
, 4));
474 gimple_cond_set_lhs (p
, lhs
);
475 gimple_cond_set_rhs (p
, rhs
);
476 gimple_cond_set_true_label (p
, t_label
);
477 gimple_cond_set_false_label (p
, f_label
);
481 /* Build a GIMPLE_COND statement from the conditional expression tree
482 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
485 gimple_build_cond_from_tree (tree cond
, tree t_label
, tree f_label
)
490 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
491 return gimple_build_cond (code
, lhs
, rhs
, t_label
, f_label
);
494 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
495 boolean expression tree COND. */
498 gimple_cond_set_condition_from_tree (gcond
*stmt
, tree cond
)
503 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
504 gimple_cond_set_condition (stmt
, code
, lhs
, rhs
);
507 /* Build a GIMPLE_LABEL statement for LABEL. */
510 gimple_build_label (tree label
)
513 = as_a
<glabel
*> (gimple_build_with_ops (GIMPLE_LABEL
, ERROR_MARK
, 1));
514 gimple_label_set_label (p
, label
);
518 /* Build a GIMPLE_GOTO statement to label DEST. */
521 gimple_build_goto (tree dest
)
524 = as_a
<ggoto
*> (gimple_build_with_ops (GIMPLE_GOTO
, ERROR_MARK
, 1));
525 gimple_goto_set_dest (p
, dest
);
530 /* Build a GIMPLE_NOP statement. */
533 gimple_build_nop (void)
535 return gimple_alloc (GIMPLE_NOP
, 0);
539 /* Build a GIMPLE_BIND statement.
540 VARS are the variables in BODY.
541 BLOCK is the containing block. */
544 gimple_build_bind (tree vars
, gimple_seq body
, tree block
)
546 gbind
*p
= as_a
<gbind
*> (gimple_alloc (GIMPLE_BIND
, 0));
547 gimple_bind_set_vars (p
, vars
);
549 gimple_bind_set_body (p
, body
);
551 gimple_bind_set_block (p
, block
);
555 /* Helper function to set the simple fields of a asm stmt.
557 STRING is a pointer to a string that is the asm blocks assembly code.
558 NINPUT is the number of register inputs.
559 NOUTPUT is the number of register outputs.
560 NCLOBBERS is the number of clobbered registers.
564 gimple_build_asm_1 (const char *string
, unsigned ninputs
, unsigned noutputs
,
565 unsigned nclobbers
, unsigned nlabels
)
568 int size
= strlen (string
);
570 /* ASMs with labels cannot have outputs. This should have been
571 enforced by the front end. */
572 gcc_assert (nlabels
== 0 || noutputs
== 0);
575 gimple_build_with_ops (GIMPLE_ASM
, ERROR_MARK
,
576 ninputs
+ noutputs
+ nclobbers
+ nlabels
));
582 p
->string
= ggc_alloc_string (string
, size
);
584 if (GATHER_STATISTICS
)
585 gimple_alloc_sizes
[(int) gimple_alloc_kind (GIMPLE_ASM
)] += size
;
590 /* Build a GIMPLE_ASM statement.
592 STRING is the assembly code.
593 NINPUT is the number of register inputs.
594 NOUTPUT is the number of register outputs.
595 NCLOBBERS is the number of clobbered registers.
596 INPUTS is a vector of the input register parameters.
597 OUTPUTS is a vector of the output register parameters.
598 CLOBBERS is a vector of the clobbered register parameters.
599 LABELS is a vector of destination labels. */
602 gimple_build_asm_vec (const char *string
, vec
<tree
, va_gc
> *inputs
,
603 vec
<tree
, va_gc
> *outputs
, vec
<tree
, va_gc
> *clobbers
,
604 vec
<tree
, va_gc
> *labels
)
609 p
= gimple_build_asm_1 (string
,
610 vec_safe_length (inputs
),
611 vec_safe_length (outputs
),
612 vec_safe_length (clobbers
),
613 vec_safe_length (labels
));
615 for (i
= 0; i
< vec_safe_length (inputs
); i
++)
616 gimple_asm_set_input_op (p
, i
, (*inputs
)[i
]);
618 for (i
= 0; i
< vec_safe_length (outputs
); i
++)
619 gimple_asm_set_output_op (p
, i
, (*outputs
)[i
]);
621 for (i
= 0; i
< vec_safe_length (clobbers
); i
++)
622 gimple_asm_set_clobber_op (p
, i
, (*clobbers
)[i
]);
624 for (i
= 0; i
< vec_safe_length (labels
); i
++)
625 gimple_asm_set_label_op (p
, i
, (*labels
)[i
]);
630 /* Build a GIMPLE_CATCH statement.
632 TYPES are the catch types.
633 HANDLER is the exception handler. */
636 gimple_build_catch (tree types
, gimple_seq handler
)
638 gcatch
*p
= as_a
<gcatch
*> (gimple_alloc (GIMPLE_CATCH
, 0));
639 gimple_catch_set_types (p
, types
);
641 gimple_catch_set_handler (p
, handler
);
646 /* Build a GIMPLE_EH_FILTER statement.
648 TYPES are the filter's types.
649 FAILURE is the filter's failure action. */
652 gimple_build_eh_filter (tree types
, gimple_seq failure
)
654 geh_filter
*p
= as_a
<geh_filter
*> (gimple_alloc (GIMPLE_EH_FILTER
, 0));
655 gimple_eh_filter_set_types (p
, types
);
657 gimple_eh_filter_set_failure (p
, failure
);
662 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
665 gimple_build_eh_must_not_throw (tree decl
)
667 geh_mnt
*p
= as_a
<geh_mnt
*> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW
, 0));
669 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
670 gcc_assert (flags_from_decl_or_type (decl
) & ECF_NORETURN
);
671 gimple_eh_must_not_throw_set_fndecl (p
, decl
);
676 /* Build a GIMPLE_EH_ELSE statement. */
679 gimple_build_eh_else (gimple_seq n_body
, gimple_seq e_body
)
681 geh_else
*p
= as_a
<geh_else
*> (gimple_alloc (GIMPLE_EH_ELSE
, 0));
682 gimple_eh_else_set_n_body (p
, n_body
);
683 gimple_eh_else_set_e_body (p
, e_body
);
687 /* Build a GIMPLE_TRY statement.
689 EVAL is the expression to evaluate.
690 CLEANUP is the cleanup expression.
691 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
692 whether this is a try/catch or a try/finally respectively. */
695 gimple_build_try (gimple_seq eval
, gimple_seq cleanup
,
696 enum gimple_try_flags kind
)
700 gcc_assert (kind
== GIMPLE_TRY_CATCH
|| kind
== GIMPLE_TRY_FINALLY
);
701 p
= as_a
<gtry
*> (gimple_alloc (GIMPLE_TRY
, 0));
702 gimple_set_subcode (p
, kind
);
704 gimple_try_set_eval (p
, eval
);
706 gimple_try_set_cleanup (p
, cleanup
);
711 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
713 CLEANUP is the cleanup expression. */
716 gimple_build_wce (gimple_seq cleanup
)
718 gimple
*p
= gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR
, 0);
720 gimple_wce_set_cleanup (p
, cleanup
);
726 /* Build a GIMPLE_RESX statement. */
729 gimple_build_resx (int region
)
732 = as_a
<gresx
*> (gimple_build_with_ops (GIMPLE_RESX
, ERROR_MARK
, 0));
738 /* The helper for constructing a gimple switch statement.
739 INDEX is the switch's index.
740 NLABELS is the number of labels in the switch excluding the default.
741 DEFAULT_LABEL is the default label for the switch statement. */
744 gimple_build_switch_nlabels (unsigned nlabels
, tree index
, tree default_label
)
746 /* nlabels + 1 default label + 1 index. */
747 gcc_checking_assert (default_label
);
748 gswitch
*p
= as_a
<gswitch
*> (gimple_build_with_ops (GIMPLE_SWITCH
,
751 gimple_switch_set_index (p
, index
);
752 gimple_switch_set_default_label (p
, default_label
);
756 /* Build a GIMPLE_SWITCH statement.
758 INDEX is the switch's index.
759 DEFAULT_LABEL is the default label
760 ARGS is a vector of labels excluding the default. */
763 gimple_build_switch (tree index
, tree default_label
, vec
<tree
> args
)
765 unsigned i
, nlabels
= args
.length ();
767 gswitch
*p
= gimple_build_switch_nlabels (nlabels
, index
, default_label
);
769 /* Copy the labels from the vector to the switch statement. */
770 for (i
= 0; i
< nlabels
; i
++)
771 gimple_switch_set_label (p
, i
+ 1, args
[i
]);
776 /* Build a GIMPLE_EH_DISPATCH statement. */
779 gimple_build_eh_dispatch (int region
)
782 = as_a
<geh_dispatch
*> (
783 gimple_build_with_ops (GIMPLE_EH_DISPATCH
, ERROR_MARK
, 0));
788 /* Build a new GIMPLE_DEBUG_BIND statement.
790 VAR is bound to VALUE; block and location are taken from STMT. */
793 gimple_build_debug_bind_stat (tree var
, tree value
, gimple
*stmt MEM_STAT_DECL
)
796 = as_a
<gdebug
*> (gimple_build_with_ops_stat (GIMPLE_DEBUG
,
797 (unsigned)GIMPLE_DEBUG_BIND
, 2
799 gimple_debug_bind_set_var (p
, var
);
800 gimple_debug_bind_set_value (p
, value
);
802 gimple_set_location (p
, gimple_location (stmt
));
808 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
810 VAR is bound to VALUE; block and location are taken from STMT. */
813 gimple_build_debug_source_bind_stat (tree var
, tree value
,
814 gimple
*stmt MEM_STAT_DECL
)
818 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
819 (unsigned)GIMPLE_DEBUG_SOURCE_BIND
, 2
822 gimple_debug_source_bind_set_var (p
, var
);
823 gimple_debug_source_bind_set_value (p
, value
);
825 gimple_set_location (p
, gimple_location (stmt
));
831 /* Build a GIMPLE_OMP_CRITICAL statement.
833 BODY is the sequence of statements for which only one thread can execute.
834 NAME is optional identifier for this critical block.
835 CLAUSES are clauses for this critical block. */
838 gimple_build_omp_critical (gimple_seq body
, tree name
, tree clauses
)
841 = as_a
<gomp_critical
*> (gimple_alloc (GIMPLE_OMP_CRITICAL
, 0));
842 gimple_omp_critical_set_name (p
, name
);
843 gimple_omp_critical_set_clauses (p
, clauses
);
845 gimple_omp_set_body (p
, body
);
850 /* Build a GIMPLE_OMP_FOR statement.
852 BODY is sequence of statements inside the for loop.
853 KIND is the `for' variant.
854 CLAUSES, are any of the construct's clauses.
855 COLLAPSE is the collapse count.
856 PRE_BODY is the sequence of statements that are loop invariant. */
859 gimple_build_omp_for (gimple_seq body
, int kind
, tree clauses
, size_t collapse
,
862 gomp_for
*p
= as_a
<gomp_for
*> (gimple_alloc (GIMPLE_OMP_FOR
, 0));
864 gimple_omp_set_body (p
, body
);
865 gimple_omp_for_set_clauses (p
, clauses
);
866 gimple_omp_for_set_kind (p
, kind
);
867 p
->collapse
= collapse
;
868 p
->iter
= ggc_cleared_vec_alloc
<gimple_omp_for_iter
> (collapse
);
871 gimple_omp_for_set_pre_body (p
, pre_body
);
877 /* Build a GIMPLE_OMP_PARALLEL statement.
879 BODY is sequence of statements which are executed in parallel.
880 CLAUSES, are the OMP parallel construct's clauses.
881 CHILD_FN is the function created for the parallel threads to execute.
882 DATA_ARG are the shared data argument(s). */
885 gimple_build_omp_parallel (gimple_seq body
, tree clauses
, tree child_fn
,
889 = as_a
<gomp_parallel
*> (gimple_alloc (GIMPLE_OMP_PARALLEL
, 0));
891 gimple_omp_set_body (p
, body
);
892 gimple_omp_parallel_set_clauses (p
, clauses
);
893 gimple_omp_parallel_set_child_fn (p
, child_fn
);
894 gimple_omp_parallel_set_data_arg (p
, data_arg
);
900 /* Build a GIMPLE_OMP_TASK statement.
902 BODY is sequence of statements which are executed by the explicit task.
903 CLAUSES, are the OMP parallel construct's clauses.
904 CHILD_FN is the function created for the parallel threads to execute.
905 DATA_ARG are the shared data argument(s).
906 COPY_FN is the optional function for firstprivate initialization.
907 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
910 gimple_build_omp_task (gimple_seq body
, tree clauses
, tree child_fn
,
911 tree data_arg
, tree copy_fn
, tree arg_size
,
914 gomp_task
*p
= as_a
<gomp_task
*> (gimple_alloc (GIMPLE_OMP_TASK
, 0));
916 gimple_omp_set_body (p
, body
);
917 gimple_omp_task_set_clauses (p
, clauses
);
918 gimple_omp_task_set_child_fn (p
, child_fn
);
919 gimple_omp_task_set_data_arg (p
, data_arg
);
920 gimple_omp_task_set_copy_fn (p
, copy_fn
);
921 gimple_omp_task_set_arg_size (p
, arg_size
);
922 gimple_omp_task_set_arg_align (p
, arg_align
);
928 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
930 BODY is the sequence of statements in the section. */
933 gimple_build_omp_section (gimple_seq body
)
935 gimple
*p
= gimple_alloc (GIMPLE_OMP_SECTION
, 0);
937 gimple_omp_set_body (p
, body
);
943 /* Build a GIMPLE_OMP_MASTER statement.
945 BODY is the sequence of statements to be executed by just the master. */
948 gimple_build_omp_master (gimple_seq body
)
950 gimple
*p
= gimple_alloc (GIMPLE_OMP_MASTER
, 0);
952 gimple_omp_set_body (p
, body
);
957 /* Build a GIMPLE_OMP_GRID_BODY statement.
959 BODY is the sequence of statements to be executed by the kernel. */
962 gimple_build_omp_grid_body (gimple_seq body
)
964 gimple
*p
= gimple_alloc (GIMPLE_OMP_GRID_BODY
, 0);
966 gimple_omp_set_body (p
, body
);
971 /* Build a GIMPLE_OMP_TASKGROUP statement.
973 BODY is the sequence of statements to be executed by the taskgroup
977 gimple_build_omp_taskgroup (gimple_seq body
)
979 gimple
*p
= gimple_alloc (GIMPLE_OMP_TASKGROUP
, 0);
981 gimple_omp_set_body (p
, body
);
987 /* Build a GIMPLE_OMP_CONTINUE statement.
989 CONTROL_DEF is the definition of the control variable.
990 CONTROL_USE is the use of the control variable. */
993 gimple_build_omp_continue (tree control_def
, tree control_use
)
996 = as_a
<gomp_continue
*> (gimple_alloc (GIMPLE_OMP_CONTINUE
, 0));
997 gimple_omp_continue_set_control_def (p
, control_def
);
998 gimple_omp_continue_set_control_use (p
, control_use
);
1002 /* Build a GIMPLE_OMP_ORDERED statement.
1004 BODY is the sequence of statements inside a loop that will executed in
1006 CLAUSES are clauses for this statement. */
1009 gimple_build_omp_ordered (gimple_seq body
, tree clauses
)
1012 = as_a
<gomp_ordered
*> (gimple_alloc (GIMPLE_OMP_ORDERED
, 0));
1013 gimple_omp_ordered_set_clauses (p
, clauses
);
1015 gimple_omp_set_body (p
, body
);
1021 /* Build a GIMPLE_OMP_RETURN statement.
1022 WAIT_P is true if this is a non-waiting return. */
1025 gimple_build_omp_return (bool wait_p
)
1027 gimple
*p
= gimple_alloc (GIMPLE_OMP_RETURN
, 0);
1029 gimple_omp_return_set_nowait (p
);
1035 /* Build a GIMPLE_OMP_SECTIONS statement.
1037 BODY is a sequence of section statements.
1038 CLAUSES are any of the OMP sections contsruct's clauses: private,
1039 firstprivate, lastprivate, reduction, and nowait. */
1042 gimple_build_omp_sections (gimple_seq body
, tree clauses
)
1045 = as_a
<gomp_sections
*> (gimple_alloc (GIMPLE_OMP_SECTIONS
, 0));
1047 gimple_omp_set_body (p
, body
);
1048 gimple_omp_sections_set_clauses (p
, clauses
);
1054 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1057 gimple_build_omp_sections_switch (void)
1059 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH
, 0);
1063 /* Build a GIMPLE_OMP_SINGLE statement.
1065 BODY is the sequence of statements that will be executed once.
1066 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1067 copyprivate, nowait. */
1070 gimple_build_omp_single (gimple_seq body
, tree clauses
)
1073 = as_a
<gomp_single
*> (gimple_alloc (GIMPLE_OMP_SINGLE
, 0));
1075 gimple_omp_set_body (p
, body
);
1076 gimple_omp_single_set_clauses (p
, clauses
);
1082 /* Build a GIMPLE_OMP_TARGET statement.
1084 BODY is the sequence of statements that will be executed.
1085 KIND is the kind of the region.
1086 CLAUSES are any of the construct's clauses. */
1089 gimple_build_omp_target (gimple_seq body
, int kind
, tree clauses
)
1092 = as_a
<gomp_target
*> (gimple_alloc (GIMPLE_OMP_TARGET
, 0));
1094 gimple_omp_set_body (p
, body
);
1095 gimple_omp_target_set_clauses (p
, clauses
);
1096 gimple_omp_target_set_kind (p
, kind
);
1102 /* Build a GIMPLE_OMP_TEAMS statement.
1104 BODY is the sequence of statements that will be executed.
1105 CLAUSES are any of the OMP teams construct's clauses. */
1108 gimple_build_omp_teams (gimple_seq body
, tree clauses
)
1110 gomp_teams
*p
= as_a
<gomp_teams
*> (gimple_alloc (GIMPLE_OMP_TEAMS
, 0));
1112 gimple_omp_set_body (p
, body
);
1113 gimple_omp_teams_set_clauses (p
, clauses
);
1119 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1122 gimple_build_omp_atomic_load (tree lhs
, tree rhs
)
1125 = as_a
<gomp_atomic_load
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD
, 0));
1126 gimple_omp_atomic_load_set_lhs (p
, lhs
);
1127 gimple_omp_atomic_load_set_rhs (p
, rhs
);
1131 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1133 VAL is the value we are storing. */
1136 gimple_build_omp_atomic_store (tree val
)
1138 gomp_atomic_store
*p
1139 = as_a
<gomp_atomic_store
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE
, 0));
1140 gimple_omp_atomic_store_set_val (p
, val
);
1144 /* Build a GIMPLE_TRANSACTION statement. */
1147 gimple_build_transaction (gimple_seq body
)
1150 = as_a
<gtransaction
*> (gimple_alloc (GIMPLE_TRANSACTION
, 0));
1151 gimple_transaction_set_body (p
, body
);
1152 gimple_transaction_set_label_norm (p
, 0);
1153 gimple_transaction_set_label_uninst (p
, 0);
1154 gimple_transaction_set_label_over (p
, 0);
1158 #if defined ENABLE_GIMPLE_CHECKING
1159 /* Complain of a gimple type mismatch and die. */
1162 gimple_check_failed (const gimple
*gs
, const char *file
, int line
,
1163 const char *function
, enum gimple_code code
,
1164 enum tree_code subcode
)
1166 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1167 gimple_code_name
[code
],
1168 get_tree_code_name (subcode
),
1169 gimple_code_name
[gimple_code (gs
)],
1171 ? get_tree_code_name ((enum tree_code
) gs
->subcode
)
1173 function
, trim_filename (file
), line
);
1175 #endif /* ENABLE_GIMPLE_CHECKING */
1178 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1179 *SEQ_P is NULL, a new sequence is allocated. */
1182 gimple_seq_add_stmt (gimple_seq
*seq_p
, gimple
*gs
)
1184 gimple_stmt_iterator si
;
1188 si
= gsi_last (*seq_p
);
1189 gsi_insert_after (&si
, gs
, GSI_NEW_STMT
);
1192 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1193 *SEQ_P is NULL, a new sequence is allocated. This function is
1194 similar to gimple_seq_add_stmt, but does not scan the operands.
1195 During gimplification, we need to manipulate statement sequences
1196 before the def/use vectors have been constructed. */
1199 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple
*gs
)
1201 gimple_stmt_iterator si
;
1206 si
= gsi_last (*seq_p
);
1207 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
1210 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1211 NULL, a new sequence is allocated. */
1214 gimple_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
1216 gimple_stmt_iterator si
;
1220 si
= gsi_last (*dst_p
);
1221 gsi_insert_seq_after (&si
, src
, GSI_NEW_STMT
);
1224 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1225 NULL, a new sequence is allocated. This function is
1226 similar to gimple_seq_add_seq, but does not scan the operands. */
1229 gimple_seq_add_seq_without_update (gimple_seq
*dst_p
, gimple_seq src
)
1231 gimple_stmt_iterator si
;
1235 si
= gsi_last (*dst_p
);
1236 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
1239 /* Determine whether to assign a location to the statement GS. */
1242 should_carry_location_p (gimple
*gs
)
1244 /* Don't emit a line note for a label. We particularly don't want to
1245 emit one for the break label, since it doesn't actually correspond
1246 to the beginning of the loop/switch. */
1247 if (gimple_code (gs
) == GIMPLE_LABEL
)
1253 /* Set the location for gimple statement GS to LOCATION. */
1256 annotate_one_with_location (gimple
*gs
, location_t location
)
1258 if (!gimple_has_location (gs
)
1259 && !gimple_do_not_emit_location_p (gs
)
1260 && should_carry_location_p (gs
))
1261 gimple_set_location (gs
, location
);
1264 /* Set LOCATION for all the statements after iterator GSI in sequence
1265 SEQ. If GSI is pointing to the end of the sequence, start with the
1266 first statement in SEQ. */
1269 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
1270 location_t location
)
1272 if (gsi_end_p (gsi
))
1273 gsi
= gsi_start (seq
);
1277 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
1278 annotate_one_with_location (gsi_stmt (gsi
), location
);
1281 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1284 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
1286 gimple_stmt_iterator i
;
1288 if (gimple_seq_empty_p (stmt_p
))
1291 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
1293 gimple
*gs
= gsi_stmt (i
);
1294 annotate_one_with_location (gs
, location
);
1298 /* Helper function of empty_body_p. Return true if STMT is an empty
1302 empty_stmt_p (gimple
*stmt
)
1304 if (gimple_code (stmt
) == GIMPLE_NOP
)
1306 if (gbind
*bind_stmt
= dyn_cast
<gbind
*> (stmt
))
1307 return empty_body_p (gimple_bind_body (bind_stmt
));
1312 /* Return true if BODY contains nothing but empty statements. */
1315 empty_body_p (gimple_seq body
)
1317 gimple_stmt_iterator i
;
1319 if (gimple_seq_empty_p (body
))
1321 for (i
= gsi_start (body
); !gsi_end_p (i
); gsi_next (&i
))
1322 if (!empty_stmt_p (gsi_stmt (i
))
1323 && !is_gimple_debug (gsi_stmt (i
)))
1330 /* Perform a deep copy of sequence SRC and return the result. */
1333 gimple_seq_copy (gimple_seq src
)
1335 gimple_stmt_iterator gsi
;
1336 gimple_seq new_seq
= NULL
;
1339 for (gsi
= gsi_start (src
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1341 stmt
= gimple_copy (gsi_stmt (gsi
));
1342 gimple_seq_add_stmt (&new_seq
, stmt
);
1350 /* Return true if calls C1 and C2 are known to go to the same function. */
1353 gimple_call_same_target_p (const gimple
*c1
, const gimple
*c2
)
1355 if (gimple_call_internal_p (c1
))
1356 return (gimple_call_internal_p (c2
)
1357 && gimple_call_internal_fn (c1
) == gimple_call_internal_fn (c2
)
1358 && (!gimple_call_internal_unique_p (as_a
<const gcall
*> (c1
))
1361 return (gimple_call_fn (c1
) == gimple_call_fn (c2
)
1362 || (gimple_call_fndecl (c1
)
1363 && gimple_call_fndecl (c1
) == gimple_call_fndecl (c2
)));
1366 /* Detect flags from a GIMPLE_CALL. This is just like
1367 call_expr_flags, but for gimple tuples. */
1370 gimple_call_flags (const gimple
*stmt
)
1373 tree decl
= gimple_call_fndecl (stmt
);
1376 flags
= flags_from_decl_or_type (decl
);
1377 else if (gimple_call_internal_p (stmt
))
1378 flags
= internal_fn_flags (gimple_call_internal_fn (stmt
));
1380 flags
= flags_from_decl_or_type (gimple_call_fntype (stmt
));
1382 if (stmt
->subcode
& GF_CALL_NOTHROW
)
1383 flags
|= ECF_NOTHROW
;
1388 /* Return the "fn spec" string for call STMT. */
1391 gimple_call_fnspec (const gcall
*stmt
)
1395 if (gimple_call_internal_p (stmt
))
1396 return internal_fn_fnspec (gimple_call_internal_fn (stmt
));
1398 type
= gimple_call_fntype (stmt
);
1402 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
1406 return TREE_VALUE (TREE_VALUE (attr
));
1409 /* Detects argument flags for argument number ARG on call STMT. */
1412 gimple_call_arg_flags (const gcall
*stmt
, unsigned arg
)
1414 const_tree attr
= gimple_call_fnspec (stmt
);
1416 if (!attr
|| 1 + arg
>= (unsigned) TREE_STRING_LENGTH (attr
))
1419 switch (TREE_STRING_POINTER (attr
)[1 + arg
])
1426 return EAF_DIRECT
| EAF_NOCLOBBER
| EAF_NOESCAPE
;
1429 return EAF_NOCLOBBER
| EAF_NOESCAPE
;
1432 return EAF_DIRECT
| EAF_NOESCAPE
;
1435 return EAF_NOESCAPE
;
1443 /* Detects return flags for the call STMT. */
1446 gimple_call_return_flags (const gcall
*stmt
)
1450 if (gimple_call_flags (stmt
) & ECF_MALLOC
)
1453 attr
= gimple_call_fnspec (stmt
);
1454 if (!attr
|| TREE_STRING_LENGTH (attr
) < 1)
1457 switch (TREE_STRING_POINTER (attr
)[0])
1463 return ERF_RETURNS_ARG
| (TREE_STRING_POINTER (attr
)[0] - '1');
1475 /* Return true if GS is a copy assignment. */
1478 gimple_assign_copy_p (gimple
*gs
)
1480 return (gimple_assign_single_p (gs
)
1481 && is_gimple_val (gimple_op (gs
, 1)));
1485 /* Return true if GS is a SSA_NAME copy assignment. */
1488 gimple_assign_ssa_name_copy_p (gimple
*gs
)
1490 return (gimple_assign_single_p (gs
)
1491 && TREE_CODE (gimple_assign_lhs (gs
)) == SSA_NAME
1492 && TREE_CODE (gimple_assign_rhs1 (gs
)) == SSA_NAME
);
1496 /* Return true if GS is an assignment with a unary RHS, but the
1497 operator has no effect on the assigned value. The logic is adapted
1498 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1499 instances in which STRIP_NOPS was previously applied to the RHS of
1502 NOTE: In the use cases that led to the creation of this function
1503 and of gimple_assign_single_p, it is typical to test for either
1504 condition and to proceed in the same manner. In each case, the
1505 assigned value is represented by the single RHS operand of the
1506 assignment. I suspect there may be cases where gimple_assign_copy_p,
1507 gimple_assign_single_p, or equivalent logic is used where a similar
1508 treatment of unary NOPs is appropriate. */
1511 gimple_assign_unary_nop_p (gimple
*gs
)
1513 return (is_gimple_assign (gs
)
1514 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs
))
1515 || gimple_assign_rhs_code (gs
) == NON_LVALUE_EXPR
)
1516 && gimple_assign_rhs1 (gs
) != error_mark_node
1517 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs
)))
1518 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs
)))));
1521 /* Set BB to be the basic block holding G. */
1524 gimple_set_bb (gimple
*stmt
, basic_block bb
)
1528 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1531 /* If the statement is a label, add the label to block-to-labels map
1532 so that we can speed up edge creation for GIMPLE_GOTOs. */
1538 t
= gimple_label_label (as_a
<glabel
*> (stmt
));
1539 uid
= LABEL_DECL_UID (t
);
1543 vec_safe_length (label_to_block_map_for_fn (cfun
));
1544 LABEL_DECL_UID (t
) = uid
= cfun
->cfg
->last_label_uid
++;
1545 if (old_len
<= (unsigned) uid
)
1547 unsigned new_len
= 3 * uid
/ 2 + 1;
1549 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun
),
1554 (*label_to_block_map_for_fn (cfun
))[uid
] = bb
;
1559 /* Modify the RHS of the assignment pointed-to by GSI using the
1560 operands in the expression tree EXPR.
1562 NOTE: The statement pointed-to by GSI may be reallocated if it
1563 did not have enough operand slots.
1565 This function is useful to convert an existing tree expression into
1566 the flat representation used for the RHS of a GIMPLE assignment.
1567 It will reallocate memory as needed to expand or shrink the number
1568 of operand slots needed to represent EXPR.
1570 NOTE: If you find yourself building a tree and then calling this
1571 function, you are most certainly doing it the slow way. It is much
1572 better to build a new assignment or to use the function
1573 gimple_assign_set_rhs_with_ops, which does not require an
1574 expression tree to be built. */
1577 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*gsi
, tree expr
)
1579 enum tree_code subcode
;
1582 extract_ops_from_tree (expr
, &subcode
, &op1
, &op2
, &op3
);
1583 gimple_assign_set_rhs_with_ops (gsi
, subcode
, op1
, op2
, op3
);
1587 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1588 operands OP1, OP2 and OP3.
1590 NOTE: The statement pointed-to by GSI may be reallocated if it
1591 did not have enough operand slots. */
1594 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*gsi
, enum tree_code code
,
1595 tree op1
, tree op2
, tree op3
)
1597 unsigned new_rhs_ops
= get_gimple_rhs_num_ops (code
);
1598 gimple
*stmt
= gsi_stmt (*gsi
);
1600 /* If the new CODE needs more operands, allocate a new statement. */
1601 if (gimple_num_ops (stmt
) < new_rhs_ops
+ 1)
1603 tree lhs
= gimple_assign_lhs (stmt
);
1604 gimple
*new_stmt
= gimple_alloc (gimple_code (stmt
), new_rhs_ops
+ 1);
1605 memcpy (new_stmt
, stmt
, gimple_size (gimple_code (stmt
)));
1606 gimple_init_singleton (new_stmt
);
1607 gsi_replace (gsi
, new_stmt
, true);
1610 /* The LHS needs to be reset as this also changes the SSA name
1612 gimple_assign_set_lhs (stmt
, lhs
);
1615 gimple_set_num_ops (stmt
, new_rhs_ops
+ 1);
1616 gimple_set_subcode (stmt
, code
);
1617 gimple_assign_set_rhs1 (stmt
, op1
);
1618 if (new_rhs_ops
> 1)
1619 gimple_assign_set_rhs2 (stmt
, op2
);
1620 if (new_rhs_ops
> 2)
1621 gimple_assign_set_rhs3 (stmt
, op3
);
1625 /* Return the LHS of a statement that performs an assignment,
1626 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1627 for a call to a function that returns no value, or for a
1628 statement other than an assignment or a call. */
1631 gimple_get_lhs (const gimple
*stmt
)
1633 enum gimple_code code
= gimple_code (stmt
);
1635 if (code
== GIMPLE_ASSIGN
)
1636 return gimple_assign_lhs (stmt
);
1637 else if (code
== GIMPLE_CALL
)
1638 return gimple_call_lhs (stmt
);
1644 /* Set the LHS of a statement that performs an assignment,
1645 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1648 gimple_set_lhs (gimple
*stmt
, tree lhs
)
1650 enum gimple_code code
= gimple_code (stmt
);
1652 if (code
== GIMPLE_ASSIGN
)
1653 gimple_assign_set_lhs (stmt
, lhs
);
1654 else if (code
== GIMPLE_CALL
)
1655 gimple_call_set_lhs (stmt
, lhs
);
1661 /* Return a deep copy of statement STMT. All the operands from STMT
1662 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1663 and VUSE operand arrays are set to empty in the new copy. The new
1664 copy isn't part of any sequence. */
1667 gimple_copy (gimple
*stmt
)
1669 enum gimple_code code
= gimple_code (stmt
);
1670 unsigned num_ops
= gimple_num_ops (stmt
);
1671 gimple
*copy
= gimple_alloc (code
, num_ops
);
1674 /* Shallow copy all the fields from STMT. */
1675 memcpy (copy
, stmt
, gimple_size (code
));
1676 gimple_init_singleton (copy
);
1678 /* If STMT has sub-statements, deep-copy them as well. */
1679 if (gimple_has_substatements (stmt
))
1684 switch (gimple_code (stmt
))
1688 gbind
*bind_stmt
= as_a
<gbind
*> (stmt
);
1689 gbind
*bind_copy
= as_a
<gbind
*> (copy
);
1690 new_seq
= gimple_seq_copy (gimple_bind_body (bind_stmt
));
1691 gimple_bind_set_body (bind_copy
, new_seq
);
1692 gimple_bind_set_vars (bind_copy
,
1693 unshare_expr (gimple_bind_vars (bind_stmt
)));
1694 gimple_bind_set_block (bind_copy
, gimple_bind_block (bind_stmt
));
1700 gcatch
*catch_stmt
= as_a
<gcatch
*> (stmt
);
1701 gcatch
*catch_copy
= as_a
<gcatch
*> (copy
);
1702 new_seq
= gimple_seq_copy (gimple_catch_handler (catch_stmt
));
1703 gimple_catch_set_handler (catch_copy
, new_seq
);
1704 t
= unshare_expr (gimple_catch_types (catch_stmt
));
1705 gimple_catch_set_types (catch_copy
, t
);
1709 case GIMPLE_EH_FILTER
:
1711 geh_filter
*eh_filter_stmt
= as_a
<geh_filter
*> (stmt
);
1712 geh_filter
*eh_filter_copy
= as_a
<geh_filter
*> (copy
);
1714 = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt
));
1715 gimple_eh_filter_set_failure (eh_filter_copy
, new_seq
);
1716 t
= unshare_expr (gimple_eh_filter_types (eh_filter_stmt
));
1717 gimple_eh_filter_set_types (eh_filter_copy
, t
);
1721 case GIMPLE_EH_ELSE
:
1723 geh_else
*eh_else_stmt
= as_a
<geh_else
*> (stmt
);
1724 geh_else
*eh_else_copy
= as_a
<geh_else
*> (copy
);
1725 new_seq
= gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt
));
1726 gimple_eh_else_set_n_body (eh_else_copy
, new_seq
);
1727 new_seq
= gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt
));
1728 gimple_eh_else_set_e_body (eh_else_copy
, new_seq
);
1734 gtry
*try_stmt
= as_a
<gtry
*> (stmt
);
1735 gtry
*try_copy
= as_a
<gtry
*> (copy
);
1736 new_seq
= gimple_seq_copy (gimple_try_eval (try_stmt
));
1737 gimple_try_set_eval (try_copy
, new_seq
);
1738 new_seq
= gimple_seq_copy (gimple_try_cleanup (try_stmt
));
1739 gimple_try_set_cleanup (try_copy
, new_seq
);
1743 case GIMPLE_OMP_FOR
:
1744 new_seq
= gimple_seq_copy (gimple_omp_for_pre_body (stmt
));
1745 gimple_omp_for_set_pre_body (copy
, new_seq
);
1746 t
= unshare_expr (gimple_omp_for_clauses (stmt
));
1747 gimple_omp_for_set_clauses (copy
, t
);
1749 gomp_for
*omp_for_copy
= as_a
<gomp_for
*> (copy
);
1750 omp_for_copy
->iter
= ggc_vec_alloc
<gimple_omp_for_iter
>
1751 ( gimple_omp_for_collapse (stmt
));
1753 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1755 gimple_omp_for_set_cond (copy
, i
,
1756 gimple_omp_for_cond (stmt
, i
));
1757 gimple_omp_for_set_index (copy
, i
,
1758 gimple_omp_for_index (stmt
, i
));
1759 t
= unshare_expr (gimple_omp_for_initial (stmt
, i
));
1760 gimple_omp_for_set_initial (copy
, i
, t
);
1761 t
= unshare_expr (gimple_omp_for_final (stmt
, i
));
1762 gimple_omp_for_set_final (copy
, i
, t
);
1763 t
= unshare_expr (gimple_omp_for_incr (stmt
, i
));
1764 gimple_omp_for_set_incr (copy
, i
, t
);
1768 case GIMPLE_OMP_PARALLEL
:
1770 gomp_parallel
*omp_par_stmt
= as_a
<gomp_parallel
*> (stmt
);
1771 gomp_parallel
*omp_par_copy
= as_a
<gomp_parallel
*> (copy
);
1772 t
= unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt
));
1773 gimple_omp_parallel_set_clauses (omp_par_copy
, t
);
1774 t
= unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt
));
1775 gimple_omp_parallel_set_child_fn (omp_par_copy
, t
);
1776 t
= unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt
));
1777 gimple_omp_parallel_set_data_arg (omp_par_copy
, t
);
1781 case GIMPLE_OMP_TASK
:
1782 t
= unshare_expr (gimple_omp_task_clauses (stmt
));
1783 gimple_omp_task_set_clauses (copy
, t
);
1784 t
= unshare_expr (gimple_omp_task_child_fn (stmt
));
1785 gimple_omp_task_set_child_fn (copy
, t
);
1786 t
= unshare_expr (gimple_omp_task_data_arg (stmt
));
1787 gimple_omp_task_set_data_arg (copy
, t
);
1788 t
= unshare_expr (gimple_omp_task_copy_fn (stmt
));
1789 gimple_omp_task_set_copy_fn (copy
, t
);
1790 t
= unshare_expr (gimple_omp_task_arg_size (stmt
));
1791 gimple_omp_task_set_arg_size (copy
, t
);
1792 t
= unshare_expr (gimple_omp_task_arg_align (stmt
));
1793 gimple_omp_task_set_arg_align (copy
, t
);
1796 case GIMPLE_OMP_CRITICAL
:
1797 t
= unshare_expr (gimple_omp_critical_name
1798 (as_a
<gomp_critical
*> (stmt
)));
1799 gimple_omp_critical_set_name (as_a
<gomp_critical
*> (copy
), t
);
1800 t
= unshare_expr (gimple_omp_critical_clauses
1801 (as_a
<gomp_critical
*> (stmt
)));
1802 gimple_omp_critical_set_clauses (as_a
<gomp_critical
*> (copy
), t
);
1805 case GIMPLE_OMP_ORDERED
:
1806 t
= unshare_expr (gimple_omp_ordered_clauses
1807 (as_a
<gomp_ordered
*> (stmt
)));
1808 gimple_omp_ordered_set_clauses (as_a
<gomp_ordered
*> (copy
), t
);
1811 case GIMPLE_OMP_SECTIONS
:
1812 t
= unshare_expr (gimple_omp_sections_clauses (stmt
));
1813 gimple_omp_sections_set_clauses (copy
, t
);
1814 t
= unshare_expr (gimple_omp_sections_control (stmt
));
1815 gimple_omp_sections_set_control (copy
, t
);
1818 case GIMPLE_OMP_SINGLE
:
1819 case GIMPLE_OMP_TARGET
:
1820 case GIMPLE_OMP_TEAMS
:
1821 case GIMPLE_OMP_SECTION
:
1822 case GIMPLE_OMP_MASTER
:
1823 case GIMPLE_OMP_TASKGROUP
:
1824 case GIMPLE_OMP_GRID_BODY
:
1826 new_seq
= gimple_seq_copy (gimple_omp_body (stmt
));
1827 gimple_omp_set_body (copy
, new_seq
);
1830 case GIMPLE_TRANSACTION
:
1831 new_seq
= gimple_seq_copy (gimple_transaction_body (
1832 as_a
<gtransaction
*> (stmt
)));
1833 gimple_transaction_set_body (as_a
<gtransaction
*> (copy
),
1837 case GIMPLE_WITH_CLEANUP_EXPR
:
1838 new_seq
= gimple_seq_copy (gimple_wce_cleanup (stmt
));
1839 gimple_wce_set_cleanup (copy
, new_seq
);
1847 /* Make copy of operands. */
1848 for (i
= 0; i
< num_ops
; i
++)
1849 gimple_set_op (copy
, i
, unshare_expr (gimple_op (stmt
, i
)));
1851 if (gimple_has_mem_ops (stmt
))
1853 gimple_set_vdef (copy
, gimple_vdef (stmt
));
1854 gimple_set_vuse (copy
, gimple_vuse (stmt
));
1857 /* Clear out SSA operand vectors on COPY. */
1858 if (gimple_has_ops (stmt
))
1860 gimple_set_use_ops (copy
, NULL
);
1862 /* SSA operands need to be updated. */
1863 gimple_set_modified (copy
, true);
1870 /* Return true if statement S has side-effects. We consider a
1871 statement to have side effects if:
1873 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
1874 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
1877 gimple_has_side_effects (const gimple
*s
)
1879 if (is_gimple_debug (s
))
1882 /* We don't have to scan the arguments to check for
1883 volatile arguments, though, at present, we still
1884 do a scan to check for TREE_SIDE_EFFECTS. */
1885 if (gimple_has_volatile_ops (s
))
1888 if (gimple_code (s
) == GIMPLE_ASM
1889 && gimple_asm_volatile_p (as_a
<const gasm
*> (s
)))
1892 if (is_gimple_call (s
))
1894 int flags
= gimple_call_flags (s
);
1896 /* An infinite loop is considered a side effect. */
1897 if (!(flags
& (ECF_CONST
| ECF_PURE
))
1898 || (flags
& ECF_LOOPING_CONST_OR_PURE
))
1907 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
1908 Return true if S can trap. When INCLUDE_MEM is true, check whether
1909 the memory operations could trap. When INCLUDE_STORES is true and
1910 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
1913 gimple_could_trap_p_1 (gimple
*s
, bool include_mem
, bool include_stores
)
1915 tree t
, div
= NULL_TREE
;
1920 unsigned i
, start
= (is_gimple_assign (s
) && !include_stores
) ? 1 : 0;
1922 for (i
= start
; i
< gimple_num_ops (s
); i
++)
1923 if (tree_could_trap_p (gimple_op (s
, i
)))
1927 switch (gimple_code (s
))
1930 return gimple_asm_volatile_p (as_a
<gasm
*> (s
));
1933 t
= gimple_call_fndecl (s
);
1934 /* Assume that calls to weak functions may trap. */
1935 if (!t
|| !DECL_P (t
) || DECL_WEAK (t
))
1940 t
= gimple_expr_type (s
);
1941 op
= gimple_assign_rhs_code (s
);
1942 if (get_gimple_rhs_class (op
) == GIMPLE_BINARY_RHS
)
1943 div
= gimple_assign_rhs2 (s
);
1944 return (operation_could_trap_p (op
, FLOAT_TYPE_P (t
),
1945 (INTEGRAL_TYPE_P (t
)
1946 && TYPE_OVERFLOW_TRAPS (t
)),
1950 t
= TREE_TYPE (gimple_cond_lhs (s
));
1951 return operation_could_trap_p (gimple_cond_code (s
),
1952 FLOAT_TYPE_P (t
), false, NULL_TREE
);
1961 /* Return true if statement S can trap. */
1964 gimple_could_trap_p (gimple
*s
)
1966 return gimple_could_trap_p_1 (s
, true, true);
1969 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
1972 gimple_assign_rhs_could_trap_p (gimple
*s
)
1974 gcc_assert (is_gimple_assign (s
));
1975 return gimple_could_trap_p_1 (s
, true, false);
1979 /* Print debugging information for gimple stmts generated. */
1982 dump_gimple_statistics (void)
1984 int i
, total_tuples
= 0, total_bytes
= 0;
1986 if (! GATHER_STATISTICS
)
1988 fprintf (stderr
, "No gimple statistics\n");
1992 fprintf (stderr
, "\nGIMPLE statements\n");
1993 fprintf (stderr
, "Kind Stmts Bytes\n");
1994 fprintf (stderr
, "---------------------------------------\n");
1995 for (i
= 0; i
< (int) gimple_alloc_kind_all
; ++i
)
1997 fprintf (stderr
, "%-20s %7d %10d\n", gimple_alloc_kind_names
[i
],
1998 gimple_alloc_counts
[i
], gimple_alloc_sizes
[i
]);
1999 total_tuples
+= gimple_alloc_counts
[i
];
2000 total_bytes
+= gimple_alloc_sizes
[i
];
2002 fprintf (stderr
, "---------------------------------------\n");
2003 fprintf (stderr
, "%-20s %7d %10d\n", "Total", total_tuples
, total_bytes
);
2004 fprintf (stderr
, "---------------------------------------\n");
2008 /* Return the number of operands needed on the RHS of a GIMPLE
2009 assignment for an expression with tree code CODE. */
2012 get_gimple_rhs_num_ops (enum tree_code code
)
2014 enum gimple_rhs_class rhs_class
= get_gimple_rhs_class (code
);
2016 if (rhs_class
== GIMPLE_UNARY_RHS
|| rhs_class
== GIMPLE_SINGLE_RHS
)
2018 else if (rhs_class
== GIMPLE_BINARY_RHS
)
2020 else if (rhs_class
== GIMPLE_TERNARY_RHS
)
2026 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2028 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2029 : ((TYPE) == tcc_binary \
2030 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2031 : ((TYPE) == tcc_constant \
2032 || (TYPE) == tcc_declaration \
2033 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2034 : ((SYM) == TRUTH_AND_EXPR \
2035 || (SYM) == TRUTH_OR_EXPR \
2036 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2037 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2038 : ((SYM) == COND_EXPR \
2039 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2040 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2041 || (SYM) == DOT_PROD_EXPR \
2042 || (SYM) == SAD_EXPR \
2043 || (SYM) == REALIGN_LOAD_EXPR \
2044 || (SYM) == VEC_COND_EXPR \
2045 || (SYM) == VEC_PERM_EXPR \
2046 || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS \
2047 : ((SYM) == CONSTRUCTOR \
2048 || (SYM) == OBJ_TYPE_REF \
2049 || (SYM) == ASSERT_EXPR \
2050 || (SYM) == ADDR_EXPR \
2051 || (SYM) == WITH_SIZE_EXPR \
2052 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2053 : GIMPLE_INVALID_RHS),
2054 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2056 const unsigned char gimple_rhs_class_table
[] = {
2057 #include "all-tree.def"
2061 #undef END_OF_BASE_TREE_CODES
2063 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2064 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2065 we failed to create one. */
2068 canonicalize_cond_expr_cond (tree t
)
2070 /* Strip conversions around boolean operations. */
2071 if (CONVERT_EXPR_P (t
)
2072 && (truth_value_p (TREE_CODE (TREE_OPERAND (t
, 0)))
2073 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
2075 t
= TREE_OPERAND (t
, 0);
2077 /* For !x use x == 0. */
2078 if (TREE_CODE (t
) == TRUTH_NOT_EXPR
)
2080 tree top0
= TREE_OPERAND (t
, 0);
2081 t
= build2 (EQ_EXPR
, TREE_TYPE (t
),
2082 top0
, build_int_cst (TREE_TYPE (top0
), 0));
2084 /* For cmp ? 1 : 0 use cmp. */
2085 else if (TREE_CODE (t
) == COND_EXPR
2086 && COMPARISON_CLASS_P (TREE_OPERAND (t
, 0))
2087 && integer_onep (TREE_OPERAND (t
, 1))
2088 && integer_zerop (TREE_OPERAND (t
, 2)))
2090 tree top0
= TREE_OPERAND (t
, 0);
2091 t
= build2 (TREE_CODE (top0
), TREE_TYPE (t
),
2092 TREE_OPERAND (top0
, 0), TREE_OPERAND (top0
, 1));
2094 /* For x ^ y use x != y. */
2095 else if (TREE_CODE (t
) == BIT_XOR_EXPR
)
2096 t
= build2 (NE_EXPR
, TREE_TYPE (t
),
2097 TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1));
2099 if (is_gimple_condexpr (t
))
2105 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2106 the positions marked by the set ARGS_TO_SKIP. */
2109 gimple_call_copy_skip_args (gcall
*stmt
, bitmap args_to_skip
)
2112 int nargs
= gimple_call_num_args (stmt
);
2113 auto_vec
<tree
> vargs (nargs
);
2116 for (i
= 0; i
< nargs
; i
++)
2117 if (!bitmap_bit_p (args_to_skip
, i
))
2118 vargs
.quick_push (gimple_call_arg (stmt
, i
));
2120 if (gimple_call_internal_p (stmt
))
2121 new_stmt
= gimple_build_call_internal_vec (gimple_call_internal_fn (stmt
),
2124 new_stmt
= gimple_build_call_vec (gimple_call_fn (stmt
), vargs
);
2126 if (gimple_call_lhs (stmt
))
2127 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2129 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2130 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
2132 if (gimple_has_location (stmt
))
2133 gimple_set_location (new_stmt
, gimple_location (stmt
));
2134 gimple_call_copy_flags (new_stmt
, stmt
);
2135 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2137 gimple_set_modified (new_stmt
, true);
2144 /* Return true if the field decls F1 and F2 are at the same offset.
2146 This is intended to be used on GIMPLE types only. */
2149 gimple_compare_field_offset (tree f1
, tree f2
)
2151 if (DECL_OFFSET_ALIGN (f1
) == DECL_OFFSET_ALIGN (f2
))
2153 tree offset1
= DECL_FIELD_OFFSET (f1
);
2154 tree offset2
= DECL_FIELD_OFFSET (f2
);
2155 return ((offset1
== offset2
2156 /* Once gimplification is done, self-referential offsets are
2157 instantiated as operand #2 of the COMPONENT_REF built for
2158 each access and reset. Therefore, they are not relevant
2159 anymore and fields are interchangeable provided that they
2160 represent the same access. */
2161 || (TREE_CODE (offset1
) == PLACEHOLDER_EXPR
2162 && TREE_CODE (offset2
) == PLACEHOLDER_EXPR
2163 && (DECL_SIZE (f1
) == DECL_SIZE (f2
)
2164 || (TREE_CODE (DECL_SIZE (f1
)) == PLACEHOLDER_EXPR
2165 && TREE_CODE (DECL_SIZE (f2
)) == PLACEHOLDER_EXPR
)
2166 || operand_equal_p (DECL_SIZE (f1
), DECL_SIZE (f2
), 0))
2167 && DECL_ALIGN (f1
) == DECL_ALIGN (f2
))
2168 || operand_equal_p (offset1
, offset2
, 0))
2169 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1
),
2170 DECL_FIELD_BIT_OFFSET (f2
)));
2173 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2174 should be, so handle differing ones specially by decomposing
2175 the offset into a byte and bit offset manually. */
2176 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1
))
2177 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2
)))
2179 unsigned HOST_WIDE_INT byte_offset1
, byte_offset2
;
2180 unsigned HOST_WIDE_INT bit_offset1
, bit_offset2
;
2181 bit_offset1
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1
));
2182 byte_offset1
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1
))
2183 + bit_offset1
/ BITS_PER_UNIT
);
2184 bit_offset2
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2
));
2185 byte_offset2
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2
))
2186 + bit_offset2
/ BITS_PER_UNIT
);
2187 if (byte_offset1
!= byte_offset2
)
2189 return bit_offset1
% BITS_PER_UNIT
== bit_offset2
% BITS_PER_UNIT
;
2196 /* Return a type the same as TYPE except unsigned or
2197 signed according to UNSIGNEDP. */
2200 gimple_signed_or_unsigned_type (bool unsignedp
, tree type
)
2205 type1
= TYPE_MAIN_VARIANT (type
);
2206 if (type1
== signed_char_type_node
2207 || type1
== char_type_node
2208 || type1
== unsigned_char_type_node
)
2209 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2210 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2211 return unsignedp
? unsigned_type_node
: integer_type_node
;
2212 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2213 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2214 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2215 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2216 if (type1
== long_long_integer_type_node
2217 || type1
== long_long_unsigned_type_node
)
2219 ? long_long_unsigned_type_node
2220 : long_long_integer_type_node
;
2222 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2223 if (int_n_enabled_p
[i
]
2224 && (type1
== int_n_trees
[i
].unsigned_type
2225 || type1
== int_n_trees
[i
].signed_type
))
2227 ? int_n_trees
[i
].unsigned_type
2228 : int_n_trees
[i
].signed_type
;
2230 #if HOST_BITS_PER_WIDE_INT >= 64
2231 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2232 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2234 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2235 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2236 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2237 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2238 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2239 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2240 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2241 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2243 #define GIMPLE_FIXED_TYPES(NAME) \
2244 if (type1 == short_ ## NAME ## _type_node \
2245 || type1 == unsigned_short_ ## NAME ## _type_node) \
2246 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2247 : short_ ## NAME ## _type_node; \
2248 if (type1 == NAME ## _type_node \
2249 || type1 == unsigned_ ## NAME ## _type_node) \
2250 return unsignedp ? unsigned_ ## NAME ## _type_node \
2251 : NAME ## _type_node; \
2252 if (type1 == long_ ## NAME ## _type_node \
2253 || type1 == unsigned_long_ ## NAME ## _type_node) \
2254 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2255 : long_ ## NAME ## _type_node; \
2256 if (type1 == long_long_ ## NAME ## _type_node \
2257 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2258 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2259 : long_long_ ## NAME ## _type_node;
2261 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2262 if (type1 == NAME ## _type_node \
2263 || type1 == u ## NAME ## _type_node) \
2264 return unsignedp ? u ## NAME ## _type_node \
2265 : NAME ## _type_node;
2267 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2268 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2269 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2270 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2271 : sat_ ## short_ ## NAME ## _type_node; \
2272 if (type1 == sat_ ## NAME ## _type_node \
2273 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2274 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2275 : sat_ ## NAME ## _type_node; \
2276 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2277 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2278 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2279 : sat_ ## long_ ## NAME ## _type_node; \
2280 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2281 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2282 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2283 : sat_ ## long_long_ ## NAME ## _type_node;
2285 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2286 if (type1 == sat_ ## NAME ## _type_node \
2287 || type1 == sat_ ## u ## NAME ## _type_node) \
2288 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2289 : sat_ ## NAME ## _type_node;
2291 GIMPLE_FIXED_TYPES (fract
);
2292 GIMPLE_FIXED_TYPES_SAT (fract
);
2293 GIMPLE_FIXED_TYPES (accum
);
2294 GIMPLE_FIXED_TYPES_SAT (accum
);
2296 GIMPLE_FIXED_MODE_TYPES (qq
);
2297 GIMPLE_FIXED_MODE_TYPES (hq
);
2298 GIMPLE_FIXED_MODE_TYPES (sq
);
2299 GIMPLE_FIXED_MODE_TYPES (dq
);
2300 GIMPLE_FIXED_MODE_TYPES (tq
);
2301 GIMPLE_FIXED_MODE_TYPES_SAT (qq
);
2302 GIMPLE_FIXED_MODE_TYPES_SAT (hq
);
2303 GIMPLE_FIXED_MODE_TYPES_SAT (sq
);
2304 GIMPLE_FIXED_MODE_TYPES_SAT (dq
);
2305 GIMPLE_FIXED_MODE_TYPES_SAT (tq
);
2306 GIMPLE_FIXED_MODE_TYPES (ha
);
2307 GIMPLE_FIXED_MODE_TYPES (sa
);
2308 GIMPLE_FIXED_MODE_TYPES (da
);
2309 GIMPLE_FIXED_MODE_TYPES (ta
);
2310 GIMPLE_FIXED_MODE_TYPES_SAT (ha
);
2311 GIMPLE_FIXED_MODE_TYPES_SAT (sa
);
2312 GIMPLE_FIXED_MODE_TYPES_SAT (da
);
2313 GIMPLE_FIXED_MODE_TYPES_SAT (ta
);
2315 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2316 the precision; they have precision set to match their range, but
2317 may use a wider mode to match an ABI. If we change modes, we may
2318 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2319 the precision as well, so as to yield correct results for
2320 bit-field types. C++ does not have these separate bit-field
2321 types, and producing a signed or unsigned variant of an
2322 ENUMERAL_TYPE may cause other problems as well. */
2323 if (!INTEGRAL_TYPE_P (type
)
2324 || TYPE_UNSIGNED (type
) == unsignedp
)
2327 #define TYPE_OK(node) \
2328 (TYPE_MODE (type) == TYPE_MODE (node) \
2329 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2330 if (TYPE_OK (signed_char_type_node
))
2331 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2332 if (TYPE_OK (integer_type_node
))
2333 return unsignedp
? unsigned_type_node
: integer_type_node
;
2334 if (TYPE_OK (short_integer_type_node
))
2335 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2336 if (TYPE_OK (long_integer_type_node
))
2337 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2338 if (TYPE_OK (long_long_integer_type_node
))
2340 ? long_long_unsigned_type_node
2341 : long_long_integer_type_node
);
2343 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2344 if (int_n_enabled_p
[i
]
2345 && TYPE_MODE (type
) == int_n_data
[i
].m
2346 && TYPE_PRECISION (type
) == int_n_data
[i
].bitsize
)
2348 ? int_n_trees
[i
].unsigned_type
2349 : int_n_trees
[i
].signed_type
;
2351 #if HOST_BITS_PER_WIDE_INT >= 64
2352 if (TYPE_OK (intTI_type_node
))
2353 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2355 if (TYPE_OK (intDI_type_node
))
2356 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2357 if (TYPE_OK (intSI_type_node
))
2358 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2359 if (TYPE_OK (intHI_type_node
))
2360 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2361 if (TYPE_OK (intQI_type_node
))
2362 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2364 #undef GIMPLE_FIXED_TYPES
2365 #undef GIMPLE_FIXED_MODE_TYPES
2366 #undef GIMPLE_FIXED_TYPES_SAT
2367 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2370 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2374 /* Return an unsigned type the same as TYPE in other respects. */
2377 gimple_unsigned_type (tree type
)
2379 return gimple_signed_or_unsigned_type (true, type
);
2383 /* Return a signed type the same as TYPE in other respects. */
2386 gimple_signed_type (tree type
)
2388 return gimple_signed_or_unsigned_type (false, type
);
2392 /* Return the typed-based alias set for T, which may be an expression
2393 or a type. Return -1 if we don't do anything special. */
2396 gimple_get_alias_set (tree t
)
2400 /* Permit type-punning when accessing a union, provided the access
2401 is directly through the union. For example, this code does not
2402 permit taking the address of a union member and then storing
2403 through it. Even the type-punning allowed here is a GCC
2404 extension, albeit a common and useful one; the C standard says
2405 that such accesses have implementation-defined behavior. */
2407 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2408 u
= TREE_OPERAND (u
, 0))
2409 if (TREE_CODE (u
) == COMPONENT_REF
2410 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2413 /* That's all the expressions we handle specially. */
2417 /* For convenience, follow the C standard when dealing with
2418 character types. Any object may be accessed via an lvalue that
2419 has character type. */
2420 if (t
== char_type_node
2421 || t
== signed_char_type_node
2422 || t
== unsigned_char_type_node
)
2425 /* Allow aliasing between signed and unsigned variants of the same
2426 type. We treat the signed variant as canonical. */
2427 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2429 tree t1
= gimple_signed_type (t
);
2431 /* t1 == t can happen for boolean nodes which are always unsigned. */
2433 return get_alias_set (t1
);
2440 /* Helper for gimple_ior_addresses_taken_1. */
2443 gimple_ior_addresses_taken_1 (gimple
*, tree addr
, tree
, void *data
)
2445 bitmap addresses_taken
= (bitmap
)data
;
2446 addr
= get_base_address (addr
);
2450 bitmap_set_bit (addresses_taken
, DECL_UID (addr
));
2456 /* Set the bit for the uid of all decls that have their address taken
2457 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2458 were any in this stmt. */
2461 gimple_ior_addresses_taken (bitmap addresses_taken
, gimple
*stmt
)
2463 return walk_stmt_load_store_addr_ops (stmt
, addresses_taken
, NULL
, NULL
,
2464 gimple_ior_addresses_taken_1
);
2468 /* Return true when STMTs arguments and return value match those of FNDECL,
2469 a decl of a builtin function. */
2472 gimple_builtin_call_types_compatible_p (const gimple
*stmt
, tree fndecl
)
2474 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
);
2476 tree ret
= gimple_call_lhs (stmt
);
2478 && !useless_type_conversion_p (TREE_TYPE (ret
),
2479 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 (!useless_type_conversion_p (TREE_VALUE (targs
), TREE_TYPE (arg
)))
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 /* If CALL is a call to a combined_fn (i.e. an internal function or
2540 a normal built-in function), return its code, otherwise return
2544 gimple_call_combined_fn (const gimple
*stmt
)
2546 if (const gcall
*call
= dyn_cast
<const gcall
*> (stmt
))
2548 if (gimple_call_internal_p (call
))
2549 return as_combined_fn (gimple_call_internal_fn (call
));
2551 tree fndecl
= gimple_call_fndecl (stmt
);
2553 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
2554 && gimple_builtin_call_types_compatible_p (stmt
, fndecl
))
2555 return as_combined_fn (DECL_FUNCTION_CODE (fndecl
));
2560 /* Return true if STMT clobbers memory. STMT is required to be a
2564 gimple_asm_clobbers_memory_p (const gasm
*stmt
)
2568 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
2570 tree op
= gimple_asm_clobber_op (stmt
, i
);
2571 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op
)), "memory") == 0)
2578 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2581 dump_decl_set (FILE *file
, bitmap set
)
2588 fprintf (file
, "{ ");
2590 EXECUTE_IF_SET_IN_BITMAP (set
, 0, i
, bi
)
2592 fprintf (file
, "D.%u", i
);
2593 fprintf (file
, " ");
2596 fprintf (file
, "}");
2599 fprintf (file
, "NIL");
2602 /* Return true when CALL is a call stmt that definitely doesn't
2603 free any memory or makes it unavailable otherwise. */
2605 nonfreeing_call_p (gimple
*call
)
2607 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2608 && gimple_call_flags (call
) & ECF_LEAF
)
2609 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call
)))
2611 /* Just in case these become ECF_LEAF in the future. */
2613 case BUILT_IN_TM_FREE
:
2614 case BUILT_IN_REALLOC
:
2615 case BUILT_IN_STACK_RESTORE
:
2620 else if (gimple_call_internal_p (call
))
2621 switch (gimple_call_internal_fn (call
))
2623 case IFN_ABNORMAL_DISPATCHER
:
2626 if (gimple_call_flags (call
) & ECF_LEAF
)
2631 tree fndecl
= gimple_call_fndecl (call
);
2634 struct cgraph_node
*n
= cgraph_node::get (fndecl
);
2637 enum availability availability
;
2638 n
= n
->function_symbol (&availability
);
2639 if (!n
|| availability
<= AVAIL_INTERPOSABLE
)
2641 return n
->nonfreeing_fn
;
2644 /* Return true when CALL is a call stmt that definitely need not
2645 be considered to be a memory barrier. */
2647 nonbarrier_call_p (gimple
*call
)
2649 if (gimple_call_flags (call
) & (ECF_PURE
| ECF_CONST
))
2651 /* Should extend this to have a nonbarrier_fn flag, just as above in
2652 the nonfreeing case. */
2656 /* Callback for walk_stmt_load_store_ops.
2658 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2661 This routine only makes a superficial check for a dereference. Thus
2662 it must only be used if it is safe to return a false negative. */
2664 check_loadstore (gimple
*, tree op
, tree
, void *data
)
2666 if (TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
2668 /* Some address spaces may legitimately dereference zero. */
2669 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (op
));
2670 if (targetm
.addr_space
.zero_address_valid (as
))
2673 return operand_equal_p (TREE_OPERAND (op
, 0), (tree
)data
, 0);
2679 /* Return true if OP can be inferred to be non-NULL after STMT executes,
2680 either by using a pointer dereference or attributes. */
2682 infer_nonnull_range (gimple
*stmt
, tree op
)
2684 return infer_nonnull_range_by_dereference (stmt
, op
)
2685 || infer_nonnull_range_by_attribute (stmt
, op
);
2688 /* Return true if OP can be inferred to be non-NULL after STMT
2689 executes by using a pointer dereference. */
2691 infer_nonnull_range_by_dereference (gimple
*stmt
, tree op
)
2693 /* We can only assume that a pointer dereference will yield
2694 non-NULL if -fdelete-null-pointer-checks is enabled. */
2695 if (!flag_delete_null_pointer_checks
2696 || !POINTER_TYPE_P (TREE_TYPE (op
))
2697 || gimple_code (stmt
) == GIMPLE_ASM
)
2700 if (walk_stmt_load_store_ops (stmt
, (void *)op
,
2701 check_loadstore
, check_loadstore
))
2707 /* Return true if OP can be inferred to be a non-NULL after STMT
2708 executes by using attributes. */
2710 infer_nonnull_range_by_attribute (gimple
*stmt
, tree op
)
2712 /* We can only assume that a pointer dereference will yield
2713 non-NULL if -fdelete-null-pointer-checks is enabled. */
2714 if (!flag_delete_null_pointer_checks
2715 || !POINTER_TYPE_P (TREE_TYPE (op
))
2716 || gimple_code (stmt
) == GIMPLE_ASM
)
2719 if (is_gimple_call (stmt
) && !gimple_call_internal_p (stmt
))
2721 tree fntype
= gimple_call_fntype (stmt
);
2722 tree attrs
= TYPE_ATTRIBUTES (fntype
);
2723 for (; attrs
; attrs
= TREE_CHAIN (attrs
))
2725 attrs
= lookup_attribute ("nonnull", attrs
);
2727 /* If "nonnull" wasn't specified, we know nothing about
2729 if (attrs
== NULL_TREE
)
2732 /* If "nonnull" applies to all the arguments, then ARG
2733 is non-null if it's in the argument list. */
2734 if (TREE_VALUE (attrs
) == NULL_TREE
)
2736 for (unsigned int i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2738 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt
, i
)))
2739 && operand_equal_p (op
, gimple_call_arg (stmt
, i
), 0))
2745 /* Now see if op appears in the nonnull list. */
2746 for (tree t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
2748 unsigned int idx
= TREE_INT_CST_LOW (TREE_VALUE (t
)) - 1;
2749 if (idx
< gimple_call_num_args (stmt
))
2751 tree arg
= gimple_call_arg (stmt
, idx
);
2752 if (operand_equal_p (op
, arg
, 0))
2759 /* If this function is marked as returning non-null, then we can
2760 infer OP is non-null if it is used in the return statement. */
2761 if (greturn
*return_stmt
= dyn_cast
<greturn
*> (stmt
))
2762 if (gimple_return_retval (return_stmt
)
2763 && operand_equal_p (gimple_return_retval (return_stmt
), op
, 0)
2764 && lookup_attribute ("returns_nonnull",
2765 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
))))
2771 /* Compare two case labels. Because the front end should already have
2772 made sure that case ranges do not overlap, it is enough to only compare
2773 the CASE_LOW values of each case label. */
2776 compare_case_labels (const void *p1
, const void *p2
)
2778 const_tree
const case1
= *(const_tree
const*)p1
;
2779 const_tree
const case2
= *(const_tree
const*)p2
;
2781 /* The 'default' case label always goes first. */
2782 if (!CASE_LOW (case1
))
2784 else if (!CASE_LOW (case2
))
2787 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
2790 /* Sort the case labels in LABEL_VEC in place in ascending order. */
2793 sort_case_labels (vec
<tree
> label_vec
)
2795 label_vec
.qsort (compare_case_labels
);
2798 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2800 LABELS is a vector that contains all case labels to look at.
2802 INDEX_TYPE is the type of the switch index expression. Case labels
2803 in LABELS are discarded if their values are not in the value range
2804 covered by INDEX_TYPE. The remaining case label values are folded
2807 If a default case exists in LABELS, it is removed from LABELS and
2808 returned in DEFAULT_CASEP. If no default case exists, but the
2809 case labels already cover the whole range of INDEX_TYPE, a default
2810 case is returned pointing to one of the existing case labels.
2811 Otherwise DEFAULT_CASEP is set to NULL_TREE.
2813 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2814 apply and no action is taken regardless of whether a default case is
2818 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
2820 tree
*default_casep
)
2822 tree min_value
, max_value
;
2823 tree default_case
= NULL_TREE
;
2827 min_value
= TYPE_MIN_VALUE (index_type
);
2828 max_value
= TYPE_MAX_VALUE (index_type
);
2829 while (i
< labels
.length ())
2831 tree elt
= labels
[i
];
2832 tree low
= CASE_LOW (elt
);
2833 tree high
= CASE_HIGH (elt
);
2834 bool remove_element
= FALSE
;
2838 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
2839 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
2841 /* This is a non-default case label, i.e. it has a value.
2843 See if the case label is reachable within the range of
2844 the index type. Remove out-of-range case values. Turn
2845 case ranges into a canonical form (high > low strictly)
2846 and convert the case label values to the index type.
2848 NB: The type of gimple_switch_index() may be the promoted
2849 type, but the case labels retain the original type. */
2853 /* This is a case range. Discard empty ranges.
2854 If the bounds or the range are equal, turn this
2855 into a simple (one-value) case. */
2856 int cmp
= tree_int_cst_compare (high
, low
);
2858 remove_element
= TRUE
;
2865 /* If the simple case value is unreachable, ignore it. */
2866 if ((TREE_CODE (min_value
) == INTEGER_CST
2867 && tree_int_cst_compare (low
, min_value
) < 0)
2868 || (TREE_CODE (max_value
) == INTEGER_CST
2869 && tree_int_cst_compare (low
, max_value
) > 0))
2870 remove_element
= TRUE
;
2872 low
= fold_convert (index_type
, low
);
2876 /* If the entire case range is unreachable, ignore it. */
2877 if ((TREE_CODE (min_value
) == INTEGER_CST
2878 && tree_int_cst_compare (high
, min_value
) < 0)
2879 || (TREE_CODE (max_value
) == INTEGER_CST
2880 && tree_int_cst_compare (low
, max_value
) > 0))
2881 remove_element
= TRUE
;
2884 /* If the lower bound is less than the index type's
2885 minimum value, truncate the range bounds. */
2886 if (TREE_CODE (min_value
) == INTEGER_CST
2887 && tree_int_cst_compare (low
, min_value
) < 0)
2889 low
= fold_convert (index_type
, low
);
2891 /* If the upper bound is greater than the index type's
2892 maximum value, truncate the range bounds. */
2893 if (TREE_CODE (max_value
) == INTEGER_CST
2894 && tree_int_cst_compare (high
, max_value
) > 0)
2896 high
= fold_convert (index_type
, high
);
2898 /* We may have folded a case range to a one-value case. */
2899 if (tree_int_cst_equal (low
, high
))
2904 CASE_LOW (elt
) = low
;
2905 CASE_HIGH (elt
) = high
;
2909 gcc_assert (!default_case
);
2911 /* The default case must be passed separately to the
2912 gimple_build_switch routine. But if DEFAULT_CASEP
2913 is NULL, we do not remove the default case (it would
2914 be completely lost). */
2916 remove_element
= TRUE
;
2920 labels
.ordered_remove (i
);
2926 if (!labels
.is_empty ())
2927 sort_case_labels (labels
);
2929 if (default_casep
&& !default_case
)
2931 /* If the switch has no default label, add one, so that we jump
2932 around the switch body. If the labels already cover the whole
2933 range of the switch index_type, add the default label pointing
2934 to one of the existing labels. */
2936 && TYPE_MIN_VALUE (index_type
)
2937 && TYPE_MAX_VALUE (index_type
)
2938 && tree_int_cst_equal (CASE_LOW (labels
[0]),
2939 TYPE_MIN_VALUE (index_type
)))
2941 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
2943 high
= CASE_LOW (labels
[len
- 1]);
2944 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
2946 for (i
= 1; i
< len
; i
++)
2948 high
= CASE_LOW (labels
[i
]);
2949 low
= CASE_HIGH (labels
[i
- 1]);
2951 low
= CASE_LOW (labels
[i
- 1]);
2952 if (wi::add (low
, 1) != high
)
2957 tree label
= CASE_LABEL (labels
[0]);
2958 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
2966 *default_casep
= default_case
;
2969 /* Set the location of all statements in SEQ to LOC. */
2972 gimple_seq_set_location (gimple_seq seq
, location_t loc
)
2974 for (gimple_stmt_iterator i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
2975 gimple_set_location (gsi_stmt (i
), loc
);
2978 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
2981 gimple_seq_discard (gimple_seq seq
)
2983 gimple_stmt_iterator gsi
;
2985 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); )
2987 gimple
*stmt
= gsi_stmt (gsi
);
2988 gsi_remove (&gsi
, true);
2989 release_defs (stmt
);
2994 /* See if STMT now calls function that takes no parameters and if so, drop
2995 call arguments. This is used when devirtualization machinery redirects
2996 to __builtiln_unreacahble or __cxa_pure_virutal. */
2999 maybe_remove_unused_call_args (struct function
*fn
, gimple
*stmt
)
3001 tree decl
= gimple_call_fndecl (stmt
);
3002 if (TYPE_ARG_TYPES (TREE_TYPE (decl
))
3003 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
))) == void_type_node
3004 && gimple_call_num_args (stmt
))
3006 gimple_set_num_ops (stmt
, 3);
3007 update_stmt_fn (fn
, stmt
);