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_must_tail (call
, CALL_EXPR_MUST_TAIL_CALL (t
));
363 gimple_call_set_return_slot_opt (call
, CALL_EXPR_RETURN_SLOT_OPT (t
));
365 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
366 && (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA
367 || DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
368 gimple_call_set_alloca_for_var (call
, CALL_ALLOCA_FOR_VAR_P (t
));
370 gimple_call_set_from_thunk (call
, CALL_FROM_THUNK_P (t
));
371 gimple_call_set_va_arg_pack (call
, CALL_EXPR_VA_ARG_PACK (t
));
372 gimple_call_set_nothrow (call
, TREE_NOTHROW (t
));
373 gimple_set_no_warning (call
, TREE_NO_WARNING (t
));
374 gimple_call_set_with_bounds (call
, CALL_WITH_BOUNDS_P (t
));
380 /* Build a GIMPLE_ASSIGN statement.
382 LHS of the assignment.
383 RHS of the assignment which can be unary or binary. */
386 gimple_build_assign (tree lhs
, tree rhs MEM_STAT_DECL
)
388 enum tree_code subcode
;
391 extract_ops_from_tree (rhs
, &subcode
, &op1
, &op2
, &op3
);
392 return gimple_build_assign (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
396 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
399 static inline gassign
*
400 gimple_build_assign_1 (tree lhs
, enum tree_code subcode
, tree op1
,
401 tree op2
, tree op3 MEM_STAT_DECL
)
406 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
408 num_ops
= get_gimple_rhs_num_ops (subcode
) + 1;
410 p
= as_a
<gassign
*> (
411 gimple_build_with_ops_stat (GIMPLE_ASSIGN
, (unsigned)subcode
, num_ops
413 gimple_assign_set_lhs (p
, lhs
);
414 gimple_assign_set_rhs1 (p
, op1
);
417 gcc_assert (num_ops
> 2);
418 gimple_assign_set_rhs2 (p
, op2
);
423 gcc_assert (num_ops
> 3);
424 gimple_assign_set_rhs3 (p
, op3
);
430 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
434 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
435 tree op2
, tree op3 MEM_STAT_DECL
)
437 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
440 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
444 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
445 tree op2 MEM_STAT_DECL
)
447 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, NULL_TREE
451 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
454 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1 MEM_STAT_DECL
)
456 return gimple_build_assign_1 (lhs
, subcode
, op1
, NULL_TREE
, NULL_TREE
461 /* Build a GIMPLE_COND statement.
463 PRED is the condition used to compare LHS and the RHS.
464 T_LABEL is the label to jump to if the condition is true.
465 F_LABEL is the label to jump to otherwise. */
468 gimple_build_cond (enum tree_code pred_code
, tree lhs
, tree rhs
,
469 tree t_label
, tree f_label
)
473 gcc_assert (TREE_CODE_CLASS (pred_code
) == tcc_comparison
);
474 p
= as_a
<gcond
*> (gimple_build_with_ops (GIMPLE_COND
, pred_code
, 4));
475 gimple_cond_set_lhs (p
, lhs
);
476 gimple_cond_set_rhs (p
, rhs
);
477 gimple_cond_set_true_label (p
, t_label
);
478 gimple_cond_set_false_label (p
, f_label
);
482 /* Build a GIMPLE_COND statement from the conditional expression tree
483 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
486 gimple_build_cond_from_tree (tree cond
, tree t_label
, tree f_label
)
491 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
492 return gimple_build_cond (code
, lhs
, rhs
, t_label
, f_label
);
495 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
496 boolean expression tree COND. */
499 gimple_cond_set_condition_from_tree (gcond
*stmt
, tree cond
)
504 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
505 gimple_cond_set_condition (stmt
, code
, lhs
, rhs
);
508 /* Build a GIMPLE_LABEL statement for LABEL. */
511 gimple_build_label (tree label
)
514 = as_a
<glabel
*> (gimple_build_with_ops (GIMPLE_LABEL
, ERROR_MARK
, 1));
515 gimple_label_set_label (p
, label
);
519 /* Build a GIMPLE_GOTO statement to label DEST. */
522 gimple_build_goto (tree dest
)
525 = as_a
<ggoto
*> (gimple_build_with_ops (GIMPLE_GOTO
, ERROR_MARK
, 1));
526 gimple_goto_set_dest (p
, dest
);
531 /* Build a GIMPLE_NOP statement. */
534 gimple_build_nop (void)
536 return gimple_alloc (GIMPLE_NOP
, 0);
540 /* Build a GIMPLE_BIND statement.
541 VARS are the variables in BODY.
542 BLOCK is the containing block. */
545 gimple_build_bind (tree vars
, gimple_seq body
, tree block
)
547 gbind
*p
= as_a
<gbind
*> (gimple_alloc (GIMPLE_BIND
, 0));
548 gimple_bind_set_vars (p
, vars
);
550 gimple_bind_set_body (p
, body
);
552 gimple_bind_set_block (p
, block
);
556 /* Helper function to set the simple fields of a asm stmt.
558 STRING is a pointer to a string that is the asm blocks assembly code.
559 NINPUT is the number of register inputs.
560 NOUTPUT is the number of register outputs.
561 NCLOBBERS is the number of clobbered registers.
565 gimple_build_asm_1 (const char *string
, unsigned ninputs
, unsigned noutputs
,
566 unsigned nclobbers
, unsigned nlabels
)
569 int size
= strlen (string
);
571 /* ASMs with labels cannot have outputs. This should have been
572 enforced by the front end. */
573 gcc_assert (nlabels
== 0 || noutputs
== 0);
576 gimple_build_with_ops (GIMPLE_ASM
, ERROR_MARK
,
577 ninputs
+ noutputs
+ nclobbers
+ nlabels
));
583 p
->string
= ggc_alloc_string (string
, size
);
585 if (GATHER_STATISTICS
)
586 gimple_alloc_sizes
[(int) gimple_alloc_kind (GIMPLE_ASM
)] += size
;
591 /* Build a GIMPLE_ASM statement.
593 STRING is the assembly code.
594 NINPUT is the number of register inputs.
595 NOUTPUT is the number of register outputs.
596 NCLOBBERS is the number of clobbered registers.
597 INPUTS is a vector of the input register parameters.
598 OUTPUTS is a vector of the output register parameters.
599 CLOBBERS is a vector of the clobbered register parameters.
600 LABELS is a vector of destination labels. */
603 gimple_build_asm_vec (const char *string
, vec
<tree
, va_gc
> *inputs
,
604 vec
<tree
, va_gc
> *outputs
, vec
<tree
, va_gc
> *clobbers
,
605 vec
<tree
, va_gc
> *labels
)
610 p
= gimple_build_asm_1 (string
,
611 vec_safe_length (inputs
),
612 vec_safe_length (outputs
),
613 vec_safe_length (clobbers
),
614 vec_safe_length (labels
));
616 for (i
= 0; i
< vec_safe_length (inputs
); i
++)
617 gimple_asm_set_input_op (p
, i
, (*inputs
)[i
]);
619 for (i
= 0; i
< vec_safe_length (outputs
); i
++)
620 gimple_asm_set_output_op (p
, i
, (*outputs
)[i
]);
622 for (i
= 0; i
< vec_safe_length (clobbers
); i
++)
623 gimple_asm_set_clobber_op (p
, i
, (*clobbers
)[i
]);
625 for (i
= 0; i
< vec_safe_length (labels
); i
++)
626 gimple_asm_set_label_op (p
, i
, (*labels
)[i
]);
631 /* Build a GIMPLE_CATCH statement.
633 TYPES are the catch types.
634 HANDLER is the exception handler. */
637 gimple_build_catch (tree types
, gimple_seq handler
)
639 gcatch
*p
= as_a
<gcatch
*> (gimple_alloc (GIMPLE_CATCH
, 0));
640 gimple_catch_set_types (p
, types
);
642 gimple_catch_set_handler (p
, handler
);
647 /* Build a GIMPLE_EH_FILTER statement.
649 TYPES are the filter's types.
650 FAILURE is the filter's failure action. */
653 gimple_build_eh_filter (tree types
, gimple_seq failure
)
655 geh_filter
*p
= as_a
<geh_filter
*> (gimple_alloc (GIMPLE_EH_FILTER
, 0));
656 gimple_eh_filter_set_types (p
, types
);
658 gimple_eh_filter_set_failure (p
, failure
);
663 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
666 gimple_build_eh_must_not_throw (tree decl
)
668 geh_mnt
*p
= as_a
<geh_mnt
*> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW
, 0));
670 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
671 gcc_assert (flags_from_decl_or_type (decl
) & ECF_NORETURN
);
672 gimple_eh_must_not_throw_set_fndecl (p
, decl
);
677 /* Build a GIMPLE_EH_ELSE statement. */
680 gimple_build_eh_else (gimple_seq n_body
, gimple_seq e_body
)
682 geh_else
*p
= as_a
<geh_else
*> (gimple_alloc (GIMPLE_EH_ELSE
, 0));
683 gimple_eh_else_set_n_body (p
, n_body
);
684 gimple_eh_else_set_e_body (p
, e_body
);
688 /* Build a GIMPLE_TRY statement.
690 EVAL is the expression to evaluate.
691 CLEANUP is the cleanup expression.
692 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
693 whether this is a try/catch or a try/finally respectively. */
696 gimple_build_try (gimple_seq eval
, gimple_seq cleanup
,
697 enum gimple_try_flags kind
)
701 gcc_assert (kind
== GIMPLE_TRY_CATCH
|| kind
== GIMPLE_TRY_FINALLY
);
702 p
= as_a
<gtry
*> (gimple_alloc (GIMPLE_TRY
, 0));
703 gimple_set_subcode (p
, kind
);
705 gimple_try_set_eval (p
, eval
);
707 gimple_try_set_cleanup (p
, cleanup
);
712 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
714 CLEANUP is the cleanup expression. */
717 gimple_build_wce (gimple_seq cleanup
)
719 gimple
*p
= gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR
, 0);
721 gimple_wce_set_cleanup (p
, cleanup
);
727 /* Build a GIMPLE_RESX statement. */
730 gimple_build_resx (int region
)
733 = as_a
<gresx
*> (gimple_build_with_ops (GIMPLE_RESX
, ERROR_MARK
, 0));
739 /* The helper for constructing a gimple switch statement.
740 INDEX is the switch's index.
741 NLABELS is the number of labels in the switch excluding the default.
742 DEFAULT_LABEL is the default label for the switch statement. */
745 gimple_build_switch_nlabels (unsigned nlabels
, tree index
, tree default_label
)
747 /* nlabels + 1 default label + 1 index. */
748 gcc_checking_assert (default_label
);
749 gswitch
*p
= as_a
<gswitch
*> (gimple_build_with_ops (GIMPLE_SWITCH
,
752 gimple_switch_set_index (p
, index
);
753 gimple_switch_set_default_label (p
, default_label
);
757 /* Build a GIMPLE_SWITCH statement.
759 INDEX is the switch's index.
760 DEFAULT_LABEL is the default label
761 ARGS is a vector of labels excluding the default. */
764 gimple_build_switch (tree index
, tree default_label
, vec
<tree
> args
)
766 unsigned i
, nlabels
= args
.length ();
768 gswitch
*p
= gimple_build_switch_nlabels (nlabels
, index
, default_label
);
770 /* Copy the labels from the vector to the switch statement. */
771 for (i
= 0; i
< nlabels
; i
++)
772 gimple_switch_set_label (p
, i
+ 1, args
[i
]);
777 /* Build a GIMPLE_EH_DISPATCH statement. */
780 gimple_build_eh_dispatch (int region
)
783 = as_a
<geh_dispatch
*> (
784 gimple_build_with_ops (GIMPLE_EH_DISPATCH
, ERROR_MARK
, 0));
789 /* Build a new GIMPLE_DEBUG_BIND statement.
791 VAR is bound to VALUE; block and location are taken from STMT. */
794 gimple_build_debug_bind_stat (tree var
, tree value
, gimple
*stmt MEM_STAT_DECL
)
797 = as_a
<gdebug
*> (gimple_build_with_ops_stat (GIMPLE_DEBUG
,
798 (unsigned)GIMPLE_DEBUG_BIND
, 2
800 gimple_debug_bind_set_var (p
, var
);
801 gimple_debug_bind_set_value (p
, value
);
803 gimple_set_location (p
, gimple_location (stmt
));
809 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
811 VAR is bound to VALUE; block and location are taken from STMT. */
814 gimple_build_debug_source_bind_stat (tree var
, tree value
,
815 gimple
*stmt MEM_STAT_DECL
)
819 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
820 (unsigned)GIMPLE_DEBUG_SOURCE_BIND
, 2
823 gimple_debug_source_bind_set_var (p
, var
);
824 gimple_debug_source_bind_set_value (p
, value
);
826 gimple_set_location (p
, gimple_location (stmt
));
832 /* Build a GIMPLE_OMP_CRITICAL statement.
834 BODY is the sequence of statements for which only one thread can execute.
835 NAME is optional identifier for this critical block.
836 CLAUSES are clauses for this critical block. */
839 gimple_build_omp_critical (gimple_seq body
, tree name
, tree clauses
)
842 = as_a
<gomp_critical
*> (gimple_alloc (GIMPLE_OMP_CRITICAL
, 0));
843 gimple_omp_critical_set_name (p
, name
);
844 gimple_omp_critical_set_clauses (p
, clauses
);
846 gimple_omp_set_body (p
, body
);
851 /* Build a GIMPLE_OMP_FOR statement.
853 BODY is sequence of statements inside the for loop.
854 KIND is the `for' variant.
855 CLAUSES, are any of the construct's clauses.
856 COLLAPSE is the collapse count.
857 PRE_BODY is the sequence of statements that are loop invariant. */
860 gimple_build_omp_for (gimple_seq body
, int kind
, tree clauses
, size_t collapse
,
863 gomp_for
*p
= as_a
<gomp_for
*> (gimple_alloc (GIMPLE_OMP_FOR
, 0));
865 gimple_omp_set_body (p
, body
);
866 gimple_omp_for_set_clauses (p
, clauses
);
867 gimple_omp_for_set_kind (p
, kind
);
868 p
->collapse
= collapse
;
869 p
->iter
= ggc_cleared_vec_alloc
<gimple_omp_for_iter
> (collapse
);
872 gimple_omp_for_set_pre_body (p
, pre_body
);
878 /* Build a GIMPLE_OMP_PARALLEL statement.
880 BODY is sequence of statements which are executed in parallel.
881 CLAUSES, are the OMP parallel construct's clauses.
882 CHILD_FN is the function created for the parallel threads to execute.
883 DATA_ARG are the shared data argument(s). */
886 gimple_build_omp_parallel (gimple_seq body
, tree clauses
, tree child_fn
,
890 = as_a
<gomp_parallel
*> (gimple_alloc (GIMPLE_OMP_PARALLEL
, 0));
892 gimple_omp_set_body (p
, body
);
893 gimple_omp_parallel_set_clauses (p
, clauses
);
894 gimple_omp_parallel_set_child_fn (p
, child_fn
);
895 gimple_omp_parallel_set_data_arg (p
, data_arg
);
901 /* Build a GIMPLE_OMP_TASK statement.
903 BODY is sequence of statements which are executed by the explicit task.
904 CLAUSES, are the OMP parallel construct's clauses.
905 CHILD_FN is the function created for the parallel threads to execute.
906 DATA_ARG are the shared data argument(s).
907 COPY_FN is the optional function for firstprivate initialization.
908 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
911 gimple_build_omp_task (gimple_seq body
, tree clauses
, tree child_fn
,
912 tree data_arg
, tree copy_fn
, tree arg_size
,
915 gomp_task
*p
= as_a
<gomp_task
*> (gimple_alloc (GIMPLE_OMP_TASK
, 0));
917 gimple_omp_set_body (p
, body
);
918 gimple_omp_task_set_clauses (p
, clauses
);
919 gimple_omp_task_set_child_fn (p
, child_fn
);
920 gimple_omp_task_set_data_arg (p
, data_arg
);
921 gimple_omp_task_set_copy_fn (p
, copy_fn
);
922 gimple_omp_task_set_arg_size (p
, arg_size
);
923 gimple_omp_task_set_arg_align (p
, arg_align
);
929 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
931 BODY is the sequence of statements in the section. */
934 gimple_build_omp_section (gimple_seq body
)
936 gimple
*p
= gimple_alloc (GIMPLE_OMP_SECTION
, 0);
938 gimple_omp_set_body (p
, body
);
944 /* Build a GIMPLE_OMP_MASTER statement.
946 BODY is the sequence of statements to be executed by just the master. */
949 gimple_build_omp_master (gimple_seq body
)
951 gimple
*p
= gimple_alloc (GIMPLE_OMP_MASTER
, 0);
953 gimple_omp_set_body (p
, body
);
958 /* Build a GIMPLE_OMP_GRID_BODY statement.
960 BODY is the sequence of statements to be executed by the kernel. */
963 gimple_build_omp_grid_body (gimple_seq body
)
965 gimple
*p
= gimple_alloc (GIMPLE_OMP_GRID_BODY
, 0);
967 gimple_omp_set_body (p
, body
);
972 /* Build a GIMPLE_OMP_TASKGROUP statement.
974 BODY is the sequence of statements to be executed by the taskgroup
978 gimple_build_omp_taskgroup (gimple_seq body
)
980 gimple
*p
= gimple_alloc (GIMPLE_OMP_TASKGROUP
, 0);
982 gimple_omp_set_body (p
, body
);
988 /* Build a GIMPLE_OMP_CONTINUE statement.
990 CONTROL_DEF is the definition of the control variable.
991 CONTROL_USE is the use of the control variable. */
994 gimple_build_omp_continue (tree control_def
, tree control_use
)
997 = as_a
<gomp_continue
*> (gimple_alloc (GIMPLE_OMP_CONTINUE
, 0));
998 gimple_omp_continue_set_control_def (p
, control_def
);
999 gimple_omp_continue_set_control_use (p
, control_use
);
1003 /* Build a GIMPLE_OMP_ORDERED statement.
1005 BODY is the sequence of statements inside a loop that will executed in
1007 CLAUSES are clauses for this statement. */
1010 gimple_build_omp_ordered (gimple_seq body
, tree clauses
)
1013 = as_a
<gomp_ordered
*> (gimple_alloc (GIMPLE_OMP_ORDERED
, 0));
1014 gimple_omp_ordered_set_clauses (p
, clauses
);
1016 gimple_omp_set_body (p
, body
);
1022 /* Build a GIMPLE_OMP_RETURN statement.
1023 WAIT_P is true if this is a non-waiting return. */
1026 gimple_build_omp_return (bool wait_p
)
1028 gimple
*p
= gimple_alloc (GIMPLE_OMP_RETURN
, 0);
1030 gimple_omp_return_set_nowait (p
);
1036 /* Build a GIMPLE_OMP_SECTIONS statement.
1038 BODY is a sequence of section statements.
1039 CLAUSES are any of the OMP sections contsruct's clauses: private,
1040 firstprivate, lastprivate, reduction, and nowait. */
1043 gimple_build_omp_sections (gimple_seq body
, tree clauses
)
1046 = as_a
<gomp_sections
*> (gimple_alloc (GIMPLE_OMP_SECTIONS
, 0));
1048 gimple_omp_set_body (p
, body
);
1049 gimple_omp_sections_set_clauses (p
, clauses
);
1055 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1058 gimple_build_omp_sections_switch (void)
1060 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH
, 0);
1064 /* Build a GIMPLE_OMP_SINGLE statement.
1066 BODY is the sequence of statements that will be executed once.
1067 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1068 copyprivate, nowait. */
1071 gimple_build_omp_single (gimple_seq body
, tree clauses
)
1074 = as_a
<gomp_single
*> (gimple_alloc (GIMPLE_OMP_SINGLE
, 0));
1076 gimple_omp_set_body (p
, body
);
1077 gimple_omp_single_set_clauses (p
, clauses
);
1083 /* Build a GIMPLE_OMP_TARGET statement.
1085 BODY is the sequence of statements that will be executed.
1086 KIND is the kind of the region.
1087 CLAUSES are any of the construct's clauses. */
1090 gimple_build_omp_target (gimple_seq body
, int kind
, tree clauses
)
1093 = as_a
<gomp_target
*> (gimple_alloc (GIMPLE_OMP_TARGET
, 0));
1095 gimple_omp_set_body (p
, body
);
1096 gimple_omp_target_set_clauses (p
, clauses
);
1097 gimple_omp_target_set_kind (p
, kind
);
1103 /* Build a GIMPLE_OMP_TEAMS statement.
1105 BODY is the sequence of statements that will be executed.
1106 CLAUSES are any of the OMP teams construct's clauses. */
1109 gimple_build_omp_teams (gimple_seq body
, tree clauses
)
1111 gomp_teams
*p
= as_a
<gomp_teams
*> (gimple_alloc (GIMPLE_OMP_TEAMS
, 0));
1113 gimple_omp_set_body (p
, body
);
1114 gimple_omp_teams_set_clauses (p
, clauses
);
1120 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1123 gimple_build_omp_atomic_load (tree lhs
, tree rhs
)
1126 = as_a
<gomp_atomic_load
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD
, 0));
1127 gimple_omp_atomic_load_set_lhs (p
, lhs
);
1128 gimple_omp_atomic_load_set_rhs (p
, rhs
);
1132 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1134 VAL is the value we are storing. */
1137 gimple_build_omp_atomic_store (tree val
)
1139 gomp_atomic_store
*p
1140 = as_a
<gomp_atomic_store
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE
, 0));
1141 gimple_omp_atomic_store_set_val (p
, val
);
1145 /* Build a GIMPLE_TRANSACTION statement. */
1148 gimple_build_transaction (gimple_seq body
)
1151 = as_a
<gtransaction
*> (gimple_alloc (GIMPLE_TRANSACTION
, 0));
1152 gimple_transaction_set_body (p
, body
);
1153 gimple_transaction_set_label_norm (p
, 0);
1154 gimple_transaction_set_label_uninst (p
, 0);
1155 gimple_transaction_set_label_over (p
, 0);
1159 #if defined ENABLE_GIMPLE_CHECKING
1160 /* Complain of a gimple type mismatch and die. */
1163 gimple_check_failed (const gimple
*gs
, const char *file
, int line
,
1164 const char *function
, enum gimple_code code
,
1165 enum tree_code subcode
)
1167 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1168 gimple_code_name
[code
],
1169 get_tree_code_name (subcode
),
1170 gimple_code_name
[gimple_code (gs
)],
1172 ? get_tree_code_name ((enum tree_code
) gs
->subcode
)
1174 function
, trim_filename (file
), line
);
1176 #endif /* ENABLE_GIMPLE_CHECKING */
1179 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1180 *SEQ_P is NULL, a new sequence is allocated. */
1183 gimple_seq_add_stmt (gimple_seq
*seq_p
, gimple
*gs
)
1185 gimple_stmt_iterator si
;
1189 si
= gsi_last (*seq_p
);
1190 gsi_insert_after (&si
, gs
, GSI_NEW_STMT
);
1193 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1194 *SEQ_P is NULL, a new sequence is allocated. This function is
1195 similar to gimple_seq_add_stmt, but does not scan the operands.
1196 During gimplification, we need to manipulate statement sequences
1197 before the def/use vectors have been constructed. */
1200 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple
*gs
)
1202 gimple_stmt_iterator si
;
1207 si
= gsi_last (*seq_p
);
1208 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
1211 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1212 NULL, a new sequence is allocated. */
1215 gimple_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
1217 gimple_stmt_iterator si
;
1221 si
= gsi_last (*dst_p
);
1222 gsi_insert_seq_after (&si
, src
, GSI_NEW_STMT
);
1225 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1226 NULL, a new sequence is allocated. This function is
1227 similar to gimple_seq_add_seq, but does not scan the operands. */
1230 gimple_seq_add_seq_without_update (gimple_seq
*dst_p
, gimple_seq src
)
1232 gimple_stmt_iterator si
;
1236 si
= gsi_last (*dst_p
);
1237 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
1240 /* Determine whether to assign a location to the statement GS. */
1243 should_carry_location_p (gimple
*gs
)
1245 /* Don't emit a line note for a label. We particularly don't want to
1246 emit one for the break label, since it doesn't actually correspond
1247 to the beginning of the loop/switch. */
1248 if (gimple_code (gs
) == GIMPLE_LABEL
)
1254 /* Set the location for gimple statement GS to LOCATION. */
1257 annotate_one_with_location (gimple
*gs
, location_t location
)
1259 if (!gimple_has_location (gs
)
1260 && !gimple_do_not_emit_location_p (gs
)
1261 && should_carry_location_p (gs
))
1262 gimple_set_location (gs
, location
);
1265 /* Set LOCATION for all the statements after iterator GSI in sequence
1266 SEQ. If GSI is pointing to the end of the sequence, start with the
1267 first statement in SEQ. */
1270 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
1271 location_t location
)
1273 if (gsi_end_p (gsi
))
1274 gsi
= gsi_start (seq
);
1278 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
1279 annotate_one_with_location (gsi_stmt (gsi
), location
);
1282 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1285 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
1287 gimple_stmt_iterator i
;
1289 if (gimple_seq_empty_p (stmt_p
))
1292 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
1294 gimple
*gs
= gsi_stmt (i
);
1295 annotate_one_with_location (gs
, location
);
1299 /* Helper function of empty_body_p. Return true if STMT is an empty
1303 empty_stmt_p (gimple
*stmt
)
1305 if (gimple_code (stmt
) == GIMPLE_NOP
)
1307 if (gbind
*bind_stmt
= dyn_cast
<gbind
*> (stmt
))
1308 return empty_body_p (gimple_bind_body (bind_stmt
));
1313 /* Return true if BODY contains nothing but empty statements. */
1316 empty_body_p (gimple_seq body
)
1318 gimple_stmt_iterator i
;
1320 if (gimple_seq_empty_p (body
))
1322 for (i
= gsi_start (body
); !gsi_end_p (i
); gsi_next (&i
))
1323 if (!empty_stmt_p (gsi_stmt (i
))
1324 && !is_gimple_debug (gsi_stmt (i
)))
1331 /* Perform a deep copy of sequence SRC and return the result. */
1334 gimple_seq_copy (gimple_seq src
)
1336 gimple_stmt_iterator gsi
;
1337 gimple_seq new_seq
= NULL
;
1340 for (gsi
= gsi_start (src
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1342 stmt
= gimple_copy (gsi_stmt (gsi
));
1343 gimple_seq_add_stmt (&new_seq
, stmt
);
1351 /* Return true if calls C1 and C2 are known to go to the same function. */
1354 gimple_call_same_target_p (const gimple
*c1
, const gimple
*c2
)
1356 if (gimple_call_internal_p (c1
))
1357 return (gimple_call_internal_p (c2
)
1358 && gimple_call_internal_fn (c1
) == gimple_call_internal_fn (c2
)
1359 && (!gimple_call_internal_unique_p (as_a
<const gcall
*> (c1
))
1362 return (gimple_call_fn (c1
) == gimple_call_fn (c2
)
1363 || (gimple_call_fndecl (c1
)
1364 && gimple_call_fndecl (c1
) == gimple_call_fndecl (c2
)));
1367 /* Detect flags from a GIMPLE_CALL. This is just like
1368 call_expr_flags, but for gimple tuples. */
1371 gimple_call_flags (const gimple
*stmt
)
1374 tree decl
= gimple_call_fndecl (stmt
);
1377 flags
= flags_from_decl_or_type (decl
);
1378 else if (gimple_call_internal_p (stmt
))
1379 flags
= internal_fn_flags (gimple_call_internal_fn (stmt
));
1381 flags
= flags_from_decl_or_type (gimple_call_fntype (stmt
));
1383 if (stmt
->subcode
& GF_CALL_NOTHROW
)
1384 flags
|= ECF_NOTHROW
;
1389 /* Return the "fn spec" string for call STMT. */
1392 gimple_call_fnspec (const gcall
*stmt
)
1396 if (gimple_call_internal_p (stmt
))
1397 return internal_fn_fnspec (gimple_call_internal_fn (stmt
));
1399 type
= gimple_call_fntype (stmt
);
1403 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
1407 return TREE_VALUE (TREE_VALUE (attr
));
1410 /* Detects argument flags for argument number ARG on call STMT. */
1413 gimple_call_arg_flags (const gcall
*stmt
, unsigned arg
)
1415 const_tree attr
= gimple_call_fnspec (stmt
);
1417 if (!attr
|| 1 + arg
>= (unsigned) TREE_STRING_LENGTH (attr
))
1420 switch (TREE_STRING_POINTER (attr
)[1 + arg
])
1427 return EAF_DIRECT
| EAF_NOCLOBBER
| EAF_NOESCAPE
;
1430 return EAF_NOCLOBBER
| EAF_NOESCAPE
;
1433 return EAF_DIRECT
| EAF_NOESCAPE
;
1436 return EAF_NOESCAPE
;
1444 /* Detects return flags for the call STMT. */
1447 gimple_call_return_flags (const gcall
*stmt
)
1451 if (gimple_call_flags (stmt
) & ECF_MALLOC
)
1454 attr
= gimple_call_fnspec (stmt
);
1455 if (!attr
|| TREE_STRING_LENGTH (attr
) < 1)
1458 switch (TREE_STRING_POINTER (attr
)[0])
1464 return ERF_RETURNS_ARG
| (TREE_STRING_POINTER (attr
)[0] - '1');
1476 /* Return true if GS is a copy assignment. */
1479 gimple_assign_copy_p (gimple
*gs
)
1481 return (gimple_assign_single_p (gs
)
1482 && is_gimple_val (gimple_op (gs
, 1)));
1486 /* Return true if GS is a SSA_NAME copy assignment. */
1489 gimple_assign_ssa_name_copy_p (gimple
*gs
)
1491 return (gimple_assign_single_p (gs
)
1492 && TREE_CODE (gimple_assign_lhs (gs
)) == SSA_NAME
1493 && TREE_CODE (gimple_assign_rhs1 (gs
)) == SSA_NAME
);
1497 /* Return true if GS is an assignment with a unary RHS, but the
1498 operator has no effect on the assigned value. The logic is adapted
1499 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1500 instances in which STRIP_NOPS was previously applied to the RHS of
1503 NOTE: In the use cases that led to the creation of this function
1504 and of gimple_assign_single_p, it is typical to test for either
1505 condition and to proceed in the same manner. In each case, the
1506 assigned value is represented by the single RHS operand of the
1507 assignment. I suspect there may be cases where gimple_assign_copy_p,
1508 gimple_assign_single_p, or equivalent logic is used where a similar
1509 treatment of unary NOPs is appropriate. */
1512 gimple_assign_unary_nop_p (gimple
*gs
)
1514 return (is_gimple_assign (gs
)
1515 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs
))
1516 || gimple_assign_rhs_code (gs
) == NON_LVALUE_EXPR
)
1517 && gimple_assign_rhs1 (gs
) != error_mark_node
1518 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs
)))
1519 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs
)))));
1522 /* Set BB to be the basic block holding G. */
1525 gimple_set_bb (gimple
*stmt
, basic_block bb
)
1529 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1532 /* If the statement is a label, add the label to block-to-labels map
1533 so that we can speed up edge creation for GIMPLE_GOTOs. */
1539 t
= gimple_label_label (as_a
<glabel
*> (stmt
));
1540 uid
= LABEL_DECL_UID (t
);
1544 vec_safe_length (label_to_block_map_for_fn (cfun
));
1545 LABEL_DECL_UID (t
) = uid
= cfun
->cfg
->last_label_uid
++;
1546 if (old_len
<= (unsigned) uid
)
1548 unsigned new_len
= 3 * uid
/ 2 + 1;
1550 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun
),
1555 (*label_to_block_map_for_fn (cfun
))[uid
] = bb
;
1560 /* Modify the RHS of the assignment pointed-to by GSI using the
1561 operands in the expression tree EXPR.
1563 NOTE: The statement pointed-to by GSI may be reallocated if it
1564 did not have enough operand slots.
1566 This function is useful to convert an existing tree expression into
1567 the flat representation used for the RHS of a GIMPLE assignment.
1568 It will reallocate memory as needed to expand or shrink the number
1569 of operand slots needed to represent EXPR.
1571 NOTE: If you find yourself building a tree and then calling this
1572 function, you are most certainly doing it the slow way. It is much
1573 better to build a new assignment or to use the function
1574 gimple_assign_set_rhs_with_ops, which does not require an
1575 expression tree to be built. */
1578 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*gsi
, tree expr
)
1580 enum tree_code subcode
;
1583 extract_ops_from_tree (expr
, &subcode
, &op1
, &op2
, &op3
);
1584 gimple_assign_set_rhs_with_ops (gsi
, subcode
, op1
, op2
, op3
);
1588 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1589 operands OP1, OP2 and OP3.
1591 NOTE: The statement pointed-to by GSI may be reallocated if it
1592 did not have enough operand slots. */
1595 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*gsi
, enum tree_code code
,
1596 tree op1
, tree op2
, tree op3
)
1598 unsigned new_rhs_ops
= get_gimple_rhs_num_ops (code
);
1599 gimple
*stmt
= gsi_stmt (*gsi
);
1601 /* If the new CODE needs more operands, allocate a new statement. */
1602 if (gimple_num_ops (stmt
) < new_rhs_ops
+ 1)
1604 tree lhs
= gimple_assign_lhs (stmt
);
1605 gimple
*new_stmt
= gimple_alloc (gimple_code (stmt
), new_rhs_ops
+ 1);
1606 memcpy (new_stmt
, stmt
, gimple_size (gimple_code (stmt
)));
1607 gimple_init_singleton (new_stmt
);
1608 gsi_replace (gsi
, new_stmt
, true);
1611 /* The LHS needs to be reset as this also changes the SSA name
1613 gimple_assign_set_lhs (stmt
, lhs
);
1616 gimple_set_num_ops (stmt
, new_rhs_ops
+ 1);
1617 gimple_set_subcode (stmt
, code
);
1618 gimple_assign_set_rhs1 (stmt
, op1
);
1619 if (new_rhs_ops
> 1)
1620 gimple_assign_set_rhs2 (stmt
, op2
);
1621 if (new_rhs_ops
> 2)
1622 gimple_assign_set_rhs3 (stmt
, op3
);
1626 /* Return the LHS of a statement that performs an assignment,
1627 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1628 for a call to a function that returns no value, or for a
1629 statement other than an assignment or a call. */
1632 gimple_get_lhs (const gimple
*stmt
)
1634 enum gimple_code code
= gimple_code (stmt
);
1636 if (code
== GIMPLE_ASSIGN
)
1637 return gimple_assign_lhs (stmt
);
1638 else if (code
== GIMPLE_CALL
)
1639 return gimple_call_lhs (stmt
);
1645 /* Set the LHS of a statement that performs an assignment,
1646 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1649 gimple_set_lhs (gimple
*stmt
, tree lhs
)
1651 enum gimple_code code
= gimple_code (stmt
);
1653 if (code
== GIMPLE_ASSIGN
)
1654 gimple_assign_set_lhs (stmt
, lhs
);
1655 else if (code
== GIMPLE_CALL
)
1656 gimple_call_set_lhs (stmt
, lhs
);
1662 /* Return a deep copy of statement STMT. All the operands from STMT
1663 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1664 and VUSE operand arrays are set to empty in the new copy. The new
1665 copy isn't part of any sequence. */
1668 gimple_copy (gimple
*stmt
)
1670 enum gimple_code code
= gimple_code (stmt
);
1671 unsigned num_ops
= gimple_num_ops (stmt
);
1672 gimple
*copy
= gimple_alloc (code
, num_ops
);
1675 /* Shallow copy all the fields from STMT. */
1676 memcpy (copy
, stmt
, gimple_size (code
));
1677 gimple_init_singleton (copy
);
1679 /* If STMT has sub-statements, deep-copy them as well. */
1680 if (gimple_has_substatements (stmt
))
1685 switch (gimple_code (stmt
))
1689 gbind
*bind_stmt
= as_a
<gbind
*> (stmt
);
1690 gbind
*bind_copy
= as_a
<gbind
*> (copy
);
1691 new_seq
= gimple_seq_copy (gimple_bind_body (bind_stmt
));
1692 gimple_bind_set_body (bind_copy
, new_seq
);
1693 gimple_bind_set_vars (bind_copy
,
1694 unshare_expr (gimple_bind_vars (bind_stmt
)));
1695 gimple_bind_set_block (bind_copy
, gimple_bind_block (bind_stmt
));
1701 gcatch
*catch_stmt
= as_a
<gcatch
*> (stmt
);
1702 gcatch
*catch_copy
= as_a
<gcatch
*> (copy
);
1703 new_seq
= gimple_seq_copy (gimple_catch_handler (catch_stmt
));
1704 gimple_catch_set_handler (catch_copy
, new_seq
);
1705 t
= unshare_expr (gimple_catch_types (catch_stmt
));
1706 gimple_catch_set_types (catch_copy
, t
);
1710 case GIMPLE_EH_FILTER
:
1712 geh_filter
*eh_filter_stmt
= as_a
<geh_filter
*> (stmt
);
1713 geh_filter
*eh_filter_copy
= as_a
<geh_filter
*> (copy
);
1715 = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt
));
1716 gimple_eh_filter_set_failure (eh_filter_copy
, new_seq
);
1717 t
= unshare_expr (gimple_eh_filter_types (eh_filter_stmt
));
1718 gimple_eh_filter_set_types (eh_filter_copy
, t
);
1722 case GIMPLE_EH_ELSE
:
1724 geh_else
*eh_else_stmt
= as_a
<geh_else
*> (stmt
);
1725 geh_else
*eh_else_copy
= as_a
<geh_else
*> (copy
);
1726 new_seq
= gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt
));
1727 gimple_eh_else_set_n_body (eh_else_copy
, new_seq
);
1728 new_seq
= gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt
));
1729 gimple_eh_else_set_e_body (eh_else_copy
, new_seq
);
1735 gtry
*try_stmt
= as_a
<gtry
*> (stmt
);
1736 gtry
*try_copy
= as_a
<gtry
*> (copy
);
1737 new_seq
= gimple_seq_copy (gimple_try_eval (try_stmt
));
1738 gimple_try_set_eval (try_copy
, new_seq
);
1739 new_seq
= gimple_seq_copy (gimple_try_cleanup (try_stmt
));
1740 gimple_try_set_cleanup (try_copy
, new_seq
);
1744 case GIMPLE_OMP_FOR
:
1745 new_seq
= gimple_seq_copy (gimple_omp_for_pre_body (stmt
));
1746 gimple_omp_for_set_pre_body (copy
, new_seq
);
1747 t
= unshare_expr (gimple_omp_for_clauses (stmt
));
1748 gimple_omp_for_set_clauses (copy
, t
);
1750 gomp_for
*omp_for_copy
= as_a
<gomp_for
*> (copy
);
1751 omp_for_copy
->iter
= ggc_vec_alloc
<gimple_omp_for_iter
>
1752 ( gimple_omp_for_collapse (stmt
));
1754 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1756 gimple_omp_for_set_cond (copy
, i
,
1757 gimple_omp_for_cond (stmt
, i
));
1758 gimple_omp_for_set_index (copy
, i
,
1759 gimple_omp_for_index (stmt
, i
));
1760 t
= unshare_expr (gimple_omp_for_initial (stmt
, i
));
1761 gimple_omp_for_set_initial (copy
, i
, t
);
1762 t
= unshare_expr (gimple_omp_for_final (stmt
, i
));
1763 gimple_omp_for_set_final (copy
, i
, t
);
1764 t
= unshare_expr (gimple_omp_for_incr (stmt
, i
));
1765 gimple_omp_for_set_incr (copy
, i
, t
);
1769 case GIMPLE_OMP_PARALLEL
:
1771 gomp_parallel
*omp_par_stmt
= as_a
<gomp_parallel
*> (stmt
);
1772 gomp_parallel
*omp_par_copy
= as_a
<gomp_parallel
*> (copy
);
1773 t
= unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt
));
1774 gimple_omp_parallel_set_clauses (omp_par_copy
, t
);
1775 t
= unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt
));
1776 gimple_omp_parallel_set_child_fn (omp_par_copy
, t
);
1777 t
= unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt
));
1778 gimple_omp_parallel_set_data_arg (omp_par_copy
, t
);
1782 case GIMPLE_OMP_TASK
:
1783 t
= unshare_expr (gimple_omp_task_clauses (stmt
));
1784 gimple_omp_task_set_clauses (copy
, t
);
1785 t
= unshare_expr (gimple_omp_task_child_fn (stmt
));
1786 gimple_omp_task_set_child_fn (copy
, t
);
1787 t
= unshare_expr (gimple_omp_task_data_arg (stmt
));
1788 gimple_omp_task_set_data_arg (copy
, t
);
1789 t
= unshare_expr (gimple_omp_task_copy_fn (stmt
));
1790 gimple_omp_task_set_copy_fn (copy
, t
);
1791 t
= unshare_expr (gimple_omp_task_arg_size (stmt
));
1792 gimple_omp_task_set_arg_size (copy
, t
);
1793 t
= unshare_expr (gimple_omp_task_arg_align (stmt
));
1794 gimple_omp_task_set_arg_align (copy
, t
);
1797 case GIMPLE_OMP_CRITICAL
:
1798 t
= unshare_expr (gimple_omp_critical_name
1799 (as_a
<gomp_critical
*> (stmt
)));
1800 gimple_omp_critical_set_name (as_a
<gomp_critical
*> (copy
), t
);
1801 t
= unshare_expr (gimple_omp_critical_clauses
1802 (as_a
<gomp_critical
*> (stmt
)));
1803 gimple_omp_critical_set_clauses (as_a
<gomp_critical
*> (copy
), t
);
1806 case GIMPLE_OMP_ORDERED
:
1807 t
= unshare_expr (gimple_omp_ordered_clauses
1808 (as_a
<gomp_ordered
*> (stmt
)));
1809 gimple_omp_ordered_set_clauses (as_a
<gomp_ordered
*> (copy
), t
);
1812 case GIMPLE_OMP_SECTIONS
:
1813 t
= unshare_expr (gimple_omp_sections_clauses (stmt
));
1814 gimple_omp_sections_set_clauses (copy
, t
);
1815 t
= unshare_expr (gimple_omp_sections_control (stmt
));
1816 gimple_omp_sections_set_control (copy
, t
);
1819 case GIMPLE_OMP_SINGLE
:
1820 case GIMPLE_OMP_TARGET
:
1821 case GIMPLE_OMP_TEAMS
:
1822 case GIMPLE_OMP_SECTION
:
1823 case GIMPLE_OMP_MASTER
:
1824 case GIMPLE_OMP_TASKGROUP
:
1825 case GIMPLE_OMP_GRID_BODY
:
1827 new_seq
= gimple_seq_copy (gimple_omp_body (stmt
));
1828 gimple_omp_set_body (copy
, new_seq
);
1831 case GIMPLE_TRANSACTION
:
1832 new_seq
= gimple_seq_copy (gimple_transaction_body (
1833 as_a
<gtransaction
*> (stmt
)));
1834 gimple_transaction_set_body (as_a
<gtransaction
*> (copy
),
1838 case GIMPLE_WITH_CLEANUP_EXPR
:
1839 new_seq
= gimple_seq_copy (gimple_wce_cleanup (stmt
));
1840 gimple_wce_set_cleanup (copy
, new_seq
);
1848 /* Make copy of operands. */
1849 for (i
= 0; i
< num_ops
; i
++)
1850 gimple_set_op (copy
, i
, unshare_expr (gimple_op (stmt
, i
)));
1852 if (gimple_has_mem_ops (stmt
))
1854 gimple_set_vdef (copy
, gimple_vdef (stmt
));
1855 gimple_set_vuse (copy
, gimple_vuse (stmt
));
1858 /* Clear out SSA operand vectors on COPY. */
1859 if (gimple_has_ops (stmt
))
1861 gimple_set_use_ops (copy
, NULL
);
1863 /* SSA operands need to be updated. */
1864 gimple_set_modified (copy
, true);
1871 /* Return true if statement S has side-effects. We consider a
1872 statement to have side effects if:
1874 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
1875 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
1878 gimple_has_side_effects (const gimple
*s
)
1880 if (is_gimple_debug (s
))
1883 /* We don't have to scan the arguments to check for
1884 volatile arguments, though, at present, we still
1885 do a scan to check for TREE_SIDE_EFFECTS. */
1886 if (gimple_has_volatile_ops (s
))
1889 if (gimple_code (s
) == GIMPLE_ASM
1890 && gimple_asm_volatile_p (as_a
<const gasm
*> (s
)))
1893 if (is_gimple_call (s
))
1895 int flags
= gimple_call_flags (s
);
1897 /* An infinite loop is considered a side effect. */
1898 if (!(flags
& (ECF_CONST
| ECF_PURE
))
1899 || (flags
& ECF_LOOPING_CONST_OR_PURE
))
1908 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
1909 Return true if S can trap. When INCLUDE_MEM is true, check whether
1910 the memory operations could trap. When INCLUDE_STORES is true and
1911 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
1914 gimple_could_trap_p_1 (gimple
*s
, bool include_mem
, bool include_stores
)
1916 tree t
, div
= NULL_TREE
;
1921 unsigned i
, start
= (is_gimple_assign (s
) && !include_stores
) ? 1 : 0;
1923 for (i
= start
; i
< gimple_num_ops (s
); i
++)
1924 if (tree_could_trap_p (gimple_op (s
, i
)))
1928 switch (gimple_code (s
))
1931 return gimple_asm_volatile_p (as_a
<gasm
*> (s
));
1934 t
= gimple_call_fndecl (s
);
1935 /* Assume that calls to weak functions may trap. */
1936 if (!t
|| !DECL_P (t
) || DECL_WEAK (t
))
1941 t
= gimple_expr_type (s
);
1942 op
= gimple_assign_rhs_code (s
);
1943 if (get_gimple_rhs_class (op
) == GIMPLE_BINARY_RHS
)
1944 div
= gimple_assign_rhs2 (s
);
1945 return (operation_could_trap_p (op
, FLOAT_TYPE_P (t
),
1946 (INTEGRAL_TYPE_P (t
)
1947 && TYPE_OVERFLOW_TRAPS (t
)),
1951 t
= TREE_TYPE (gimple_cond_lhs (s
));
1952 return operation_could_trap_p (gimple_cond_code (s
),
1953 FLOAT_TYPE_P (t
), false, NULL_TREE
);
1962 /* Return true if statement S can trap. */
1965 gimple_could_trap_p (gimple
*s
)
1967 return gimple_could_trap_p_1 (s
, true, true);
1970 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
1973 gimple_assign_rhs_could_trap_p (gimple
*s
)
1975 gcc_assert (is_gimple_assign (s
));
1976 return gimple_could_trap_p_1 (s
, true, false);
1980 /* Print debugging information for gimple stmts generated. */
1983 dump_gimple_statistics (void)
1985 int i
, total_tuples
= 0, total_bytes
= 0;
1987 if (! GATHER_STATISTICS
)
1989 fprintf (stderr
, "No gimple statistics\n");
1993 fprintf (stderr
, "\nGIMPLE statements\n");
1994 fprintf (stderr
, "Kind Stmts Bytes\n");
1995 fprintf (stderr
, "---------------------------------------\n");
1996 for (i
= 0; i
< (int) gimple_alloc_kind_all
; ++i
)
1998 fprintf (stderr
, "%-20s %7d %10d\n", gimple_alloc_kind_names
[i
],
1999 gimple_alloc_counts
[i
], gimple_alloc_sizes
[i
]);
2000 total_tuples
+= gimple_alloc_counts
[i
];
2001 total_bytes
+= gimple_alloc_sizes
[i
];
2003 fprintf (stderr
, "---------------------------------------\n");
2004 fprintf (stderr
, "%-20s %7d %10d\n", "Total", total_tuples
, total_bytes
);
2005 fprintf (stderr
, "---------------------------------------\n");
2009 /* Return the number of operands needed on the RHS of a GIMPLE
2010 assignment for an expression with tree code CODE. */
2013 get_gimple_rhs_num_ops (enum tree_code code
)
2015 enum gimple_rhs_class rhs_class
= get_gimple_rhs_class (code
);
2017 if (rhs_class
== GIMPLE_UNARY_RHS
|| rhs_class
== GIMPLE_SINGLE_RHS
)
2019 else if (rhs_class
== GIMPLE_BINARY_RHS
)
2021 else if (rhs_class
== GIMPLE_TERNARY_RHS
)
2027 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2029 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2030 : ((TYPE) == tcc_binary \
2031 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2032 : ((TYPE) == tcc_constant \
2033 || (TYPE) == tcc_declaration \
2034 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2035 : ((SYM) == TRUTH_AND_EXPR \
2036 || (SYM) == TRUTH_OR_EXPR \
2037 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2038 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2039 : ((SYM) == COND_EXPR \
2040 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2041 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2042 || (SYM) == DOT_PROD_EXPR \
2043 || (SYM) == SAD_EXPR \
2044 || (SYM) == REALIGN_LOAD_EXPR \
2045 || (SYM) == VEC_COND_EXPR \
2046 || (SYM) == VEC_PERM_EXPR \
2047 || (SYM) == BIT_INSERT_EXPR \
2048 || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS \
2049 : ((SYM) == CONSTRUCTOR \
2050 || (SYM) == OBJ_TYPE_REF \
2051 || (SYM) == ASSERT_EXPR \
2052 || (SYM) == ADDR_EXPR \
2053 || (SYM) == WITH_SIZE_EXPR \
2054 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2055 : GIMPLE_INVALID_RHS),
2056 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2058 const unsigned char gimple_rhs_class_table
[] = {
2059 #include "all-tree.def"
2063 #undef END_OF_BASE_TREE_CODES
2065 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2066 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2067 we failed to create one. */
2070 canonicalize_cond_expr_cond (tree t
)
2072 /* Strip conversions around boolean operations. */
2073 if (CONVERT_EXPR_P (t
)
2074 && (truth_value_p (TREE_CODE (TREE_OPERAND (t
, 0)))
2075 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
2077 t
= TREE_OPERAND (t
, 0);
2079 /* For !x use x == 0. */
2080 if (TREE_CODE (t
) == TRUTH_NOT_EXPR
)
2082 tree top0
= TREE_OPERAND (t
, 0);
2083 t
= build2 (EQ_EXPR
, TREE_TYPE (t
),
2084 top0
, build_int_cst (TREE_TYPE (top0
), 0));
2086 /* For cmp ? 1 : 0 use cmp. */
2087 else if (TREE_CODE (t
) == COND_EXPR
2088 && COMPARISON_CLASS_P (TREE_OPERAND (t
, 0))
2089 && integer_onep (TREE_OPERAND (t
, 1))
2090 && integer_zerop (TREE_OPERAND (t
, 2)))
2092 tree top0
= TREE_OPERAND (t
, 0);
2093 t
= build2 (TREE_CODE (top0
), TREE_TYPE (t
),
2094 TREE_OPERAND (top0
, 0), TREE_OPERAND (top0
, 1));
2096 /* For x ^ y use x != y. */
2097 else if (TREE_CODE (t
) == BIT_XOR_EXPR
)
2098 t
= build2 (NE_EXPR
, TREE_TYPE (t
),
2099 TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1));
2101 if (is_gimple_condexpr (t
))
2107 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2108 the positions marked by the set ARGS_TO_SKIP. */
2111 gimple_call_copy_skip_args (gcall
*stmt
, bitmap args_to_skip
)
2114 int nargs
= gimple_call_num_args (stmt
);
2115 auto_vec
<tree
> vargs (nargs
);
2118 for (i
= 0; i
< nargs
; i
++)
2119 if (!bitmap_bit_p (args_to_skip
, i
))
2120 vargs
.quick_push (gimple_call_arg (stmt
, i
));
2122 if (gimple_call_internal_p (stmt
))
2123 new_stmt
= gimple_build_call_internal_vec (gimple_call_internal_fn (stmt
),
2126 new_stmt
= gimple_build_call_vec (gimple_call_fn (stmt
), vargs
);
2128 if (gimple_call_lhs (stmt
))
2129 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2131 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2132 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
2134 if (gimple_has_location (stmt
))
2135 gimple_set_location (new_stmt
, gimple_location (stmt
));
2136 gimple_call_copy_flags (new_stmt
, stmt
);
2137 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2139 gimple_set_modified (new_stmt
, true);
2146 /* Return true if the field decls F1 and F2 are at the same offset.
2148 This is intended to be used on GIMPLE types only. */
2151 gimple_compare_field_offset (tree f1
, tree f2
)
2153 if (DECL_OFFSET_ALIGN (f1
) == DECL_OFFSET_ALIGN (f2
))
2155 tree offset1
= DECL_FIELD_OFFSET (f1
);
2156 tree offset2
= DECL_FIELD_OFFSET (f2
);
2157 return ((offset1
== offset2
2158 /* Once gimplification is done, self-referential offsets are
2159 instantiated as operand #2 of the COMPONENT_REF built for
2160 each access and reset. Therefore, they are not relevant
2161 anymore and fields are interchangeable provided that they
2162 represent the same access. */
2163 || (TREE_CODE (offset1
) == PLACEHOLDER_EXPR
2164 && TREE_CODE (offset2
) == PLACEHOLDER_EXPR
2165 && (DECL_SIZE (f1
) == DECL_SIZE (f2
)
2166 || (TREE_CODE (DECL_SIZE (f1
)) == PLACEHOLDER_EXPR
2167 && TREE_CODE (DECL_SIZE (f2
)) == PLACEHOLDER_EXPR
)
2168 || operand_equal_p (DECL_SIZE (f1
), DECL_SIZE (f2
), 0))
2169 && DECL_ALIGN (f1
) == DECL_ALIGN (f2
))
2170 || operand_equal_p (offset1
, offset2
, 0))
2171 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1
),
2172 DECL_FIELD_BIT_OFFSET (f2
)));
2175 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2176 should be, so handle differing ones specially by decomposing
2177 the offset into a byte and bit offset manually. */
2178 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1
))
2179 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2
)))
2181 unsigned HOST_WIDE_INT byte_offset1
, byte_offset2
;
2182 unsigned HOST_WIDE_INT bit_offset1
, bit_offset2
;
2183 bit_offset1
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1
));
2184 byte_offset1
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1
))
2185 + bit_offset1
/ BITS_PER_UNIT
);
2186 bit_offset2
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2
));
2187 byte_offset2
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2
))
2188 + bit_offset2
/ BITS_PER_UNIT
);
2189 if (byte_offset1
!= byte_offset2
)
2191 return bit_offset1
% BITS_PER_UNIT
== bit_offset2
% BITS_PER_UNIT
;
2198 /* Return a type the same as TYPE except unsigned or
2199 signed according to UNSIGNEDP. */
2202 gimple_signed_or_unsigned_type (bool unsignedp
, tree type
)
2207 type1
= TYPE_MAIN_VARIANT (type
);
2208 if (type1
== signed_char_type_node
2209 || type1
== char_type_node
2210 || type1
== unsigned_char_type_node
)
2211 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2212 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2213 return unsignedp
? unsigned_type_node
: integer_type_node
;
2214 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2215 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2216 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2217 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2218 if (type1
== long_long_integer_type_node
2219 || type1
== long_long_unsigned_type_node
)
2221 ? long_long_unsigned_type_node
2222 : long_long_integer_type_node
;
2224 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2225 if (int_n_enabled_p
[i
]
2226 && (type1
== int_n_trees
[i
].unsigned_type
2227 || type1
== int_n_trees
[i
].signed_type
))
2229 ? int_n_trees
[i
].unsigned_type
2230 : int_n_trees
[i
].signed_type
;
2232 #if HOST_BITS_PER_WIDE_INT >= 64
2233 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2234 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2236 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2237 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2238 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2239 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2240 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2241 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2242 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2243 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2245 #define GIMPLE_FIXED_TYPES(NAME) \
2246 if (type1 == short_ ## NAME ## _type_node \
2247 || type1 == unsigned_short_ ## NAME ## _type_node) \
2248 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2249 : short_ ## NAME ## _type_node; \
2250 if (type1 == NAME ## _type_node \
2251 || type1 == unsigned_ ## NAME ## _type_node) \
2252 return unsignedp ? unsigned_ ## NAME ## _type_node \
2253 : NAME ## _type_node; \
2254 if (type1 == long_ ## NAME ## _type_node \
2255 || type1 == unsigned_long_ ## NAME ## _type_node) \
2256 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2257 : long_ ## NAME ## _type_node; \
2258 if (type1 == long_long_ ## NAME ## _type_node \
2259 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2260 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2261 : long_long_ ## NAME ## _type_node;
2263 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2264 if (type1 == NAME ## _type_node \
2265 || type1 == u ## NAME ## _type_node) \
2266 return unsignedp ? u ## NAME ## _type_node \
2267 : NAME ## _type_node;
2269 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2270 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2271 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2272 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2273 : sat_ ## short_ ## NAME ## _type_node; \
2274 if (type1 == sat_ ## NAME ## _type_node \
2275 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2276 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2277 : sat_ ## NAME ## _type_node; \
2278 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2279 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2280 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2281 : sat_ ## long_ ## NAME ## _type_node; \
2282 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2283 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2284 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2285 : sat_ ## long_long_ ## NAME ## _type_node;
2287 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2288 if (type1 == sat_ ## NAME ## _type_node \
2289 || type1 == sat_ ## u ## NAME ## _type_node) \
2290 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2291 : sat_ ## NAME ## _type_node;
2293 GIMPLE_FIXED_TYPES (fract
);
2294 GIMPLE_FIXED_TYPES_SAT (fract
);
2295 GIMPLE_FIXED_TYPES (accum
);
2296 GIMPLE_FIXED_TYPES_SAT (accum
);
2298 GIMPLE_FIXED_MODE_TYPES (qq
);
2299 GIMPLE_FIXED_MODE_TYPES (hq
);
2300 GIMPLE_FIXED_MODE_TYPES (sq
);
2301 GIMPLE_FIXED_MODE_TYPES (dq
);
2302 GIMPLE_FIXED_MODE_TYPES (tq
);
2303 GIMPLE_FIXED_MODE_TYPES_SAT (qq
);
2304 GIMPLE_FIXED_MODE_TYPES_SAT (hq
);
2305 GIMPLE_FIXED_MODE_TYPES_SAT (sq
);
2306 GIMPLE_FIXED_MODE_TYPES_SAT (dq
);
2307 GIMPLE_FIXED_MODE_TYPES_SAT (tq
);
2308 GIMPLE_FIXED_MODE_TYPES (ha
);
2309 GIMPLE_FIXED_MODE_TYPES (sa
);
2310 GIMPLE_FIXED_MODE_TYPES (da
);
2311 GIMPLE_FIXED_MODE_TYPES (ta
);
2312 GIMPLE_FIXED_MODE_TYPES_SAT (ha
);
2313 GIMPLE_FIXED_MODE_TYPES_SAT (sa
);
2314 GIMPLE_FIXED_MODE_TYPES_SAT (da
);
2315 GIMPLE_FIXED_MODE_TYPES_SAT (ta
);
2317 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2318 the precision; they have precision set to match their range, but
2319 may use a wider mode to match an ABI. If we change modes, we may
2320 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2321 the precision as well, so as to yield correct results for
2322 bit-field types. C++ does not have these separate bit-field
2323 types, and producing a signed or unsigned variant of an
2324 ENUMERAL_TYPE may cause other problems as well. */
2325 if (!INTEGRAL_TYPE_P (type
)
2326 || TYPE_UNSIGNED (type
) == unsignedp
)
2329 #define TYPE_OK(node) \
2330 (TYPE_MODE (type) == TYPE_MODE (node) \
2331 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2332 if (TYPE_OK (signed_char_type_node
))
2333 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2334 if (TYPE_OK (integer_type_node
))
2335 return unsignedp
? unsigned_type_node
: integer_type_node
;
2336 if (TYPE_OK (short_integer_type_node
))
2337 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2338 if (TYPE_OK (long_integer_type_node
))
2339 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2340 if (TYPE_OK (long_long_integer_type_node
))
2342 ? long_long_unsigned_type_node
2343 : long_long_integer_type_node
);
2345 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2346 if (int_n_enabled_p
[i
]
2347 && TYPE_MODE (type
) == int_n_data
[i
].m
2348 && TYPE_PRECISION (type
) == int_n_data
[i
].bitsize
)
2350 ? int_n_trees
[i
].unsigned_type
2351 : int_n_trees
[i
].signed_type
;
2353 #if HOST_BITS_PER_WIDE_INT >= 64
2354 if (TYPE_OK (intTI_type_node
))
2355 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2357 if (TYPE_OK (intDI_type_node
))
2358 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2359 if (TYPE_OK (intSI_type_node
))
2360 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2361 if (TYPE_OK (intHI_type_node
))
2362 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2363 if (TYPE_OK (intQI_type_node
))
2364 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2366 #undef GIMPLE_FIXED_TYPES
2367 #undef GIMPLE_FIXED_MODE_TYPES
2368 #undef GIMPLE_FIXED_TYPES_SAT
2369 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2372 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2376 /* Return an unsigned type the same as TYPE in other respects. */
2379 gimple_unsigned_type (tree type
)
2381 return gimple_signed_or_unsigned_type (true, type
);
2385 /* Return a signed type the same as TYPE in other respects. */
2388 gimple_signed_type (tree type
)
2390 return gimple_signed_or_unsigned_type (false, type
);
2394 /* Return the typed-based alias set for T, which may be an expression
2395 or a type. Return -1 if we don't do anything special. */
2398 gimple_get_alias_set (tree t
)
2402 /* Permit type-punning when accessing a union, provided the access
2403 is directly through the union. For example, this code does not
2404 permit taking the address of a union member and then storing
2405 through it. Even the type-punning allowed here is a GCC
2406 extension, albeit a common and useful one; the C standard says
2407 that such accesses have implementation-defined behavior. */
2409 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2410 u
= TREE_OPERAND (u
, 0))
2411 if (TREE_CODE (u
) == COMPONENT_REF
2412 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2415 /* That's all the expressions we handle specially. */
2419 /* For convenience, follow the C standard when dealing with
2420 character types. Any object may be accessed via an lvalue that
2421 has character type. */
2422 if (t
== char_type_node
2423 || t
== signed_char_type_node
2424 || t
== unsigned_char_type_node
)
2427 /* Allow aliasing between signed and unsigned variants of the same
2428 type. We treat the signed variant as canonical. */
2429 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2431 tree t1
= gimple_signed_type (t
);
2433 /* t1 == t can happen for boolean nodes which are always unsigned. */
2435 return get_alias_set (t1
);
2442 /* Helper for gimple_ior_addresses_taken_1. */
2445 gimple_ior_addresses_taken_1 (gimple
*, tree addr
, tree
, void *data
)
2447 bitmap addresses_taken
= (bitmap
)data
;
2448 addr
= get_base_address (addr
);
2452 bitmap_set_bit (addresses_taken
, DECL_UID (addr
));
2458 /* Set the bit for the uid of all decls that have their address taken
2459 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2460 were any in this stmt. */
2463 gimple_ior_addresses_taken (bitmap addresses_taken
, gimple
*stmt
)
2465 return walk_stmt_load_store_addr_ops (stmt
, addresses_taken
, NULL
, NULL
,
2466 gimple_ior_addresses_taken_1
);
2470 /* Return true when STMTs arguments and return value match those of FNDECL,
2471 a decl of a builtin function. */
2474 gimple_builtin_call_types_compatible_p (const gimple
*stmt
, tree fndecl
)
2476 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
);
2478 tree ret
= gimple_call_lhs (stmt
);
2480 && !useless_type_conversion_p (TREE_TYPE (ret
),
2481 TREE_TYPE (TREE_TYPE (fndecl
))))
2484 tree targs
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2485 unsigned nargs
= gimple_call_num_args (stmt
);
2486 for (unsigned i
= 0; i
< nargs
; ++i
)
2488 /* Variadic args follow. */
2491 tree arg
= gimple_call_arg (stmt
, i
);
2492 tree type
= TREE_VALUE (targs
);
2493 if (!useless_type_conversion_p (type
, TREE_TYPE (arg
))
2494 /* char/short integral arguments are promoted to int
2495 by several frontends if targetm.calls.promote_prototypes
2496 is true. Allow such promotion too. */
2497 && !(INTEGRAL_TYPE_P (type
)
2498 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)
2499 && targetm
.calls
.promote_prototypes (TREE_TYPE (fndecl
))
2500 && useless_type_conversion_p (integer_type_node
,
2503 targs
= TREE_CHAIN (targs
);
2505 if (targs
&& !VOID_TYPE_P (TREE_VALUE (targs
)))
2510 /* Return true when STMT is builtins call. */
2513 gimple_call_builtin_p (const gimple
*stmt
)
2516 if (is_gimple_call (stmt
)
2517 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2518 && DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
)
2519 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2523 /* Return true when STMT is builtins call to CLASS. */
2526 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_class klass
)
2529 if (is_gimple_call (stmt
)
2530 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2531 && DECL_BUILT_IN_CLASS (fndecl
) == klass
)
2532 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2536 /* Return true when STMT is builtins call to CODE of CLASS. */
2539 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_function code
)
2542 if (is_gimple_call (stmt
)
2543 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2544 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
2545 && DECL_FUNCTION_CODE (fndecl
) == code
)
2546 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2550 /* If CALL is a call to a combined_fn (i.e. an internal function or
2551 a normal built-in function), return its code, otherwise return
2555 gimple_call_combined_fn (const gimple
*stmt
)
2557 if (const gcall
*call
= dyn_cast
<const gcall
*> (stmt
))
2559 if (gimple_call_internal_p (call
))
2560 return as_combined_fn (gimple_call_internal_fn (call
));
2562 tree fndecl
= gimple_call_fndecl (stmt
);
2564 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
2565 && gimple_builtin_call_types_compatible_p (stmt
, fndecl
))
2566 return as_combined_fn (DECL_FUNCTION_CODE (fndecl
));
2571 /* Return true if STMT clobbers memory. STMT is required to be a
2575 gimple_asm_clobbers_memory_p (const gasm
*stmt
)
2579 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
2581 tree op
= gimple_asm_clobber_op (stmt
, i
);
2582 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op
)), "memory") == 0)
2589 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2592 dump_decl_set (FILE *file
, bitmap set
)
2599 fprintf (file
, "{ ");
2601 EXECUTE_IF_SET_IN_BITMAP (set
, 0, i
, bi
)
2603 fprintf (file
, "D.%u", i
);
2604 fprintf (file
, " ");
2607 fprintf (file
, "}");
2610 fprintf (file
, "NIL");
2613 /* Return true when CALL is a call stmt that definitely doesn't
2614 free any memory or makes it unavailable otherwise. */
2616 nonfreeing_call_p (gimple
*call
)
2618 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2619 && gimple_call_flags (call
) & ECF_LEAF
)
2620 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call
)))
2622 /* Just in case these become ECF_LEAF in the future. */
2624 case BUILT_IN_TM_FREE
:
2625 case BUILT_IN_REALLOC
:
2626 case BUILT_IN_STACK_RESTORE
:
2631 else if (gimple_call_internal_p (call
))
2632 switch (gimple_call_internal_fn (call
))
2634 case IFN_ABNORMAL_DISPATCHER
:
2637 if (gimple_call_flags (call
) & ECF_LEAF
)
2642 tree fndecl
= gimple_call_fndecl (call
);
2645 struct cgraph_node
*n
= cgraph_node::get (fndecl
);
2648 enum availability availability
;
2649 n
= n
->function_symbol (&availability
);
2650 if (!n
|| availability
<= AVAIL_INTERPOSABLE
)
2652 return n
->nonfreeing_fn
;
2655 /* Return true when CALL is a call stmt that definitely need not
2656 be considered to be a memory barrier. */
2658 nonbarrier_call_p (gimple
*call
)
2660 if (gimple_call_flags (call
) & (ECF_PURE
| ECF_CONST
))
2662 /* Should extend this to have a nonbarrier_fn flag, just as above in
2663 the nonfreeing case. */
2667 /* Callback for walk_stmt_load_store_ops.
2669 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2672 This routine only makes a superficial check for a dereference. Thus
2673 it must only be used if it is safe to return a false negative. */
2675 check_loadstore (gimple
*, tree op
, tree
, void *data
)
2677 if (TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
2679 /* Some address spaces may legitimately dereference zero. */
2680 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (op
));
2681 if (targetm
.addr_space
.zero_address_valid (as
))
2684 return operand_equal_p (TREE_OPERAND (op
, 0), (tree
)data
, 0);
2690 /* Return true if OP can be inferred to be non-NULL after STMT executes,
2691 either by using a pointer dereference or attributes. */
2693 infer_nonnull_range (gimple
*stmt
, tree op
)
2695 return infer_nonnull_range_by_dereference (stmt
, op
)
2696 || infer_nonnull_range_by_attribute (stmt
, op
);
2699 /* Return true if OP can be inferred to be non-NULL after STMT
2700 executes by using a pointer dereference. */
2702 infer_nonnull_range_by_dereference (gimple
*stmt
, tree op
)
2704 /* We can only assume that a pointer dereference will yield
2705 non-NULL if -fdelete-null-pointer-checks is enabled. */
2706 if (!flag_delete_null_pointer_checks
2707 || !POINTER_TYPE_P (TREE_TYPE (op
))
2708 || gimple_code (stmt
) == GIMPLE_ASM
)
2711 if (walk_stmt_load_store_ops (stmt
, (void *)op
,
2712 check_loadstore
, check_loadstore
))
2718 /* Return true if OP can be inferred to be a non-NULL after STMT
2719 executes by using attributes. */
2721 infer_nonnull_range_by_attribute (gimple
*stmt
, tree op
)
2723 /* We can only assume that a pointer dereference will yield
2724 non-NULL if -fdelete-null-pointer-checks is enabled. */
2725 if (!flag_delete_null_pointer_checks
2726 || !POINTER_TYPE_P (TREE_TYPE (op
))
2727 || gimple_code (stmt
) == GIMPLE_ASM
)
2730 if (is_gimple_call (stmt
) && !gimple_call_internal_p (stmt
))
2732 tree fntype
= gimple_call_fntype (stmt
);
2733 tree attrs
= TYPE_ATTRIBUTES (fntype
);
2734 for (; attrs
; attrs
= TREE_CHAIN (attrs
))
2736 attrs
= lookup_attribute ("nonnull", attrs
);
2738 /* If "nonnull" wasn't specified, we know nothing about
2740 if (attrs
== NULL_TREE
)
2743 /* If "nonnull" applies to all the arguments, then ARG
2744 is non-null if it's in the argument list. */
2745 if (TREE_VALUE (attrs
) == NULL_TREE
)
2747 for (unsigned int i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2749 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt
, i
)))
2750 && operand_equal_p (op
, gimple_call_arg (stmt
, i
), 0))
2756 /* Now see if op appears in the nonnull list. */
2757 for (tree t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
2759 unsigned int idx
= TREE_INT_CST_LOW (TREE_VALUE (t
)) - 1;
2760 if (idx
< gimple_call_num_args (stmt
))
2762 tree arg
= gimple_call_arg (stmt
, idx
);
2763 if (operand_equal_p (op
, arg
, 0))
2770 /* If this function is marked as returning non-null, then we can
2771 infer OP is non-null if it is used in the return statement. */
2772 if (greturn
*return_stmt
= dyn_cast
<greturn
*> (stmt
))
2773 if (gimple_return_retval (return_stmt
)
2774 && operand_equal_p (gimple_return_retval (return_stmt
), op
, 0)
2775 && lookup_attribute ("returns_nonnull",
2776 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
))))
2782 /* Compare two case labels. Because the front end should already have
2783 made sure that case ranges do not overlap, it is enough to only compare
2784 the CASE_LOW values of each case label. */
2787 compare_case_labels (const void *p1
, const void *p2
)
2789 const_tree
const case1
= *(const_tree
const*)p1
;
2790 const_tree
const case2
= *(const_tree
const*)p2
;
2792 /* The 'default' case label always goes first. */
2793 if (!CASE_LOW (case1
))
2795 else if (!CASE_LOW (case2
))
2798 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
2801 /* Sort the case labels in LABEL_VEC in place in ascending order. */
2804 sort_case_labels (vec
<tree
> label_vec
)
2806 label_vec
.qsort (compare_case_labels
);
2809 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2811 LABELS is a vector that contains all case labels to look at.
2813 INDEX_TYPE is the type of the switch index expression. Case labels
2814 in LABELS are discarded if their values are not in the value range
2815 covered by INDEX_TYPE. The remaining case label values are folded
2818 If a default case exists in LABELS, it is removed from LABELS and
2819 returned in DEFAULT_CASEP. If no default case exists, but the
2820 case labels already cover the whole range of INDEX_TYPE, a default
2821 case is returned pointing to one of the existing case labels.
2822 Otherwise DEFAULT_CASEP is set to NULL_TREE.
2824 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2825 apply and no action is taken regardless of whether a default case is
2829 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
2831 tree
*default_casep
)
2833 tree min_value
, max_value
;
2834 tree default_case
= NULL_TREE
;
2838 min_value
= TYPE_MIN_VALUE (index_type
);
2839 max_value
= TYPE_MAX_VALUE (index_type
);
2840 while (i
< labels
.length ())
2842 tree elt
= labels
[i
];
2843 tree low
= CASE_LOW (elt
);
2844 tree high
= CASE_HIGH (elt
);
2845 bool remove_element
= FALSE
;
2849 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
2850 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
2852 /* This is a non-default case label, i.e. it has a value.
2854 See if the case label is reachable within the range of
2855 the index type. Remove out-of-range case values. Turn
2856 case ranges into a canonical form (high > low strictly)
2857 and convert the case label values to the index type.
2859 NB: The type of gimple_switch_index() may be the promoted
2860 type, but the case labels retain the original type. */
2864 /* This is a case range. Discard empty ranges.
2865 If the bounds or the range are equal, turn this
2866 into a simple (one-value) case. */
2867 int cmp
= tree_int_cst_compare (high
, low
);
2869 remove_element
= TRUE
;
2876 /* If the simple case value is unreachable, ignore it. */
2877 if ((TREE_CODE (min_value
) == INTEGER_CST
2878 && tree_int_cst_compare (low
, min_value
) < 0)
2879 || (TREE_CODE (max_value
) == INTEGER_CST
2880 && tree_int_cst_compare (low
, max_value
) > 0))
2881 remove_element
= TRUE
;
2883 low
= fold_convert (index_type
, low
);
2887 /* If the entire case range is unreachable, ignore it. */
2888 if ((TREE_CODE (min_value
) == INTEGER_CST
2889 && tree_int_cst_compare (high
, min_value
) < 0)
2890 || (TREE_CODE (max_value
) == INTEGER_CST
2891 && tree_int_cst_compare (low
, max_value
) > 0))
2892 remove_element
= TRUE
;
2895 /* If the lower bound is less than the index type's
2896 minimum value, truncate the range bounds. */
2897 if (TREE_CODE (min_value
) == INTEGER_CST
2898 && tree_int_cst_compare (low
, min_value
) < 0)
2900 low
= fold_convert (index_type
, low
);
2902 /* If the upper bound is greater than the index type's
2903 maximum value, truncate the range bounds. */
2904 if (TREE_CODE (max_value
) == INTEGER_CST
2905 && tree_int_cst_compare (high
, max_value
) > 0)
2907 high
= fold_convert (index_type
, high
);
2909 /* We may have folded a case range to a one-value case. */
2910 if (tree_int_cst_equal (low
, high
))
2915 CASE_LOW (elt
) = low
;
2916 CASE_HIGH (elt
) = high
;
2920 gcc_assert (!default_case
);
2922 /* The default case must be passed separately to the
2923 gimple_build_switch routine. But if DEFAULT_CASEP
2924 is NULL, we do not remove the default case (it would
2925 be completely lost). */
2927 remove_element
= TRUE
;
2931 labels
.ordered_remove (i
);
2937 if (!labels
.is_empty ())
2938 sort_case_labels (labels
);
2940 if (default_casep
&& !default_case
)
2942 /* If the switch has no default label, add one, so that we jump
2943 around the switch body. If the labels already cover the whole
2944 range of the switch index_type, add the default label pointing
2945 to one of the existing labels. */
2947 && TYPE_MIN_VALUE (index_type
)
2948 && TYPE_MAX_VALUE (index_type
)
2949 && tree_int_cst_equal (CASE_LOW (labels
[0]),
2950 TYPE_MIN_VALUE (index_type
)))
2952 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
2954 high
= CASE_LOW (labels
[len
- 1]);
2955 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
2957 for (i
= 1; i
< len
; i
++)
2959 high
= CASE_LOW (labels
[i
]);
2960 low
= CASE_HIGH (labels
[i
- 1]);
2962 low
= CASE_LOW (labels
[i
- 1]);
2963 if (wi::add (low
, 1) != high
)
2968 tree label
= CASE_LABEL (labels
[0]);
2969 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
2977 *default_casep
= default_case
;
2980 /* Set the location of all statements in SEQ to LOC. */
2983 gimple_seq_set_location (gimple_seq seq
, location_t loc
)
2985 for (gimple_stmt_iterator i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
2986 gimple_set_location (gsi_stmt (i
), loc
);
2989 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
2992 gimple_seq_discard (gimple_seq seq
)
2994 gimple_stmt_iterator gsi
;
2996 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); )
2998 gimple
*stmt
= gsi_stmt (gsi
);
2999 gsi_remove (&gsi
, true);
3000 release_defs (stmt
);
3005 /* See if STMT now calls function that takes no parameters and if so, drop
3006 call arguments. This is used when devirtualization machinery redirects
3007 to __builtin_unreachable or __cxa_pure_virtual. */
3010 maybe_remove_unused_call_args (struct function
*fn
, gimple
*stmt
)
3012 tree decl
= gimple_call_fndecl (stmt
);
3013 if (TYPE_ARG_TYPES (TREE_TYPE (decl
))
3014 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
))) == void_type_node
3015 && gimple_call_num_args (stmt
))
3017 gimple_set_num_ops (stmt
, 3);
3018 update_stmt_fn (fn
, stmt
);