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"
42 #include "gimple-pretty-print.h"
45 /* All the tuples have their operand vector (if present) at the very bottom
46 of the structure. Therefore, the offset required to find the
47 operands vector the size of the structure minus the size of the 1
48 element tree array at the end (see gimple_ops). */
49 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
50 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
51 EXPORTED_CONST
size_t gimple_ops_offset_
[] = {
52 #include "gsstruct.def"
56 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
57 static const size_t gsstruct_code_size
[] = {
58 #include "gsstruct.def"
62 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
63 const char *const gimple_code_name
[] = {
68 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
69 EXPORTED_CONST
enum gimple_statement_structure_enum gss_for_code_
[] = {
76 int gimple_alloc_counts
[(int) gimple_alloc_kind_all
];
77 int gimple_alloc_sizes
[(int) gimple_alloc_kind_all
];
79 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
80 static const char * const gimple_alloc_kind_names
[] = {
87 /* Static gimple tuple members. */
88 const enum gimple_code
gassign::code_
;
89 const enum gimple_code
gcall::code_
;
90 const enum gimple_code
gcond::code_
;
93 /* Gimple tuple constructors.
94 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
95 be passed a NULL to start with an empty sequence. */
97 /* Set the code for statement G to CODE. */
100 gimple_set_code (gimple
*g
, enum gimple_code code
)
105 /* Return the number of bytes needed to hold a GIMPLE statement with
109 gimple_size (enum gimple_code code
)
111 return gsstruct_code_size
[gss_for_code (code
)];
114 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
118 gimple_alloc_stat (enum gimple_code code
, unsigned num_ops MEM_STAT_DECL
)
123 size
= gimple_size (code
);
125 size
+= sizeof (tree
) * (num_ops
- 1);
127 if (GATHER_STATISTICS
)
129 enum gimple_alloc_kind kind
= gimple_alloc_kind (code
);
130 gimple_alloc_counts
[(int) kind
]++;
131 gimple_alloc_sizes
[(int) kind
] += size
;
134 stmt
= ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT
);
135 gimple_set_code (stmt
, code
);
136 gimple_set_num_ops (stmt
, num_ops
);
138 /* Do not call gimple_set_modified here as it has other side
139 effects and this tuple is still not completely built. */
141 gimple_init_singleton (stmt
);
146 /* Set SUBCODE to be the code of the expression computed by statement G. */
149 gimple_set_subcode (gimple
*g
, unsigned subcode
)
151 /* We only have 16 bits for the RHS code. Assert that we are not
153 gcc_assert (subcode
< (1 << 16));
154 g
->subcode
= subcode
;
159 /* Build a tuple with operands. CODE is the statement to build (which
160 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
161 for the new tuple. NUM_OPS is the number of operands to allocate. */
163 #define gimple_build_with_ops(c, s, n) \
164 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
167 gimple_build_with_ops_stat (enum gimple_code code
, unsigned subcode
,
168 unsigned num_ops MEM_STAT_DECL
)
170 gimple
*s
= gimple_alloc_stat (code
, num_ops PASS_MEM_STAT
);
171 gimple_set_subcode (s
, subcode
);
177 /* Build a GIMPLE_RETURN statement returning RETVAL. */
180 gimple_build_return (tree retval
)
183 = as_a
<greturn
*> (gimple_build_with_ops (GIMPLE_RETURN
, ERROR_MARK
,
186 gimple_return_set_retval (s
, retval
);
190 /* Reset alias information on call S. */
193 gimple_call_reset_alias_info (gcall
*s
)
195 if (gimple_call_flags (s
) & ECF_CONST
)
196 memset (gimple_call_use_set (s
), 0, sizeof (struct pt_solution
));
198 pt_solution_reset (gimple_call_use_set (s
));
199 if (gimple_call_flags (s
) & (ECF_CONST
|ECF_PURE
|ECF_NOVOPS
))
200 memset (gimple_call_clobber_set (s
), 0, sizeof (struct pt_solution
));
202 pt_solution_reset (gimple_call_clobber_set (s
));
205 /* Helper for gimple_build_call, gimple_build_call_valist,
206 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
207 components of a GIMPLE_CALL statement to function FN with NARGS
210 static inline gcall
*
211 gimple_build_call_1 (tree fn
, unsigned nargs
)
214 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
216 if (TREE_CODE (fn
) == FUNCTION_DECL
)
217 fn
= build_fold_addr_expr (fn
);
218 gimple_set_op (s
, 1, fn
);
219 gimple_call_set_fntype (s
, TREE_TYPE (TREE_TYPE (fn
)));
220 gimple_call_reset_alias_info (s
);
225 /* Build a GIMPLE_CALL statement to function FN with the arguments
226 specified in vector ARGS. */
229 gimple_build_call_vec (tree fn
, vec
<tree
> args
)
232 unsigned nargs
= args
.length ();
233 gcall
*call
= gimple_build_call_1 (fn
, nargs
);
235 for (i
= 0; i
< nargs
; i
++)
236 gimple_call_set_arg (call
, i
, args
[i
]);
242 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
243 arguments. The ... are the arguments. */
246 gimple_build_call (tree fn
, unsigned nargs
, ...)
252 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
254 call
= gimple_build_call_1 (fn
, nargs
);
256 va_start (ap
, nargs
);
257 for (i
= 0; i
< nargs
; i
++)
258 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
265 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
266 arguments. AP contains the arguments. */
269 gimple_build_call_valist (tree fn
, unsigned nargs
, va_list ap
)
274 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
276 call
= gimple_build_call_1 (fn
, nargs
);
278 for (i
= 0; i
< nargs
; i
++)
279 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
285 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
286 Build the basic components of a GIMPLE_CALL statement to internal
287 function FN with NARGS arguments. */
289 static inline gcall
*
290 gimple_build_call_internal_1 (enum internal_fn fn
, unsigned nargs
)
293 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
295 s
->subcode
|= GF_CALL_INTERNAL
;
296 gimple_call_set_internal_fn (s
, fn
);
297 gimple_call_reset_alias_info (s
);
302 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
303 the number of arguments. The ... are the arguments. */
306 gimple_build_call_internal (enum internal_fn fn
, unsigned nargs
, ...)
312 call
= gimple_build_call_internal_1 (fn
, nargs
);
313 va_start (ap
, nargs
);
314 for (i
= 0; i
< nargs
; i
++)
315 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
322 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
323 specified in vector ARGS. */
326 gimple_build_call_internal_vec (enum internal_fn fn
, vec
<tree
> args
)
331 nargs
= args
.length ();
332 call
= gimple_build_call_internal_1 (fn
, nargs
);
333 for (i
= 0; i
< nargs
; i
++)
334 gimple_call_set_arg (call
, i
, args
[i
]);
340 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
341 assumed to be in GIMPLE form already. Minimal checking is done of
345 gimple_build_call_from_tree (tree t
)
349 tree fndecl
= get_callee_fndecl (t
);
351 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
353 nargs
= call_expr_nargs (t
);
354 call
= gimple_build_call_1 (fndecl
? fndecl
: CALL_EXPR_FN (t
), nargs
);
356 for (i
= 0; i
< nargs
; i
++)
357 gimple_call_set_arg (call
, i
, CALL_EXPR_ARG (t
, i
));
359 gimple_set_block (call
, TREE_BLOCK (t
));
361 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
362 gimple_call_set_chain (call
, CALL_EXPR_STATIC_CHAIN (t
));
363 gimple_call_set_tail (call
, CALL_EXPR_TAILCALL (t
));
364 gimple_call_set_must_tail (call
, CALL_EXPR_MUST_TAIL_CALL (t
));
365 gimple_call_set_return_slot_opt (call
, CALL_EXPR_RETURN_SLOT_OPT (t
));
367 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
368 && (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA
369 || DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
370 gimple_call_set_alloca_for_var (call
, CALL_ALLOCA_FOR_VAR_P (t
));
372 gimple_call_set_from_thunk (call
, CALL_FROM_THUNK_P (t
));
373 gimple_call_set_va_arg_pack (call
, CALL_EXPR_VA_ARG_PACK (t
));
374 gimple_call_set_nothrow (call
, TREE_NOTHROW (t
));
375 gimple_set_no_warning (call
, TREE_NO_WARNING (t
));
376 gimple_call_set_with_bounds (call
, CALL_WITH_BOUNDS_P (t
));
382 /* Build a GIMPLE_ASSIGN statement.
384 LHS of the assignment.
385 RHS of the assignment which can be unary or binary. */
388 gimple_build_assign (tree lhs
, tree rhs MEM_STAT_DECL
)
390 enum tree_code subcode
;
393 extract_ops_from_tree (rhs
, &subcode
, &op1
, &op2
, &op3
);
394 return gimple_build_assign (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
398 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
401 static inline gassign
*
402 gimple_build_assign_1 (tree lhs
, enum tree_code subcode
, tree op1
,
403 tree op2
, tree op3 MEM_STAT_DECL
)
408 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
410 num_ops
= get_gimple_rhs_num_ops (subcode
) + 1;
412 p
= as_a
<gassign
*> (
413 gimple_build_with_ops_stat (GIMPLE_ASSIGN
, (unsigned)subcode
, num_ops
415 gimple_assign_set_lhs (p
, lhs
);
416 gimple_assign_set_rhs1 (p
, op1
);
419 gcc_assert (num_ops
> 2);
420 gimple_assign_set_rhs2 (p
, op2
);
425 gcc_assert (num_ops
> 3);
426 gimple_assign_set_rhs3 (p
, op3
);
432 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
436 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
437 tree op2
, tree op3 MEM_STAT_DECL
)
439 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
442 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
446 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
447 tree op2 MEM_STAT_DECL
)
449 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, NULL_TREE
453 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
456 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1 MEM_STAT_DECL
)
458 return gimple_build_assign_1 (lhs
, subcode
, op1
, NULL_TREE
, NULL_TREE
463 /* Build a GIMPLE_COND statement.
465 PRED is the condition used to compare LHS and the RHS.
466 T_LABEL is the label to jump to if the condition is true.
467 F_LABEL is the label to jump to otherwise. */
470 gimple_build_cond (enum tree_code pred_code
, tree lhs
, tree rhs
,
471 tree t_label
, tree f_label
)
475 gcc_assert (TREE_CODE_CLASS (pred_code
) == tcc_comparison
);
476 p
= as_a
<gcond
*> (gimple_build_with_ops (GIMPLE_COND
, pred_code
, 4));
477 gimple_cond_set_lhs (p
, lhs
);
478 gimple_cond_set_rhs (p
, rhs
);
479 gimple_cond_set_true_label (p
, t_label
);
480 gimple_cond_set_false_label (p
, f_label
);
484 /* Build a GIMPLE_COND statement from the conditional expression tree
485 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
488 gimple_build_cond_from_tree (tree cond
, tree t_label
, tree f_label
)
493 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
494 return gimple_build_cond (code
, lhs
, rhs
, t_label
, f_label
);
497 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
498 boolean expression tree COND. */
501 gimple_cond_set_condition_from_tree (gcond
*stmt
, tree cond
)
506 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
507 gimple_cond_set_condition (stmt
, code
, lhs
, rhs
);
510 /* Build a GIMPLE_LABEL statement for LABEL. */
513 gimple_build_label (tree label
)
516 = as_a
<glabel
*> (gimple_build_with_ops (GIMPLE_LABEL
, ERROR_MARK
, 1));
517 gimple_label_set_label (p
, label
);
521 /* Build a GIMPLE_GOTO statement to label DEST. */
524 gimple_build_goto (tree dest
)
527 = as_a
<ggoto
*> (gimple_build_with_ops (GIMPLE_GOTO
, ERROR_MARK
, 1));
528 gimple_goto_set_dest (p
, dest
);
533 /* Build a GIMPLE_NOP statement. */
536 gimple_build_nop (void)
538 return gimple_alloc (GIMPLE_NOP
, 0);
542 /* Build a GIMPLE_BIND statement.
543 VARS are the variables in BODY.
544 BLOCK is the containing block. */
547 gimple_build_bind (tree vars
, gimple_seq body
, tree block
)
549 gbind
*p
= as_a
<gbind
*> (gimple_alloc (GIMPLE_BIND
, 0));
550 gimple_bind_set_vars (p
, vars
);
552 gimple_bind_set_body (p
, body
);
554 gimple_bind_set_block (p
, block
);
558 /* Helper function to set the simple fields of a asm stmt.
560 STRING is a pointer to a string that is the asm blocks assembly code.
561 NINPUT is the number of register inputs.
562 NOUTPUT is the number of register outputs.
563 NCLOBBERS is the number of clobbered registers.
567 gimple_build_asm_1 (const char *string
, unsigned ninputs
, unsigned noutputs
,
568 unsigned nclobbers
, unsigned nlabels
)
571 int size
= strlen (string
);
573 /* ASMs with labels cannot have outputs. This should have been
574 enforced by the front end. */
575 gcc_assert (nlabels
== 0 || noutputs
== 0);
578 gimple_build_with_ops (GIMPLE_ASM
, ERROR_MARK
,
579 ninputs
+ noutputs
+ nclobbers
+ nlabels
));
585 p
->string
= ggc_alloc_string (string
, size
);
587 if (GATHER_STATISTICS
)
588 gimple_alloc_sizes
[(int) gimple_alloc_kind (GIMPLE_ASM
)] += size
;
593 /* Build a GIMPLE_ASM statement.
595 STRING is the assembly code.
596 NINPUT is the number of register inputs.
597 NOUTPUT is the number of register outputs.
598 NCLOBBERS is the number of clobbered registers.
599 INPUTS is a vector of the input register parameters.
600 OUTPUTS is a vector of the output register parameters.
601 CLOBBERS is a vector of the clobbered register parameters.
602 LABELS is a vector of destination labels. */
605 gimple_build_asm_vec (const char *string
, vec
<tree
, va_gc
> *inputs
,
606 vec
<tree
, va_gc
> *outputs
, vec
<tree
, va_gc
> *clobbers
,
607 vec
<tree
, va_gc
> *labels
)
612 p
= gimple_build_asm_1 (string
,
613 vec_safe_length (inputs
),
614 vec_safe_length (outputs
),
615 vec_safe_length (clobbers
),
616 vec_safe_length (labels
));
618 for (i
= 0; i
< vec_safe_length (inputs
); i
++)
619 gimple_asm_set_input_op (p
, i
, (*inputs
)[i
]);
621 for (i
= 0; i
< vec_safe_length (outputs
); i
++)
622 gimple_asm_set_output_op (p
, i
, (*outputs
)[i
]);
624 for (i
= 0; i
< vec_safe_length (clobbers
); i
++)
625 gimple_asm_set_clobber_op (p
, i
, (*clobbers
)[i
]);
627 for (i
= 0; i
< vec_safe_length (labels
); i
++)
628 gimple_asm_set_label_op (p
, i
, (*labels
)[i
]);
633 /* Build a GIMPLE_CATCH statement.
635 TYPES are the catch types.
636 HANDLER is the exception handler. */
639 gimple_build_catch (tree types
, gimple_seq handler
)
641 gcatch
*p
= as_a
<gcatch
*> (gimple_alloc (GIMPLE_CATCH
, 0));
642 gimple_catch_set_types (p
, types
);
644 gimple_catch_set_handler (p
, handler
);
649 /* Build a GIMPLE_EH_FILTER statement.
651 TYPES are the filter's types.
652 FAILURE is the filter's failure action. */
655 gimple_build_eh_filter (tree types
, gimple_seq failure
)
657 geh_filter
*p
= as_a
<geh_filter
*> (gimple_alloc (GIMPLE_EH_FILTER
, 0));
658 gimple_eh_filter_set_types (p
, types
);
660 gimple_eh_filter_set_failure (p
, failure
);
665 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
668 gimple_build_eh_must_not_throw (tree decl
)
670 geh_mnt
*p
= as_a
<geh_mnt
*> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW
, 0));
672 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
673 gcc_assert (flags_from_decl_or_type (decl
) & ECF_NORETURN
);
674 gimple_eh_must_not_throw_set_fndecl (p
, decl
);
679 /* Build a GIMPLE_EH_ELSE statement. */
682 gimple_build_eh_else (gimple_seq n_body
, gimple_seq e_body
)
684 geh_else
*p
= as_a
<geh_else
*> (gimple_alloc (GIMPLE_EH_ELSE
, 0));
685 gimple_eh_else_set_n_body (p
, n_body
);
686 gimple_eh_else_set_e_body (p
, e_body
);
690 /* Build a GIMPLE_TRY statement.
692 EVAL is the expression to evaluate.
693 CLEANUP is the cleanup expression.
694 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
695 whether this is a try/catch or a try/finally respectively. */
698 gimple_build_try (gimple_seq eval
, gimple_seq cleanup
,
699 enum gimple_try_flags kind
)
703 gcc_assert (kind
== GIMPLE_TRY_CATCH
|| kind
== GIMPLE_TRY_FINALLY
);
704 p
= as_a
<gtry
*> (gimple_alloc (GIMPLE_TRY
, 0));
705 gimple_set_subcode (p
, kind
);
707 gimple_try_set_eval (p
, eval
);
709 gimple_try_set_cleanup (p
, cleanup
);
714 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
716 CLEANUP is the cleanup expression. */
719 gimple_build_wce (gimple_seq cleanup
)
721 gimple
*p
= gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR
, 0);
723 gimple_wce_set_cleanup (p
, cleanup
);
729 /* Build a GIMPLE_RESX statement. */
732 gimple_build_resx (int region
)
735 = as_a
<gresx
*> (gimple_build_with_ops (GIMPLE_RESX
, ERROR_MARK
, 0));
741 /* The helper for constructing a gimple switch statement.
742 INDEX is the switch's index.
743 NLABELS is the number of labels in the switch excluding the default.
744 DEFAULT_LABEL is the default label for the switch statement. */
747 gimple_build_switch_nlabels (unsigned nlabels
, tree index
, tree default_label
)
749 /* nlabels + 1 default label + 1 index. */
750 gcc_checking_assert (default_label
);
751 gswitch
*p
= as_a
<gswitch
*> (gimple_build_with_ops (GIMPLE_SWITCH
,
754 gimple_switch_set_index (p
, index
);
755 gimple_switch_set_default_label (p
, default_label
);
759 /* Build a GIMPLE_SWITCH statement.
761 INDEX is the switch's index.
762 DEFAULT_LABEL is the default label
763 ARGS is a vector of labels excluding the default. */
766 gimple_build_switch (tree index
, tree default_label
, vec
<tree
> args
)
768 unsigned i
, nlabels
= args
.length ();
770 gswitch
*p
= gimple_build_switch_nlabels (nlabels
, index
, default_label
);
772 /* Copy the labels from the vector to the switch statement. */
773 for (i
= 0; i
< nlabels
; i
++)
774 gimple_switch_set_label (p
, i
+ 1, args
[i
]);
779 /* Build a GIMPLE_EH_DISPATCH statement. */
782 gimple_build_eh_dispatch (int region
)
785 = as_a
<geh_dispatch
*> (
786 gimple_build_with_ops (GIMPLE_EH_DISPATCH
, ERROR_MARK
, 0));
791 /* Build a new GIMPLE_DEBUG_BIND statement.
793 VAR is bound to VALUE; block and location are taken from STMT. */
796 gimple_build_debug_bind_stat (tree var
, tree value
, gimple
*stmt MEM_STAT_DECL
)
799 = as_a
<gdebug
*> (gimple_build_with_ops_stat (GIMPLE_DEBUG
,
800 (unsigned)GIMPLE_DEBUG_BIND
, 2
802 gimple_debug_bind_set_var (p
, var
);
803 gimple_debug_bind_set_value (p
, value
);
805 gimple_set_location (p
, gimple_location (stmt
));
811 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
813 VAR is bound to VALUE; block and location are taken from STMT. */
816 gimple_build_debug_source_bind_stat (tree var
, tree value
,
817 gimple
*stmt MEM_STAT_DECL
)
821 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
822 (unsigned)GIMPLE_DEBUG_SOURCE_BIND
, 2
825 gimple_debug_source_bind_set_var (p
, var
);
826 gimple_debug_source_bind_set_value (p
, value
);
828 gimple_set_location (p
, gimple_location (stmt
));
834 /* Build a GIMPLE_OMP_CRITICAL statement.
836 BODY is the sequence of statements for which only one thread can execute.
837 NAME is optional identifier for this critical block.
838 CLAUSES are clauses for this critical block. */
841 gimple_build_omp_critical (gimple_seq body
, tree name
, tree clauses
)
844 = as_a
<gomp_critical
*> (gimple_alloc (GIMPLE_OMP_CRITICAL
, 0));
845 gimple_omp_critical_set_name (p
, name
);
846 gimple_omp_critical_set_clauses (p
, clauses
);
848 gimple_omp_set_body (p
, body
);
853 /* Build a GIMPLE_OMP_FOR statement.
855 BODY is sequence of statements inside the for loop.
856 KIND is the `for' variant.
857 CLAUSES, are any of the construct's clauses.
858 COLLAPSE is the collapse count.
859 PRE_BODY is the sequence of statements that are loop invariant. */
862 gimple_build_omp_for (gimple_seq body
, int kind
, tree clauses
, size_t collapse
,
865 gomp_for
*p
= as_a
<gomp_for
*> (gimple_alloc (GIMPLE_OMP_FOR
, 0));
867 gimple_omp_set_body (p
, body
);
868 gimple_omp_for_set_clauses (p
, clauses
);
869 gimple_omp_for_set_kind (p
, kind
);
870 p
->collapse
= collapse
;
871 p
->iter
= ggc_cleared_vec_alloc
<gimple_omp_for_iter
> (collapse
);
874 gimple_omp_for_set_pre_body (p
, pre_body
);
880 /* Build a GIMPLE_OMP_PARALLEL statement.
882 BODY is sequence of statements which are executed in parallel.
883 CLAUSES, are the OMP parallel construct's clauses.
884 CHILD_FN is the function created for the parallel threads to execute.
885 DATA_ARG are the shared data argument(s). */
888 gimple_build_omp_parallel (gimple_seq body
, tree clauses
, tree child_fn
,
892 = as_a
<gomp_parallel
*> (gimple_alloc (GIMPLE_OMP_PARALLEL
, 0));
894 gimple_omp_set_body (p
, body
);
895 gimple_omp_parallel_set_clauses (p
, clauses
);
896 gimple_omp_parallel_set_child_fn (p
, child_fn
);
897 gimple_omp_parallel_set_data_arg (p
, data_arg
);
903 /* Build a GIMPLE_OMP_TASK statement.
905 BODY is sequence of statements which are executed by the explicit task.
906 CLAUSES, are the OMP parallel construct's clauses.
907 CHILD_FN is the function created for the parallel threads to execute.
908 DATA_ARG are the shared data argument(s).
909 COPY_FN is the optional function for firstprivate initialization.
910 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
913 gimple_build_omp_task (gimple_seq body
, tree clauses
, tree child_fn
,
914 tree data_arg
, tree copy_fn
, tree arg_size
,
917 gomp_task
*p
= as_a
<gomp_task
*> (gimple_alloc (GIMPLE_OMP_TASK
, 0));
919 gimple_omp_set_body (p
, body
);
920 gimple_omp_task_set_clauses (p
, clauses
);
921 gimple_omp_task_set_child_fn (p
, child_fn
);
922 gimple_omp_task_set_data_arg (p
, data_arg
);
923 gimple_omp_task_set_copy_fn (p
, copy_fn
);
924 gimple_omp_task_set_arg_size (p
, arg_size
);
925 gimple_omp_task_set_arg_align (p
, arg_align
);
931 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
933 BODY is the sequence of statements in the section. */
936 gimple_build_omp_section (gimple_seq body
)
938 gimple
*p
= gimple_alloc (GIMPLE_OMP_SECTION
, 0);
940 gimple_omp_set_body (p
, body
);
946 /* Build a GIMPLE_OMP_MASTER statement.
948 BODY is the sequence of statements to be executed by just the master. */
951 gimple_build_omp_master (gimple_seq body
)
953 gimple
*p
= gimple_alloc (GIMPLE_OMP_MASTER
, 0);
955 gimple_omp_set_body (p
, body
);
960 /* Build a GIMPLE_OMP_GRID_BODY statement.
962 BODY is the sequence of statements to be executed by the kernel. */
965 gimple_build_omp_grid_body (gimple_seq body
)
967 gimple
*p
= gimple_alloc (GIMPLE_OMP_GRID_BODY
, 0);
969 gimple_omp_set_body (p
, body
);
974 /* Build a GIMPLE_OMP_TASKGROUP statement.
976 BODY is the sequence of statements to be executed by the taskgroup
980 gimple_build_omp_taskgroup (gimple_seq body
)
982 gimple
*p
= gimple_alloc (GIMPLE_OMP_TASKGROUP
, 0);
984 gimple_omp_set_body (p
, body
);
990 /* Build a GIMPLE_OMP_CONTINUE statement.
992 CONTROL_DEF is the definition of the control variable.
993 CONTROL_USE is the use of the control variable. */
996 gimple_build_omp_continue (tree control_def
, tree control_use
)
999 = as_a
<gomp_continue
*> (gimple_alloc (GIMPLE_OMP_CONTINUE
, 0));
1000 gimple_omp_continue_set_control_def (p
, control_def
);
1001 gimple_omp_continue_set_control_use (p
, control_use
);
1005 /* Build a GIMPLE_OMP_ORDERED statement.
1007 BODY is the sequence of statements inside a loop that will executed in
1009 CLAUSES are clauses for this statement. */
1012 gimple_build_omp_ordered (gimple_seq body
, tree clauses
)
1015 = as_a
<gomp_ordered
*> (gimple_alloc (GIMPLE_OMP_ORDERED
, 0));
1016 gimple_omp_ordered_set_clauses (p
, clauses
);
1018 gimple_omp_set_body (p
, body
);
1024 /* Build a GIMPLE_OMP_RETURN statement.
1025 WAIT_P is true if this is a non-waiting return. */
1028 gimple_build_omp_return (bool wait_p
)
1030 gimple
*p
= gimple_alloc (GIMPLE_OMP_RETURN
, 0);
1032 gimple_omp_return_set_nowait (p
);
1038 /* Build a GIMPLE_OMP_SECTIONS statement.
1040 BODY is a sequence of section statements.
1041 CLAUSES are any of the OMP sections contsruct's clauses: private,
1042 firstprivate, lastprivate, reduction, and nowait. */
1045 gimple_build_omp_sections (gimple_seq body
, tree clauses
)
1048 = as_a
<gomp_sections
*> (gimple_alloc (GIMPLE_OMP_SECTIONS
, 0));
1050 gimple_omp_set_body (p
, body
);
1051 gimple_omp_sections_set_clauses (p
, clauses
);
1057 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1060 gimple_build_omp_sections_switch (void)
1062 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH
, 0);
1066 /* Build a GIMPLE_OMP_SINGLE statement.
1068 BODY is the sequence of statements that will be executed once.
1069 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1070 copyprivate, nowait. */
1073 gimple_build_omp_single (gimple_seq body
, tree clauses
)
1076 = as_a
<gomp_single
*> (gimple_alloc (GIMPLE_OMP_SINGLE
, 0));
1078 gimple_omp_set_body (p
, body
);
1079 gimple_omp_single_set_clauses (p
, clauses
);
1085 /* Build a GIMPLE_OMP_TARGET statement.
1087 BODY is the sequence of statements that will be executed.
1088 KIND is the kind of the region.
1089 CLAUSES are any of the construct's clauses. */
1092 gimple_build_omp_target (gimple_seq body
, int kind
, tree clauses
)
1095 = as_a
<gomp_target
*> (gimple_alloc (GIMPLE_OMP_TARGET
, 0));
1097 gimple_omp_set_body (p
, body
);
1098 gimple_omp_target_set_clauses (p
, clauses
);
1099 gimple_omp_target_set_kind (p
, kind
);
1105 /* Build a GIMPLE_OMP_TEAMS statement.
1107 BODY is the sequence of statements that will be executed.
1108 CLAUSES are any of the OMP teams construct's clauses. */
1111 gimple_build_omp_teams (gimple_seq body
, tree clauses
)
1113 gomp_teams
*p
= as_a
<gomp_teams
*> (gimple_alloc (GIMPLE_OMP_TEAMS
, 0));
1115 gimple_omp_set_body (p
, body
);
1116 gimple_omp_teams_set_clauses (p
, clauses
);
1122 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1125 gimple_build_omp_atomic_load (tree lhs
, tree rhs
)
1128 = as_a
<gomp_atomic_load
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD
, 0));
1129 gimple_omp_atomic_load_set_lhs (p
, lhs
);
1130 gimple_omp_atomic_load_set_rhs (p
, rhs
);
1134 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1136 VAL is the value we are storing. */
1139 gimple_build_omp_atomic_store (tree val
)
1141 gomp_atomic_store
*p
1142 = as_a
<gomp_atomic_store
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE
, 0));
1143 gimple_omp_atomic_store_set_val (p
, val
);
1147 /* Build a GIMPLE_TRANSACTION statement. */
1150 gimple_build_transaction (gimple_seq body
)
1153 = as_a
<gtransaction
*> (gimple_alloc (GIMPLE_TRANSACTION
, 0));
1154 gimple_transaction_set_body (p
, body
);
1155 gimple_transaction_set_label_norm (p
, 0);
1156 gimple_transaction_set_label_uninst (p
, 0);
1157 gimple_transaction_set_label_over (p
, 0);
1161 #if defined ENABLE_GIMPLE_CHECKING
1162 /* Complain of a gimple type mismatch and die. */
1165 gimple_check_failed (const gimple
*gs
, const char *file
, int line
,
1166 const char *function
, enum gimple_code code
,
1167 enum tree_code subcode
)
1169 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1170 gimple_code_name
[code
],
1171 get_tree_code_name (subcode
),
1172 gimple_code_name
[gimple_code (gs
)],
1174 ? get_tree_code_name ((enum tree_code
) gs
->subcode
)
1176 function
, trim_filename (file
), line
);
1178 #endif /* ENABLE_GIMPLE_CHECKING */
1181 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1182 *SEQ_P is NULL, a new sequence is allocated. */
1185 gimple_seq_add_stmt (gimple_seq
*seq_p
, gimple
*gs
)
1187 gimple_stmt_iterator si
;
1191 si
= gsi_last (*seq_p
);
1192 gsi_insert_after (&si
, gs
, GSI_NEW_STMT
);
1195 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1196 *SEQ_P is NULL, a new sequence is allocated. This function is
1197 similar to gimple_seq_add_stmt, but does not scan the operands.
1198 During gimplification, we need to manipulate statement sequences
1199 before the def/use vectors have been constructed. */
1202 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple
*gs
)
1204 gimple_stmt_iterator si
;
1209 si
= gsi_last (*seq_p
);
1210 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
1213 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1214 NULL, a new sequence is allocated. */
1217 gimple_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
1219 gimple_stmt_iterator si
;
1223 si
= gsi_last (*dst_p
);
1224 gsi_insert_seq_after (&si
, src
, GSI_NEW_STMT
);
1227 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1228 NULL, a new sequence is allocated. This function is
1229 similar to gimple_seq_add_seq, but does not scan the operands. */
1232 gimple_seq_add_seq_without_update (gimple_seq
*dst_p
, gimple_seq src
)
1234 gimple_stmt_iterator si
;
1238 si
= gsi_last (*dst_p
);
1239 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
1242 /* Determine whether to assign a location to the statement GS. */
1245 should_carry_location_p (gimple
*gs
)
1247 /* Don't emit a line note for a label. We particularly don't want to
1248 emit one for the break label, since it doesn't actually correspond
1249 to the beginning of the loop/switch. */
1250 if (gimple_code (gs
) == GIMPLE_LABEL
)
1256 /* Set the location for gimple statement GS to LOCATION. */
1259 annotate_one_with_location (gimple
*gs
, location_t location
)
1261 if (!gimple_has_location (gs
)
1262 && !gimple_do_not_emit_location_p (gs
)
1263 && should_carry_location_p (gs
))
1264 gimple_set_location (gs
, location
);
1267 /* Set LOCATION for all the statements after iterator GSI in sequence
1268 SEQ. If GSI is pointing to the end of the sequence, start with the
1269 first statement in SEQ. */
1272 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
1273 location_t location
)
1275 if (gsi_end_p (gsi
))
1276 gsi
= gsi_start (seq
);
1280 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
1281 annotate_one_with_location (gsi_stmt (gsi
), location
);
1284 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1287 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
1289 gimple_stmt_iterator i
;
1291 if (gimple_seq_empty_p (stmt_p
))
1294 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
1296 gimple
*gs
= gsi_stmt (i
);
1297 annotate_one_with_location (gs
, location
);
1301 /* Helper function of empty_body_p. Return true if STMT is an empty
1305 empty_stmt_p (gimple
*stmt
)
1307 if (gimple_code (stmt
) == GIMPLE_NOP
)
1309 if (gbind
*bind_stmt
= dyn_cast
<gbind
*> (stmt
))
1310 return empty_body_p (gimple_bind_body (bind_stmt
));
1315 /* Return true if BODY contains nothing but empty statements. */
1318 empty_body_p (gimple_seq body
)
1320 gimple_stmt_iterator i
;
1322 if (gimple_seq_empty_p (body
))
1324 for (i
= gsi_start (body
); !gsi_end_p (i
); gsi_next (&i
))
1325 if (!empty_stmt_p (gsi_stmt (i
))
1326 && !is_gimple_debug (gsi_stmt (i
)))
1333 /* Perform a deep copy of sequence SRC and return the result. */
1336 gimple_seq_copy (gimple_seq src
)
1338 gimple_stmt_iterator gsi
;
1339 gimple_seq new_seq
= NULL
;
1342 for (gsi
= gsi_start (src
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1344 stmt
= gimple_copy (gsi_stmt (gsi
));
1345 gimple_seq_add_stmt (&new_seq
, stmt
);
1353 /* Return true if calls C1 and C2 are known to go to the same function. */
1356 gimple_call_same_target_p (const gimple
*c1
, const gimple
*c2
)
1358 if (gimple_call_internal_p (c1
))
1359 return (gimple_call_internal_p (c2
)
1360 && gimple_call_internal_fn (c1
) == gimple_call_internal_fn (c2
)
1361 && (!gimple_call_internal_unique_p (as_a
<const gcall
*> (c1
))
1364 return (gimple_call_fn (c1
) == gimple_call_fn (c2
)
1365 || (gimple_call_fndecl (c1
)
1366 && gimple_call_fndecl (c1
) == gimple_call_fndecl (c2
)));
1369 /* Detect flags from a GIMPLE_CALL. This is just like
1370 call_expr_flags, but for gimple tuples. */
1373 gimple_call_flags (const gimple
*stmt
)
1376 tree decl
= gimple_call_fndecl (stmt
);
1379 flags
= flags_from_decl_or_type (decl
);
1380 else if (gimple_call_internal_p (stmt
))
1381 flags
= internal_fn_flags (gimple_call_internal_fn (stmt
));
1383 flags
= flags_from_decl_or_type (gimple_call_fntype (stmt
));
1385 if (stmt
->subcode
& GF_CALL_NOTHROW
)
1386 flags
|= ECF_NOTHROW
;
1391 /* Return the "fn spec" string for call STMT. */
1394 gimple_call_fnspec (const gcall
*stmt
)
1398 if (gimple_call_internal_p (stmt
))
1399 return internal_fn_fnspec (gimple_call_internal_fn (stmt
));
1401 type
= gimple_call_fntype (stmt
);
1405 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
1409 return TREE_VALUE (TREE_VALUE (attr
));
1412 /* Detects argument flags for argument number ARG on call STMT. */
1415 gimple_call_arg_flags (const gcall
*stmt
, unsigned arg
)
1417 const_tree attr
= gimple_call_fnspec (stmt
);
1419 if (!attr
|| 1 + arg
>= (unsigned) TREE_STRING_LENGTH (attr
))
1422 switch (TREE_STRING_POINTER (attr
)[1 + arg
])
1429 return EAF_DIRECT
| EAF_NOCLOBBER
| EAF_NOESCAPE
;
1432 return EAF_NOCLOBBER
| EAF_NOESCAPE
;
1435 return EAF_DIRECT
| EAF_NOESCAPE
;
1438 return EAF_NOESCAPE
;
1446 /* Detects return flags for the call STMT. */
1449 gimple_call_return_flags (const gcall
*stmt
)
1453 if (gimple_call_flags (stmt
) & ECF_MALLOC
)
1456 attr
= gimple_call_fnspec (stmt
);
1457 if (!attr
|| TREE_STRING_LENGTH (attr
) < 1)
1460 switch (TREE_STRING_POINTER (attr
)[0])
1466 return ERF_RETURNS_ARG
| (TREE_STRING_POINTER (attr
)[0] - '1');
1478 /* Return true if GS is a copy assignment. */
1481 gimple_assign_copy_p (gimple
*gs
)
1483 return (gimple_assign_single_p (gs
)
1484 && is_gimple_val (gimple_op (gs
, 1)));
1488 /* Return true if GS is a SSA_NAME copy assignment. */
1491 gimple_assign_ssa_name_copy_p (gimple
*gs
)
1493 return (gimple_assign_single_p (gs
)
1494 && TREE_CODE (gimple_assign_lhs (gs
)) == SSA_NAME
1495 && TREE_CODE (gimple_assign_rhs1 (gs
)) == SSA_NAME
);
1499 /* Return true if GS is an assignment with a unary RHS, but the
1500 operator has no effect on the assigned value. The logic is adapted
1501 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1502 instances in which STRIP_NOPS was previously applied to the RHS of
1505 NOTE: In the use cases that led to the creation of this function
1506 and of gimple_assign_single_p, it is typical to test for either
1507 condition and to proceed in the same manner. In each case, the
1508 assigned value is represented by the single RHS operand of the
1509 assignment. I suspect there may be cases where gimple_assign_copy_p,
1510 gimple_assign_single_p, or equivalent logic is used where a similar
1511 treatment of unary NOPs is appropriate. */
1514 gimple_assign_unary_nop_p (gimple
*gs
)
1516 return (is_gimple_assign (gs
)
1517 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs
))
1518 || gimple_assign_rhs_code (gs
) == NON_LVALUE_EXPR
)
1519 && gimple_assign_rhs1 (gs
) != error_mark_node
1520 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs
)))
1521 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs
)))));
1524 /* Set BB to be the basic block holding G. */
1527 gimple_set_bb (gimple
*stmt
, basic_block bb
)
1531 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1534 /* If the statement is a label, add the label to block-to-labels map
1535 so that we can speed up edge creation for GIMPLE_GOTOs. */
1541 t
= gimple_label_label (as_a
<glabel
*> (stmt
));
1542 uid
= LABEL_DECL_UID (t
);
1546 vec_safe_length (label_to_block_map_for_fn (cfun
));
1547 LABEL_DECL_UID (t
) = uid
= cfun
->cfg
->last_label_uid
++;
1548 if (old_len
<= (unsigned) uid
)
1550 unsigned new_len
= 3 * uid
/ 2 + 1;
1552 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun
),
1557 (*label_to_block_map_for_fn (cfun
))[uid
] = bb
;
1562 /* Modify the RHS of the assignment pointed-to by GSI using the
1563 operands in the expression tree EXPR.
1565 NOTE: The statement pointed-to by GSI may be reallocated if it
1566 did not have enough operand slots.
1568 This function is useful to convert an existing tree expression into
1569 the flat representation used for the RHS of a GIMPLE assignment.
1570 It will reallocate memory as needed to expand or shrink the number
1571 of operand slots needed to represent EXPR.
1573 NOTE: If you find yourself building a tree and then calling this
1574 function, you are most certainly doing it the slow way. It is much
1575 better to build a new assignment or to use the function
1576 gimple_assign_set_rhs_with_ops, which does not require an
1577 expression tree to be built. */
1580 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*gsi
, tree expr
)
1582 enum tree_code subcode
;
1585 extract_ops_from_tree (expr
, &subcode
, &op1
, &op2
, &op3
);
1586 gimple_assign_set_rhs_with_ops (gsi
, subcode
, op1
, op2
, op3
);
1590 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1591 operands OP1, OP2 and OP3.
1593 NOTE: The statement pointed-to by GSI may be reallocated if it
1594 did not have enough operand slots. */
1597 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*gsi
, enum tree_code code
,
1598 tree op1
, tree op2
, tree op3
)
1600 unsigned new_rhs_ops
= get_gimple_rhs_num_ops (code
);
1601 gimple
*stmt
= gsi_stmt (*gsi
);
1603 /* If the new CODE needs more operands, allocate a new statement. */
1604 if (gimple_num_ops (stmt
) < new_rhs_ops
+ 1)
1606 tree lhs
= gimple_assign_lhs (stmt
);
1607 gimple
*new_stmt
= gimple_alloc (gimple_code (stmt
), new_rhs_ops
+ 1);
1608 memcpy (new_stmt
, stmt
, gimple_size (gimple_code (stmt
)));
1609 gimple_init_singleton (new_stmt
);
1610 gsi_replace (gsi
, new_stmt
, true);
1613 /* The LHS needs to be reset as this also changes the SSA name
1615 gimple_assign_set_lhs (stmt
, lhs
);
1618 gimple_set_num_ops (stmt
, new_rhs_ops
+ 1);
1619 gimple_set_subcode (stmt
, code
);
1620 gimple_assign_set_rhs1 (stmt
, op1
);
1621 if (new_rhs_ops
> 1)
1622 gimple_assign_set_rhs2 (stmt
, op2
);
1623 if (new_rhs_ops
> 2)
1624 gimple_assign_set_rhs3 (stmt
, op3
);
1628 /* Return the LHS of a statement that performs an assignment,
1629 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1630 for a call to a function that returns no value, or for a
1631 statement other than an assignment or a call. */
1634 gimple_get_lhs (const gimple
*stmt
)
1636 enum gimple_code code
= gimple_code (stmt
);
1638 if (code
== GIMPLE_ASSIGN
)
1639 return gimple_assign_lhs (stmt
);
1640 else if (code
== GIMPLE_CALL
)
1641 return gimple_call_lhs (stmt
);
1647 /* Set the LHS of a statement that performs an assignment,
1648 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1651 gimple_set_lhs (gimple
*stmt
, tree lhs
)
1653 enum gimple_code code
= gimple_code (stmt
);
1655 if (code
== GIMPLE_ASSIGN
)
1656 gimple_assign_set_lhs (stmt
, lhs
);
1657 else if (code
== GIMPLE_CALL
)
1658 gimple_call_set_lhs (stmt
, lhs
);
1664 /* Return a deep copy of statement STMT. All the operands from STMT
1665 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1666 and VUSE operand arrays are set to empty in the new copy. The new
1667 copy isn't part of any sequence. */
1670 gimple_copy (gimple
*stmt
)
1672 enum gimple_code code
= gimple_code (stmt
);
1673 unsigned num_ops
= gimple_num_ops (stmt
);
1674 gimple
*copy
= gimple_alloc (code
, num_ops
);
1677 /* Shallow copy all the fields from STMT. */
1678 memcpy (copy
, stmt
, gimple_size (code
));
1679 gimple_init_singleton (copy
);
1681 /* If STMT has sub-statements, deep-copy them as well. */
1682 if (gimple_has_substatements (stmt
))
1687 switch (gimple_code (stmt
))
1691 gbind
*bind_stmt
= as_a
<gbind
*> (stmt
);
1692 gbind
*bind_copy
= as_a
<gbind
*> (copy
);
1693 new_seq
= gimple_seq_copy (gimple_bind_body (bind_stmt
));
1694 gimple_bind_set_body (bind_copy
, new_seq
);
1695 gimple_bind_set_vars (bind_copy
,
1696 unshare_expr (gimple_bind_vars (bind_stmt
)));
1697 gimple_bind_set_block (bind_copy
, gimple_bind_block (bind_stmt
));
1703 gcatch
*catch_stmt
= as_a
<gcatch
*> (stmt
);
1704 gcatch
*catch_copy
= as_a
<gcatch
*> (copy
);
1705 new_seq
= gimple_seq_copy (gimple_catch_handler (catch_stmt
));
1706 gimple_catch_set_handler (catch_copy
, new_seq
);
1707 t
= unshare_expr (gimple_catch_types (catch_stmt
));
1708 gimple_catch_set_types (catch_copy
, t
);
1712 case GIMPLE_EH_FILTER
:
1714 geh_filter
*eh_filter_stmt
= as_a
<geh_filter
*> (stmt
);
1715 geh_filter
*eh_filter_copy
= as_a
<geh_filter
*> (copy
);
1717 = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt
));
1718 gimple_eh_filter_set_failure (eh_filter_copy
, new_seq
);
1719 t
= unshare_expr (gimple_eh_filter_types (eh_filter_stmt
));
1720 gimple_eh_filter_set_types (eh_filter_copy
, t
);
1724 case GIMPLE_EH_ELSE
:
1726 geh_else
*eh_else_stmt
= as_a
<geh_else
*> (stmt
);
1727 geh_else
*eh_else_copy
= as_a
<geh_else
*> (copy
);
1728 new_seq
= gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt
));
1729 gimple_eh_else_set_n_body (eh_else_copy
, new_seq
);
1730 new_seq
= gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt
));
1731 gimple_eh_else_set_e_body (eh_else_copy
, new_seq
);
1737 gtry
*try_stmt
= as_a
<gtry
*> (stmt
);
1738 gtry
*try_copy
= as_a
<gtry
*> (copy
);
1739 new_seq
= gimple_seq_copy (gimple_try_eval (try_stmt
));
1740 gimple_try_set_eval (try_copy
, new_seq
);
1741 new_seq
= gimple_seq_copy (gimple_try_cleanup (try_stmt
));
1742 gimple_try_set_cleanup (try_copy
, new_seq
);
1746 case GIMPLE_OMP_FOR
:
1747 new_seq
= gimple_seq_copy (gimple_omp_for_pre_body (stmt
));
1748 gimple_omp_for_set_pre_body (copy
, new_seq
);
1749 t
= unshare_expr (gimple_omp_for_clauses (stmt
));
1750 gimple_omp_for_set_clauses (copy
, t
);
1752 gomp_for
*omp_for_copy
= as_a
<gomp_for
*> (copy
);
1753 omp_for_copy
->iter
= ggc_vec_alloc
<gimple_omp_for_iter
>
1754 ( gimple_omp_for_collapse (stmt
));
1756 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1758 gimple_omp_for_set_cond (copy
, i
,
1759 gimple_omp_for_cond (stmt
, i
));
1760 gimple_omp_for_set_index (copy
, i
,
1761 gimple_omp_for_index (stmt
, i
));
1762 t
= unshare_expr (gimple_omp_for_initial (stmt
, i
));
1763 gimple_omp_for_set_initial (copy
, i
, t
);
1764 t
= unshare_expr (gimple_omp_for_final (stmt
, i
));
1765 gimple_omp_for_set_final (copy
, i
, t
);
1766 t
= unshare_expr (gimple_omp_for_incr (stmt
, i
));
1767 gimple_omp_for_set_incr (copy
, i
, t
);
1771 case GIMPLE_OMP_PARALLEL
:
1773 gomp_parallel
*omp_par_stmt
= as_a
<gomp_parallel
*> (stmt
);
1774 gomp_parallel
*omp_par_copy
= as_a
<gomp_parallel
*> (copy
);
1775 t
= unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt
));
1776 gimple_omp_parallel_set_clauses (omp_par_copy
, t
);
1777 t
= unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt
));
1778 gimple_omp_parallel_set_child_fn (omp_par_copy
, t
);
1779 t
= unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt
));
1780 gimple_omp_parallel_set_data_arg (omp_par_copy
, t
);
1784 case GIMPLE_OMP_TASK
:
1785 t
= unshare_expr (gimple_omp_task_clauses (stmt
));
1786 gimple_omp_task_set_clauses (copy
, t
);
1787 t
= unshare_expr (gimple_omp_task_child_fn (stmt
));
1788 gimple_omp_task_set_child_fn (copy
, t
);
1789 t
= unshare_expr (gimple_omp_task_data_arg (stmt
));
1790 gimple_omp_task_set_data_arg (copy
, t
);
1791 t
= unshare_expr (gimple_omp_task_copy_fn (stmt
));
1792 gimple_omp_task_set_copy_fn (copy
, t
);
1793 t
= unshare_expr (gimple_omp_task_arg_size (stmt
));
1794 gimple_omp_task_set_arg_size (copy
, t
);
1795 t
= unshare_expr (gimple_omp_task_arg_align (stmt
));
1796 gimple_omp_task_set_arg_align (copy
, t
);
1799 case GIMPLE_OMP_CRITICAL
:
1800 t
= unshare_expr (gimple_omp_critical_name
1801 (as_a
<gomp_critical
*> (stmt
)));
1802 gimple_omp_critical_set_name (as_a
<gomp_critical
*> (copy
), t
);
1803 t
= unshare_expr (gimple_omp_critical_clauses
1804 (as_a
<gomp_critical
*> (stmt
)));
1805 gimple_omp_critical_set_clauses (as_a
<gomp_critical
*> (copy
), t
);
1808 case GIMPLE_OMP_ORDERED
:
1809 t
= unshare_expr (gimple_omp_ordered_clauses
1810 (as_a
<gomp_ordered
*> (stmt
)));
1811 gimple_omp_ordered_set_clauses (as_a
<gomp_ordered
*> (copy
), t
);
1814 case GIMPLE_OMP_SECTIONS
:
1815 t
= unshare_expr (gimple_omp_sections_clauses (stmt
));
1816 gimple_omp_sections_set_clauses (copy
, t
);
1817 t
= unshare_expr (gimple_omp_sections_control (stmt
));
1818 gimple_omp_sections_set_control (copy
, t
);
1821 case GIMPLE_OMP_SINGLE
:
1822 case GIMPLE_OMP_TARGET
:
1823 case GIMPLE_OMP_TEAMS
:
1824 case GIMPLE_OMP_SECTION
:
1825 case GIMPLE_OMP_MASTER
:
1826 case GIMPLE_OMP_TASKGROUP
:
1827 case GIMPLE_OMP_GRID_BODY
:
1829 new_seq
= gimple_seq_copy (gimple_omp_body (stmt
));
1830 gimple_omp_set_body (copy
, new_seq
);
1833 case GIMPLE_TRANSACTION
:
1834 new_seq
= gimple_seq_copy (gimple_transaction_body (
1835 as_a
<gtransaction
*> (stmt
)));
1836 gimple_transaction_set_body (as_a
<gtransaction
*> (copy
),
1840 case GIMPLE_WITH_CLEANUP_EXPR
:
1841 new_seq
= gimple_seq_copy (gimple_wce_cleanup (stmt
));
1842 gimple_wce_set_cleanup (copy
, new_seq
);
1850 /* Make copy of operands. */
1851 for (i
= 0; i
< num_ops
; i
++)
1852 gimple_set_op (copy
, i
, unshare_expr (gimple_op (stmt
, i
)));
1854 if (gimple_has_mem_ops (stmt
))
1856 gimple_set_vdef (copy
, gimple_vdef (stmt
));
1857 gimple_set_vuse (copy
, gimple_vuse (stmt
));
1860 /* Clear out SSA operand vectors on COPY. */
1861 if (gimple_has_ops (stmt
))
1863 gimple_set_use_ops (copy
, NULL
);
1865 /* SSA operands need to be updated. */
1866 gimple_set_modified (copy
, true);
1873 /* Return true if statement S has side-effects. We consider a
1874 statement to have side effects if:
1876 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
1877 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
1880 gimple_has_side_effects (const gimple
*s
)
1882 if (is_gimple_debug (s
))
1885 /* We don't have to scan the arguments to check for
1886 volatile arguments, though, at present, we still
1887 do a scan to check for TREE_SIDE_EFFECTS. */
1888 if (gimple_has_volatile_ops (s
))
1891 if (gimple_code (s
) == GIMPLE_ASM
1892 && gimple_asm_volatile_p (as_a
<const gasm
*> (s
)))
1895 if (is_gimple_call (s
))
1897 int flags
= gimple_call_flags (s
);
1899 /* An infinite loop is considered a side effect. */
1900 if (!(flags
& (ECF_CONST
| ECF_PURE
))
1901 || (flags
& ECF_LOOPING_CONST_OR_PURE
))
1910 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
1911 Return true if S can trap. When INCLUDE_MEM is true, check whether
1912 the memory operations could trap. When INCLUDE_STORES is true and
1913 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
1916 gimple_could_trap_p_1 (gimple
*s
, bool include_mem
, bool include_stores
)
1918 tree t
, div
= NULL_TREE
;
1923 unsigned i
, start
= (is_gimple_assign (s
) && !include_stores
) ? 1 : 0;
1925 for (i
= start
; i
< gimple_num_ops (s
); i
++)
1926 if (tree_could_trap_p (gimple_op (s
, i
)))
1930 switch (gimple_code (s
))
1933 return gimple_asm_volatile_p (as_a
<gasm
*> (s
));
1936 t
= gimple_call_fndecl (s
);
1937 /* Assume that calls to weak functions may trap. */
1938 if (!t
|| !DECL_P (t
) || DECL_WEAK (t
))
1943 t
= gimple_expr_type (s
);
1944 op
= gimple_assign_rhs_code (s
);
1945 if (get_gimple_rhs_class (op
) == GIMPLE_BINARY_RHS
)
1946 div
= gimple_assign_rhs2 (s
);
1947 return (operation_could_trap_p (op
, FLOAT_TYPE_P (t
),
1948 (INTEGRAL_TYPE_P (t
)
1949 && TYPE_OVERFLOW_TRAPS (t
)),
1953 t
= TREE_TYPE (gimple_cond_lhs (s
));
1954 return operation_could_trap_p (gimple_cond_code (s
),
1955 FLOAT_TYPE_P (t
), false, NULL_TREE
);
1964 /* Return true if statement S can trap. */
1967 gimple_could_trap_p (gimple
*s
)
1969 return gimple_could_trap_p_1 (s
, true, true);
1972 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
1975 gimple_assign_rhs_could_trap_p (gimple
*s
)
1977 gcc_assert (is_gimple_assign (s
));
1978 return gimple_could_trap_p_1 (s
, true, false);
1982 /* Print debugging information for gimple stmts generated. */
1985 dump_gimple_statistics (void)
1987 int i
, total_tuples
= 0, total_bytes
= 0;
1989 if (! GATHER_STATISTICS
)
1991 fprintf (stderr
, "No gimple statistics\n");
1995 fprintf (stderr
, "\nGIMPLE statements\n");
1996 fprintf (stderr
, "Kind Stmts Bytes\n");
1997 fprintf (stderr
, "---------------------------------------\n");
1998 for (i
= 0; i
< (int) gimple_alloc_kind_all
; ++i
)
2000 fprintf (stderr
, "%-20s %7d %10d\n", gimple_alloc_kind_names
[i
],
2001 gimple_alloc_counts
[i
], gimple_alloc_sizes
[i
]);
2002 total_tuples
+= gimple_alloc_counts
[i
];
2003 total_bytes
+= gimple_alloc_sizes
[i
];
2005 fprintf (stderr
, "---------------------------------------\n");
2006 fprintf (stderr
, "%-20s %7d %10d\n", "Total", total_tuples
, total_bytes
);
2007 fprintf (stderr
, "---------------------------------------\n");
2011 /* Return the number of operands needed on the RHS of a GIMPLE
2012 assignment for an expression with tree code CODE. */
2015 get_gimple_rhs_num_ops (enum tree_code code
)
2017 enum gimple_rhs_class rhs_class
= get_gimple_rhs_class (code
);
2019 if (rhs_class
== GIMPLE_UNARY_RHS
|| rhs_class
== GIMPLE_SINGLE_RHS
)
2021 else if (rhs_class
== GIMPLE_BINARY_RHS
)
2023 else if (rhs_class
== GIMPLE_TERNARY_RHS
)
2029 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2031 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2032 : ((TYPE) == tcc_binary \
2033 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2034 : ((TYPE) == tcc_constant \
2035 || (TYPE) == tcc_declaration \
2036 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2037 : ((SYM) == TRUTH_AND_EXPR \
2038 || (SYM) == TRUTH_OR_EXPR \
2039 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2040 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2041 : ((SYM) == COND_EXPR \
2042 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2043 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2044 || (SYM) == DOT_PROD_EXPR \
2045 || (SYM) == SAD_EXPR \
2046 || (SYM) == REALIGN_LOAD_EXPR \
2047 || (SYM) == VEC_COND_EXPR \
2048 || (SYM) == VEC_PERM_EXPR \
2049 || (SYM) == BIT_INSERT_EXPR \
2050 || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS \
2051 : ((SYM) == CONSTRUCTOR \
2052 || (SYM) == OBJ_TYPE_REF \
2053 || (SYM) == ASSERT_EXPR \
2054 || (SYM) == ADDR_EXPR \
2055 || (SYM) == WITH_SIZE_EXPR \
2056 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2057 : GIMPLE_INVALID_RHS),
2058 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2060 const unsigned char gimple_rhs_class_table
[] = {
2061 #include "all-tree.def"
2065 #undef END_OF_BASE_TREE_CODES
2067 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2068 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2069 we failed to create one. */
2072 canonicalize_cond_expr_cond (tree t
)
2074 /* Strip conversions around boolean operations. */
2075 if (CONVERT_EXPR_P (t
)
2076 && (truth_value_p (TREE_CODE (TREE_OPERAND (t
, 0)))
2077 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
2079 t
= TREE_OPERAND (t
, 0);
2081 /* For !x use x == 0. */
2082 if (TREE_CODE (t
) == TRUTH_NOT_EXPR
)
2084 tree top0
= TREE_OPERAND (t
, 0);
2085 t
= build2 (EQ_EXPR
, TREE_TYPE (t
),
2086 top0
, build_int_cst (TREE_TYPE (top0
), 0));
2088 /* For cmp ? 1 : 0 use cmp. */
2089 else if (TREE_CODE (t
) == COND_EXPR
2090 && COMPARISON_CLASS_P (TREE_OPERAND (t
, 0))
2091 && integer_onep (TREE_OPERAND (t
, 1))
2092 && integer_zerop (TREE_OPERAND (t
, 2)))
2094 tree top0
= TREE_OPERAND (t
, 0);
2095 t
= build2 (TREE_CODE (top0
), TREE_TYPE (t
),
2096 TREE_OPERAND (top0
, 0), TREE_OPERAND (top0
, 1));
2098 /* For x ^ y use x != y. */
2099 else if (TREE_CODE (t
) == BIT_XOR_EXPR
)
2100 t
= build2 (NE_EXPR
, TREE_TYPE (t
),
2101 TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1));
2103 if (is_gimple_condexpr (t
))
2109 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2110 the positions marked by the set ARGS_TO_SKIP. */
2113 gimple_call_copy_skip_args (gcall
*stmt
, bitmap args_to_skip
)
2116 int nargs
= gimple_call_num_args (stmt
);
2117 auto_vec
<tree
> vargs (nargs
);
2120 for (i
= 0; i
< nargs
; i
++)
2121 if (!bitmap_bit_p (args_to_skip
, i
))
2122 vargs
.quick_push (gimple_call_arg (stmt
, i
));
2124 if (gimple_call_internal_p (stmt
))
2125 new_stmt
= gimple_build_call_internal_vec (gimple_call_internal_fn (stmt
),
2128 new_stmt
= gimple_build_call_vec (gimple_call_fn (stmt
), vargs
);
2130 if (gimple_call_lhs (stmt
))
2131 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2133 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2134 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
2136 if (gimple_has_location (stmt
))
2137 gimple_set_location (new_stmt
, gimple_location (stmt
));
2138 gimple_call_copy_flags (new_stmt
, stmt
);
2139 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2141 gimple_set_modified (new_stmt
, true);
2148 /* Return true if the field decls F1 and F2 are at the same offset.
2150 This is intended to be used on GIMPLE types only. */
2153 gimple_compare_field_offset (tree f1
, tree f2
)
2155 if (DECL_OFFSET_ALIGN (f1
) == DECL_OFFSET_ALIGN (f2
))
2157 tree offset1
= DECL_FIELD_OFFSET (f1
);
2158 tree offset2
= DECL_FIELD_OFFSET (f2
);
2159 return ((offset1
== offset2
2160 /* Once gimplification is done, self-referential offsets are
2161 instantiated as operand #2 of the COMPONENT_REF built for
2162 each access and reset. Therefore, they are not relevant
2163 anymore and fields are interchangeable provided that they
2164 represent the same access. */
2165 || (TREE_CODE (offset1
) == PLACEHOLDER_EXPR
2166 && TREE_CODE (offset2
) == PLACEHOLDER_EXPR
2167 && (DECL_SIZE (f1
) == DECL_SIZE (f2
)
2168 || (TREE_CODE (DECL_SIZE (f1
)) == PLACEHOLDER_EXPR
2169 && TREE_CODE (DECL_SIZE (f2
)) == PLACEHOLDER_EXPR
)
2170 || operand_equal_p (DECL_SIZE (f1
), DECL_SIZE (f2
), 0))
2171 && DECL_ALIGN (f1
) == DECL_ALIGN (f2
))
2172 || operand_equal_p (offset1
, offset2
, 0))
2173 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1
),
2174 DECL_FIELD_BIT_OFFSET (f2
)));
2177 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2178 should be, so handle differing ones specially by decomposing
2179 the offset into a byte and bit offset manually. */
2180 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1
))
2181 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2
)))
2183 unsigned HOST_WIDE_INT byte_offset1
, byte_offset2
;
2184 unsigned HOST_WIDE_INT bit_offset1
, bit_offset2
;
2185 bit_offset1
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1
));
2186 byte_offset1
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1
))
2187 + bit_offset1
/ BITS_PER_UNIT
);
2188 bit_offset2
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2
));
2189 byte_offset2
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2
))
2190 + bit_offset2
/ BITS_PER_UNIT
);
2191 if (byte_offset1
!= byte_offset2
)
2193 return bit_offset1
% BITS_PER_UNIT
== bit_offset2
% BITS_PER_UNIT
;
2200 /* Return a type the same as TYPE except unsigned or
2201 signed according to UNSIGNEDP. */
2204 gimple_signed_or_unsigned_type (bool unsignedp
, tree type
)
2209 type1
= TYPE_MAIN_VARIANT (type
);
2210 if (type1
== signed_char_type_node
2211 || type1
== char_type_node
2212 || type1
== unsigned_char_type_node
)
2213 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2214 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2215 return unsignedp
? unsigned_type_node
: integer_type_node
;
2216 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2217 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2218 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2219 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2220 if (type1
== long_long_integer_type_node
2221 || type1
== long_long_unsigned_type_node
)
2223 ? long_long_unsigned_type_node
2224 : long_long_integer_type_node
;
2226 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2227 if (int_n_enabled_p
[i
]
2228 && (type1
== int_n_trees
[i
].unsigned_type
2229 || type1
== int_n_trees
[i
].signed_type
))
2231 ? int_n_trees
[i
].unsigned_type
2232 : int_n_trees
[i
].signed_type
;
2234 #if HOST_BITS_PER_WIDE_INT >= 64
2235 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2236 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2238 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2239 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2240 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2241 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2242 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2243 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2244 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2245 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2247 #define GIMPLE_FIXED_TYPES(NAME) \
2248 if (type1 == short_ ## NAME ## _type_node \
2249 || type1 == unsigned_short_ ## NAME ## _type_node) \
2250 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2251 : short_ ## NAME ## _type_node; \
2252 if (type1 == NAME ## _type_node \
2253 || type1 == unsigned_ ## NAME ## _type_node) \
2254 return unsignedp ? unsigned_ ## NAME ## _type_node \
2255 : NAME ## _type_node; \
2256 if (type1 == long_ ## NAME ## _type_node \
2257 || type1 == unsigned_long_ ## NAME ## _type_node) \
2258 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2259 : long_ ## NAME ## _type_node; \
2260 if (type1 == long_long_ ## NAME ## _type_node \
2261 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2262 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2263 : long_long_ ## NAME ## _type_node;
2265 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2266 if (type1 == NAME ## _type_node \
2267 || type1 == u ## NAME ## _type_node) \
2268 return unsignedp ? u ## NAME ## _type_node \
2269 : NAME ## _type_node;
2271 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2272 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2273 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2274 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2275 : sat_ ## short_ ## NAME ## _type_node; \
2276 if (type1 == sat_ ## NAME ## _type_node \
2277 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2278 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2279 : sat_ ## NAME ## _type_node; \
2280 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2281 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2282 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2283 : sat_ ## long_ ## NAME ## _type_node; \
2284 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2285 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2286 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2287 : sat_ ## long_long_ ## NAME ## _type_node;
2289 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2290 if (type1 == sat_ ## NAME ## _type_node \
2291 || type1 == sat_ ## u ## NAME ## _type_node) \
2292 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2293 : sat_ ## NAME ## _type_node;
2295 GIMPLE_FIXED_TYPES (fract
);
2296 GIMPLE_FIXED_TYPES_SAT (fract
);
2297 GIMPLE_FIXED_TYPES (accum
);
2298 GIMPLE_FIXED_TYPES_SAT (accum
);
2300 GIMPLE_FIXED_MODE_TYPES (qq
);
2301 GIMPLE_FIXED_MODE_TYPES (hq
);
2302 GIMPLE_FIXED_MODE_TYPES (sq
);
2303 GIMPLE_FIXED_MODE_TYPES (dq
);
2304 GIMPLE_FIXED_MODE_TYPES (tq
);
2305 GIMPLE_FIXED_MODE_TYPES_SAT (qq
);
2306 GIMPLE_FIXED_MODE_TYPES_SAT (hq
);
2307 GIMPLE_FIXED_MODE_TYPES_SAT (sq
);
2308 GIMPLE_FIXED_MODE_TYPES_SAT (dq
);
2309 GIMPLE_FIXED_MODE_TYPES_SAT (tq
);
2310 GIMPLE_FIXED_MODE_TYPES (ha
);
2311 GIMPLE_FIXED_MODE_TYPES (sa
);
2312 GIMPLE_FIXED_MODE_TYPES (da
);
2313 GIMPLE_FIXED_MODE_TYPES (ta
);
2314 GIMPLE_FIXED_MODE_TYPES_SAT (ha
);
2315 GIMPLE_FIXED_MODE_TYPES_SAT (sa
);
2316 GIMPLE_FIXED_MODE_TYPES_SAT (da
);
2317 GIMPLE_FIXED_MODE_TYPES_SAT (ta
);
2319 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2320 the precision; they have precision set to match their range, but
2321 may use a wider mode to match an ABI. If we change modes, we may
2322 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2323 the precision as well, so as to yield correct results for
2324 bit-field types. C++ does not have these separate bit-field
2325 types, and producing a signed or unsigned variant of an
2326 ENUMERAL_TYPE may cause other problems as well. */
2327 if (!INTEGRAL_TYPE_P (type
)
2328 || TYPE_UNSIGNED (type
) == unsignedp
)
2331 #define TYPE_OK(node) \
2332 (TYPE_MODE (type) == TYPE_MODE (node) \
2333 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2334 if (TYPE_OK (signed_char_type_node
))
2335 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2336 if (TYPE_OK (integer_type_node
))
2337 return unsignedp
? unsigned_type_node
: integer_type_node
;
2338 if (TYPE_OK (short_integer_type_node
))
2339 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2340 if (TYPE_OK (long_integer_type_node
))
2341 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2342 if (TYPE_OK (long_long_integer_type_node
))
2344 ? long_long_unsigned_type_node
2345 : long_long_integer_type_node
);
2347 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2348 if (int_n_enabled_p
[i
]
2349 && TYPE_MODE (type
) == int_n_data
[i
].m
2350 && TYPE_PRECISION (type
) == int_n_data
[i
].bitsize
)
2352 ? int_n_trees
[i
].unsigned_type
2353 : int_n_trees
[i
].signed_type
;
2355 #if HOST_BITS_PER_WIDE_INT >= 64
2356 if (TYPE_OK (intTI_type_node
))
2357 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2359 if (TYPE_OK (intDI_type_node
))
2360 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2361 if (TYPE_OK (intSI_type_node
))
2362 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2363 if (TYPE_OK (intHI_type_node
))
2364 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2365 if (TYPE_OK (intQI_type_node
))
2366 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2368 #undef GIMPLE_FIXED_TYPES
2369 #undef GIMPLE_FIXED_MODE_TYPES
2370 #undef GIMPLE_FIXED_TYPES_SAT
2371 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2374 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2378 /* Return an unsigned type the same as TYPE in other respects. */
2381 gimple_unsigned_type (tree type
)
2383 return gimple_signed_or_unsigned_type (true, type
);
2387 /* Return a signed type the same as TYPE in other respects. */
2390 gimple_signed_type (tree type
)
2392 return gimple_signed_or_unsigned_type (false, type
);
2396 /* Return the typed-based alias set for T, which may be an expression
2397 or a type. Return -1 if we don't do anything special. */
2400 gimple_get_alias_set (tree t
)
2404 /* Permit type-punning when accessing a union, provided the access
2405 is directly through the union. For example, this code does not
2406 permit taking the address of a union member and then storing
2407 through it. Even the type-punning allowed here is a GCC
2408 extension, albeit a common and useful one; the C standard says
2409 that such accesses have implementation-defined behavior. */
2411 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2412 u
= TREE_OPERAND (u
, 0))
2413 if (TREE_CODE (u
) == COMPONENT_REF
2414 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2417 /* That's all the expressions we handle specially. */
2421 /* For convenience, follow the C standard when dealing with
2422 character types. Any object may be accessed via an lvalue that
2423 has character type. */
2424 if (t
== char_type_node
2425 || t
== signed_char_type_node
2426 || t
== unsigned_char_type_node
)
2429 /* Allow aliasing between signed and unsigned variants of the same
2430 type. We treat the signed variant as canonical. */
2431 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2433 tree t1
= gimple_signed_type (t
);
2435 /* t1 == t can happen for boolean nodes which are always unsigned. */
2437 return get_alias_set (t1
);
2444 /* Helper for gimple_ior_addresses_taken_1. */
2447 gimple_ior_addresses_taken_1 (gimple
*, tree addr
, tree
, void *data
)
2449 bitmap addresses_taken
= (bitmap
)data
;
2450 addr
= get_base_address (addr
);
2454 bitmap_set_bit (addresses_taken
, DECL_UID (addr
));
2460 /* Set the bit for the uid of all decls that have their address taken
2461 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2462 were any in this stmt. */
2465 gimple_ior_addresses_taken (bitmap addresses_taken
, gimple
*stmt
)
2467 return walk_stmt_load_store_addr_ops (stmt
, addresses_taken
, NULL
, NULL
,
2468 gimple_ior_addresses_taken_1
);
2472 /* Return true when STMTs arguments and return value match those of FNDECL,
2473 a decl of a builtin function. */
2476 gimple_builtin_call_types_compatible_p (const gimple
*stmt
, tree fndecl
)
2478 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
);
2480 tree ret
= gimple_call_lhs (stmt
);
2482 && !useless_type_conversion_p (TREE_TYPE (ret
),
2483 TREE_TYPE (TREE_TYPE (fndecl
))))
2486 tree targs
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2487 unsigned nargs
= gimple_call_num_args (stmt
);
2488 for (unsigned i
= 0; i
< nargs
; ++i
)
2490 /* Variadic args follow. */
2493 tree arg
= gimple_call_arg (stmt
, i
);
2494 tree type
= TREE_VALUE (targs
);
2495 if (!useless_type_conversion_p (type
, TREE_TYPE (arg
))
2496 /* char/short integral arguments are promoted to int
2497 by several frontends if targetm.calls.promote_prototypes
2498 is true. Allow such promotion too. */
2499 && !(INTEGRAL_TYPE_P (type
)
2500 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)
2501 && targetm
.calls
.promote_prototypes (TREE_TYPE (fndecl
))
2502 && useless_type_conversion_p (integer_type_node
,
2505 targs
= TREE_CHAIN (targs
);
2507 if (targs
&& !VOID_TYPE_P (TREE_VALUE (targs
)))
2512 /* Return true when STMT is builtins call. */
2515 gimple_call_builtin_p (const gimple
*stmt
)
2518 if (is_gimple_call (stmt
)
2519 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2520 && DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
)
2521 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2525 /* Return true when STMT is builtins call to CLASS. */
2528 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_class klass
)
2531 if (is_gimple_call (stmt
)
2532 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2533 && DECL_BUILT_IN_CLASS (fndecl
) == klass
)
2534 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2538 /* Return true when STMT is builtins call to CODE of CLASS. */
2541 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_function code
)
2544 if (is_gimple_call (stmt
)
2545 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2546 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
2547 && DECL_FUNCTION_CODE (fndecl
) == code
)
2548 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2552 /* If CALL is a call to a combined_fn (i.e. an internal function or
2553 a normal built-in function), return its code, otherwise return
2557 gimple_call_combined_fn (const gimple
*stmt
)
2559 if (const gcall
*call
= dyn_cast
<const gcall
*> (stmt
))
2561 if (gimple_call_internal_p (call
))
2562 return as_combined_fn (gimple_call_internal_fn (call
));
2564 tree fndecl
= gimple_call_fndecl (stmt
);
2566 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
2567 && gimple_builtin_call_types_compatible_p (stmt
, fndecl
))
2568 return as_combined_fn (DECL_FUNCTION_CODE (fndecl
));
2573 /* Return true if STMT clobbers memory. STMT is required to be a
2577 gimple_asm_clobbers_memory_p (const gasm
*stmt
)
2581 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
2583 tree op
= gimple_asm_clobber_op (stmt
, i
);
2584 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op
)), "memory") == 0)
2588 /* Non-empty basic ASM implicitly clobbers memory. */
2589 if (gimple_asm_input_p (stmt
) && strlen (gimple_asm_string (stmt
)) != 0)
2595 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2598 dump_decl_set (FILE *file
, bitmap set
)
2605 fprintf (file
, "{ ");
2607 EXECUTE_IF_SET_IN_BITMAP (set
, 0, i
, bi
)
2609 fprintf (file
, "D.%u", i
);
2610 fprintf (file
, " ");
2613 fprintf (file
, "}");
2616 fprintf (file
, "NIL");
2619 /* Return true when CALL is a call stmt that definitely doesn't
2620 free any memory or makes it unavailable otherwise. */
2622 nonfreeing_call_p (gimple
*call
)
2624 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2625 && gimple_call_flags (call
) & ECF_LEAF
)
2626 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call
)))
2628 /* Just in case these become ECF_LEAF in the future. */
2630 case BUILT_IN_TM_FREE
:
2631 case BUILT_IN_REALLOC
:
2632 case BUILT_IN_STACK_RESTORE
:
2637 else if (gimple_call_internal_p (call
))
2638 switch (gimple_call_internal_fn (call
))
2640 case IFN_ABNORMAL_DISPATCHER
:
2643 if (gimple_call_flags (call
) & ECF_LEAF
)
2648 tree fndecl
= gimple_call_fndecl (call
);
2651 struct cgraph_node
*n
= cgraph_node::get (fndecl
);
2654 enum availability availability
;
2655 n
= n
->function_symbol (&availability
);
2656 if (!n
|| availability
<= AVAIL_INTERPOSABLE
)
2658 return n
->nonfreeing_fn
;
2661 /* Return true when CALL is a call stmt that definitely need not
2662 be considered to be a memory barrier. */
2664 nonbarrier_call_p (gimple
*call
)
2666 if (gimple_call_flags (call
) & (ECF_PURE
| ECF_CONST
))
2668 /* Should extend this to have a nonbarrier_fn flag, just as above in
2669 the nonfreeing case. */
2673 /* Callback for walk_stmt_load_store_ops.
2675 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2678 This routine only makes a superficial check for a dereference. Thus
2679 it must only be used if it is safe to return a false negative. */
2681 check_loadstore (gimple
*, tree op
, tree
, void *data
)
2683 if (TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
2685 /* Some address spaces may legitimately dereference zero. */
2686 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (op
));
2687 if (targetm
.addr_space
.zero_address_valid (as
))
2690 return operand_equal_p (TREE_OPERAND (op
, 0), (tree
)data
, 0);
2696 /* Return true if OP can be inferred to be non-NULL after STMT executes,
2697 either by using a pointer dereference or attributes. */
2699 infer_nonnull_range (gimple
*stmt
, tree op
)
2701 return infer_nonnull_range_by_dereference (stmt
, op
)
2702 || infer_nonnull_range_by_attribute (stmt
, op
);
2705 /* Return true if OP can be inferred to be non-NULL after STMT
2706 executes by using a pointer dereference. */
2708 infer_nonnull_range_by_dereference (gimple
*stmt
, tree op
)
2710 /* We can only assume that a pointer dereference will yield
2711 non-NULL if -fdelete-null-pointer-checks is enabled. */
2712 if (!flag_delete_null_pointer_checks
2713 || !POINTER_TYPE_P (TREE_TYPE (op
))
2714 || gimple_code (stmt
) == GIMPLE_ASM
)
2717 if (walk_stmt_load_store_ops (stmt
, (void *)op
,
2718 check_loadstore
, check_loadstore
))
2724 /* Return true if OP can be inferred to be a non-NULL after STMT
2725 executes by using attributes. */
2727 infer_nonnull_range_by_attribute (gimple
*stmt
, tree op
)
2729 /* We can only assume that a pointer dereference will yield
2730 non-NULL if -fdelete-null-pointer-checks is enabled. */
2731 if (!flag_delete_null_pointer_checks
2732 || !POINTER_TYPE_P (TREE_TYPE (op
))
2733 || gimple_code (stmt
) == GIMPLE_ASM
)
2736 if (is_gimple_call (stmt
) && !gimple_call_internal_p (stmt
))
2738 tree fntype
= gimple_call_fntype (stmt
);
2739 tree attrs
= TYPE_ATTRIBUTES (fntype
);
2740 for (; attrs
; attrs
= TREE_CHAIN (attrs
))
2742 attrs
= lookup_attribute ("nonnull", attrs
);
2744 /* If "nonnull" wasn't specified, we know nothing about
2746 if (attrs
== NULL_TREE
)
2749 /* If "nonnull" applies to all the arguments, then ARG
2750 is non-null if it's in the argument list. */
2751 if (TREE_VALUE (attrs
) == NULL_TREE
)
2753 for (unsigned int i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2755 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt
, i
)))
2756 && operand_equal_p (op
, gimple_call_arg (stmt
, i
), 0))
2762 /* Now see if op appears in the nonnull list. */
2763 for (tree t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
2765 unsigned int idx
= TREE_INT_CST_LOW (TREE_VALUE (t
)) - 1;
2766 if (idx
< gimple_call_num_args (stmt
))
2768 tree arg
= gimple_call_arg (stmt
, idx
);
2769 if (operand_equal_p (op
, arg
, 0))
2776 /* If this function is marked as returning non-null, then we can
2777 infer OP is non-null if it is used in the return statement. */
2778 if (greturn
*return_stmt
= dyn_cast
<greturn
*> (stmt
))
2779 if (gimple_return_retval (return_stmt
)
2780 && operand_equal_p (gimple_return_retval (return_stmt
), op
, 0)
2781 && lookup_attribute ("returns_nonnull",
2782 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
))))
2788 /* Compare two case labels. Because the front end should already have
2789 made sure that case ranges do not overlap, it is enough to only compare
2790 the CASE_LOW values of each case label. */
2793 compare_case_labels (const void *p1
, const void *p2
)
2795 const_tree
const case1
= *(const_tree
const*)p1
;
2796 const_tree
const case2
= *(const_tree
const*)p2
;
2798 /* The 'default' case label always goes first. */
2799 if (!CASE_LOW (case1
))
2801 else if (!CASE_LOW (case2
))
2804 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
2807 /* Sort the case labels in LABEL_VEC in place in ascending order. */
2810 sort_case_labels (vec
<tree
> label_vec
)
2812 label_vec
.qsort (compare_case_labels
);
2815 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2817 LABELS is a vector that contains all case labels to look at.
2819 INDEX_TYPE is the type of the switch index expression. Case labels
2820 in LABELS are discarded if their values are not in the value range
2821 covered by INDEX_TYPE. The remaining case label values are folded
2824 If a default case exists in LABELS, it is removed from LABELS and
2825 returned in DEFAULT_CASEP. If no default case exists, but the
2826 case labels already cover the whole range of INDEX_TYPE, a default
2827 case is returned pointing to one of the existing case labels.
2828 Otherwise DEFAULT_CASEP is set to NULL_TREE.
2830 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2831 apply and no action is taken regardless of whether a default case is
2835 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
2837 tree
*default_casep
)
2839 tree min_value
, max_value
;
2840 tree default_case
= NULL_TREE
;
2844 min_value
= TYPE_MIN_VALUE (index_type
);
2845 max_value
= TYPE_MAX_VALUE (index_type
);
2846 while (i
< labels
.length ())
2848 tree elt
= labels
[i
];
2849 tree low
= CASE_LOW (elt
);
2850 tree high
= CASE_HIGH (elt
);
2851 bool remove_element
= FALSE
;
2855 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
2856 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
2858 /* This is a non-default case label, i.e. it has a value.
2860 See if the case label is reachable within the range of
2861 the index type. Remove out-of-range case values. Turn
2862 case ranges into a canonical form (high > low strictly)
2863 and convert the case label values to the index type.
2865 NB: The type of gimple_switch_index() may be the promoted
2866 type, but the case labels retain the original type. */
2870 /* This is a case range. Discard empty ranges.
2871 If the bounds or the range are equal, turn this
2872 into a simple (one-value) case. */
2873 int cmp
= tree_int_cst_compare (high
, low
);
2875 remove_element
= TRUE
;
2882 /* If the simple case value is unreachable, ignore it. */
2883 if ((TREE_CODE (min_value
) == INTEGER_CST
2884 && tree_int_cst_compare (low
, min_value
) < 0)
2885 || (TREE_CODE (max_value
) == INTEGER_CST
2886 && tree_int_cst_compare (low
, max_value
) > 0))
2887 remove_element
= TRUE
;
2889 low
= fold_convert (index_type
, low
);
2893 /* If the entire case range is unreachable, ignore it. */
2894 if ((TREE_CODE (min_value
) == INTEGER_CST
2895 && tree_int_cst_compare (high
, min_value
) < 0)
2896 || (TREE_CODE (max_value
) == INTEGER_CST
2897 && tree_int_cst_compare (low
, max_value
) > 0))
2898 remove_element
= TRUE
;
2901 /* If the lower bound is less than the index type's
2902 minimum value, truncate the range bounds. */
2903 if (TREE_CODE (min_value
) == INTEGER_CST
2904 && tree_int_cst_compare (low
, min_value
) < 0)
2906 low
= fold_convert (index_type
, low
);
2908 /* If the upper bound is greater than the index type's
2909 maximum value, truncate the range bounds. */
2910 if (TREE_CODE (max_value
) == INTEGER_CST
2911 && tree_int_cst_compare (high
, max_value
) > 0)
2913 high
= fold_convert (index_type
, high
);
2915 /* We may have folded a case range to a one-value case. */
2916 if (tree_int_cst_equal (low
, high
))
2921 CASE_LOW (elt
) = low
;
2922 CASE_HIGH (elt
) = high
;
2926 gcc_assert (!default_case
);
2928 /* The default case must be passed separately to the
2929 gimple_build_switch routine. But if DEFAULT_CASEP
2930 is NULL, we do not remove the default case (it would
2931 be completely lost). */
2933 remove_element
= TRUE
;
2937 labels
.ordered_remove (i
);
2943 if (!labels
.is_empty ())
2944 sort_case_labels (labels
);
2946 if (default_casep
&& !default_case
)
2948 /* If the switch has no default label, add one, so that we jump
2949 around the switch body. If the labels already cover the whole
2950 range of the switch index_type, add the default label pointing
2951 to one of the existing labels. */
2953 && TYPE_MIN_VALUE (index_type
)
2954 && TYPE_MAX_VALUE (index_type
)
2955 && tree_int_cst_equal (CASE_LOW (labels
[0]),
2956 TYPE_MIN_VALUE (index_type
)))
2958 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
2960 high
= CASE_LOW (labels
[len
- 1]);
2961 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
2963 for (i
= 1; i
< len
; i
++)
2965 high
= CASE_LOW (labels
[i
]);
2966 low
= CASE_HIGH (labels
[i
- 1]);
2968 low
= CASE_LOW (labels
[i
- 1]);
2969 if (wi::add (low
, 1) != high
)
2974 tree label
= CASE_LABEL (labels
[0]);
2975 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
2983 *default_casep
= default_case
;
2986 /* Set the location of all statements in SEQ to LOC. */
2989 gimple_seq_set_location (gimple_seq seq
, location_t loc
)
2991 for (gimple_stmt_iterator i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
2992 gimple_set_location (gsi_stmt (i
), loc
);
2995 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
2998 gimple_seq_discard (gimple_seq seq
)
3000 gimple_stmt_iterator gsi
;
3002 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); )
3004 gimple
*stmt
= gsi_stmt (gsi
);
3005 gsi_remove (&gsi
, true);
3006 release_defs (stmt
);
3011 /* See if STMT now calls function that takes no parameters and if so, drop
3012 call arguments. This is used when devirtualization machinery redirects
3013 to __builtin_unreachable or __cxa_pure_virtual. */
3016 maybe_remove_unused_call_args (struct function
*fn
, gimple
*stmt
)
3018 tree decl
= gimple_call_fndecl (stmt
);
3019 if (TYPE_ARG_TYPES (TREE_TYPE (decl
))
3020 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
))) == void_type_node
3021 && gimple_call_num_args (stmt
))
3023 gimple_set_num_ops (stmt
, 3);
3024 update_stmt_fn (fn
, stmt
);
3030 namespace selftest
{
3032 /* Selftests for core gimple structures. */
3034 /* Verify that STMT is pretty-printed as EXPECTED.
3035 Helper function for selftests. */
3038 verify_gimple_pp (const char *expected
, gimple
*stmt
)
3041 pp_gimple_stmt_1 (&pp
, stmt
, 0 /* spc */, 0 /* flags */);
3042 ASSERT_STREQ (expected
, pp_formatted_text (&pp
));
3045 /* Build a GIMPLE_ASSIGN equivalent to
3047 and verify various properties of it. */
3050 test_assign_single ()
3052 tree type
= integer_type_node
;
3053 tree lhs
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3054 get_identifier ("tmp"),
3056 tree rhs
= build_int_cst (type
, 5);
3057 gassign
*stmt
= gimple_build_assign (lhs
, rhs
);
3058 verify_gimple_pp ("tmp = 5;", stmt
);
3060 ASSERT_TRUE (is_gimple_assign (stmt
));
3061 ASSERT_EQ (lhs
, gimple_assign_lhs (stmt
));
3062 ASSERT_EQ (lhs
, gimple_get_lhs (stmt
));
3063 ASSERT_EQ (rhs
, gimple_assign_rhs1 (stmt
));
3064 ASSERT_EQ (NULL
, gimple_assign_rhs2 (stmt
));
3065 ASSERT_EQ (NULL
, gimple_assign_rhs3 (stmt
));
3066 ASSERT_TRUE (gimple_assign_single_p (stmt
));
3067 ASSERT_EQ (INTEGER_CST
, gimple_assign_rhs_code (stmt
));
3070 /* Build a GIMPLE_ASSIGN equivalent to
3072 and verify various properties of it. */
3075 test_assign_binop ()
3077 tree type
= integer_type_node
;
3078 tree lhs
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3079 get_identifier ("tmp"),
3081 tree a
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3082 get_identifier ("a"),
3084 tree b
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3085 get_identifier ("b"),
3087 gassign
*stmt
= gimple_build_assign (lhs
, MULT_EXPR
, a
, b
);
3088 verify_gimple_pp ("tmp = a * b;", stmt
);
3090 ASSERT_TRUE (is_gimple_assign (stmt
));
3091 ASSERT_EQ (lhs
, gimple_assign_lhs (stmt
));
3092 ASSERT_EQ (lhs
, gimple_get_lhs (stmt
));
3093 ASSERT_EQ (a
, gimple_assign_rhs1 (stmt
));
3094 ASSERT_EQ (b
, gimple_assign_rhs2 (stmt
));
3095 ASSERT_EQ (NULL
, gimple_assign_rhs3 (stmt
));
3096 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3097 ASSERT_EQ (MULT_EXPR
, gimple_assign_rhs_code (stmt
));
3100 /* Build a GIMPLE_NOP and verify various properties of it. */
3105 gimple
*stmt
= gimple_build_nop ();
3106 verify_gimple_pp ("GIMPLE_NOP", stmt
);
3107 ASSERT_EQ (GIMPLE_NOP
, gimple_code (stmt
));
3108 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3109 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3112 /* Build a GIMPLE_RETURN equivalent to
3114 and verify various properties of it. */
3119 tree type
= integer_type_node
;
3120 tree val
= build_int_cst (type
, 7);
3121 greturn
*stmt
= gimple_build_return (val
);
3122 verify_gimple_pp ("return 7;", stmt
);
3124 ASSERT_EQ (GIMPLE_RETURN
, gimple_code (stmt
));
3125 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3126 ASSERT_EQ (val
, gimple_return_retval (stmt
));
3127 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3130 /* Build a GIMPLE_RETURN equivalent to
3132 and verify various properties of it. */
3135 test_return_without_value ()
3137 greturn
*stmt
= gimple_build_return (NULL
);
3138 verify_gimple_pp ("return;", stmt
);
3140 ASSERT_EQ (GIMPLE_RETURN
, gimple_code (stmt
));
3141 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3142 ASSERT_EQ (NULL
, gimple_return_retval (stmt
));
3143 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3146 /* Run all of the selftests within this file. */
3151 test_assign_single ();
3152 test_assign_binop ();
3154 test_return_stmt ();
3155 test_return_without_value ();
3158 } // namespace selftest
3161 #endif /* CHECKING_P */