1 /* Gimple IR support functions.
3 Copyright (C) 2007-2018 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 #include "gimple-pretty-print.h"
44 #include "stringpool.h"
49 /* All the tuples have their operand vector (if present) at the very bottom
50 of the structure. Therefore, the offset required to find the
51 operands vector the size of the structure minus the size of the 1
52 element tree array at the end (see gimple_ops). */
53 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
54 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
55 EXPORTED_CONST
size_t gimple_ops_offset_
[] = {
56 #include "gsstruct.def"
60 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
61 static const size_t gsstruct_code_size
[] = {
62 #include "gsstruct.def"
66 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
67 const char *const gimple_code_name
[] = {
72 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
73 EXPORTED_CONST
enum gimple_statement_structure_enum gss_for_code_
[] = {
80 uint64_t gimple_alloc_counts
[(int) gimple_alloc_kind_all
];
81 uint64_t gimple_alloc_sizes
[(int) gimple_alloc_kind_all
];
83 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
84 static const char * const gimple_alloc_kind_names
[] = {
91 /* Static gimple tuple members. */
92 const enum gimple_code
gassign::code_
;
93 const enum gimple_code
gcall::code_
;
94 const enum gimple_code
gcond::code_
;
97 /* Gimple tuple constructors.
98 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
99 be passed a NULL to start with an empty sequence. */
101 /* Set the code for statement G to CODE. */
104 gimple_set_code (gimple
*g
, enum gimple_code code
)
109 /* Return the number of bytes needed to hold a GIMPLE statement with
113 gimple_size (enum gimple_code code
)
115 return gsstruct_code_size
[gss_for_code (code
)];
118 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
122 gimple_alloc (enum gimple_code code
, unsigned num_ops MEM_STAT_DECL
)
127 size
= gimple_size (code
);
129 size
+= sizeof (tree
) * (num_ops
- 1);
131 if (GATHER_STATISTICS
)
133 enum gimple_alloc_kind kind
= gimple_alloc_kind (code
);
134 gimple_alloc_counts
[(int) kind
]++;
135 gimple_alloc_sizes
[(int) kind
] += size
;
138 stmt
= ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT
);
139 gimple_set_code (stmt
, code
);
140 gimple_set_num_ops (stmt
, num_ops
);
142 /* Do not call gimple_set_modified here as it has other side
143 effects and this tuple is still not completely built. */
145 gimple_init_singleton (stmt
);
150 /* Set SUBCODE to be the code of the expression computed by statement G. */
153 gimple_set_subcode (gimple
*g
, unsigned subcode
)
155 /* We only have 16 bits for the RHS code. Assert that we are not
157 gcc_assert (subcode
< (1 << 16));
158 g
->subcode
= subcode
;
163 /* Build a tuple with operands. CODE is the statement to build (which
164 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
165 for the new tuple. NUM_OPS is the number of operands to allocate. */
167 #define gimple_build_with_ops(c, s, n) \
168 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
171 gimple_build_with_ops_stat (enum gimple_code code
, unsigned subcode
,
172 unsigned num_ops MEM_STAT_DECL
)
174 gimple
*s
= gimple_alloc (code
, num_ops PASS_MEM_STAT
);
175 gimple_set_subcode (s
, subcode
);
181 /* Build a GIMPLE_RETURN statement returning RETVAL. */
184 gimple_build_return (tree retval
)
187 = as_a
<greturn
*> (gimple_build_with_ops (GIMPLE_RETURN
, ERROR_MARK
,
190 gimple_return_set_retval (s
, retval
);
194 /* Reset alias information on call S. */
197 gimple_call_reset_alias_info (gcall
*s
)
199 if (gimple_call_flags (s
) & ECF_CONST
)
200 memset (gimple_call_use_set (s
), 0, sizeof (struct pt_solution
));
202 pt_solution_reset (gimple_call_use_set (s
));
203 if (gimple_call_flags (s
) & (ECF_CONST
|ECF_PURE
|ECF_NOVOPS
))
204 memset (gimple_call_clobber_set (s
), 0, sizeof (struct pt_solution
));
206 pt_solution_reset (gimple_call_clobber_set (s
));
209 /* Helper for gimple_build_call, gimple_build_call_valist,
210 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
211 components of a GIMPLE_CALL statement to function FN with NARGS
214 static inline gcall
*
215 gimple_build_call_1 (tree fn
, unsigned nargs
)
218 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
220 if (TREE_CODE (fn
) == FUNCTION_DECL
)
221 fn
= build_fold_addr_expr (fn
);
222 gimple_set_op (s
, 1, fn
);
223 gimple_call_set_fntype (s
, TREE_TYPE (TREE_TYPE (fn
)));
224 gimple_call_reset_alias_info (s
);
229 /* Build a GIMPLE_CALL statement to function FN with the arguments
230 specified in vector ARGS. */
233 gimple_build_call_vec (tree fn
, vec
<tree
> args
)
236 unsigned nargs
= args
.length ();
237 gcall
*call
= gimple_build_call_1 (fn
, nargs
);
239 for (i
= 0; i
< nargs
; i
++)
240 gimple_call_set_arg (call
, i
, args
[i
]);
246 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
247 arguments. The ... are the arguments. */
250 gimple_build_call (tree fn
, unsigned nargs
, ...)
256 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
258 call
= gimple_build_call_1 (fn
, nargs
);
260 va_start (ap
, nargs
);
261 for (i
= 0; i
< nargs
; i
++)
262 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
269 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
270 arguments. AP contains the arguments. */
273 gimple_build_call_valist (tree fn
, unsigned nargs
, va_list ap
)
278 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
280 call
= gimple_build_call_1 (fn
, nargs
);
282 for (i
= 0; i
< nargs
; i
++)
283 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
289 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
290 Build the basic components of a GIMPLE_CALL statement to internal
291 function FN with NARGS arguments. */
293 static inline gcall
*
294 gimple_build_call_internal_1 (enum internal_fn fn
, unsigned nargs
)
297 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
299 s
->subcode
|= GF_CALL_INTERNAL
;
300 gimple_call_set_internal_fn (s
, fn
);
301 gimple_call_reset_alias_info (s
);
306 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
307 the number of arguments. The ... are the arguments. */
310 gimple_build_call_internal (enum internal_fn fn
, unsigned nargs
, ...)
316 call
= gimple_build_call_internal_1 (fn
, nargs
);
317 va_start (ap
, nargs
);
318 for (i
= 0; i
< nargs
; i
++)
319 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
326 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
327 specified in vector ARGS. */
330 gimple_build_call_internal_vec (enum internal_fn fn
, vec
<tree
> args
)
335 nargs
= args
.length ();
336 call
= gimple_build_call_internal_1 (fn
, nargs
);
337 for (i
= 0; i
< nargs
; i
++)
338 gimple_call_set_arg (call
, i
, args
[i
]);
344 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
345 assumed to be in GIMPLE form already. Minimal checking is done of
349 gimple_build_call_from_tree (tree t
, tree fnptrtype
)
354 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
356 nargs
= call_expr_nargs (t
);
358 tree fndecl
= NULL_TREE
;
359 if (CALL_EXPR_FN (t
) == NULL_TREE
)
360 call
= gimple_build_call_internal_1 (CALL_EXPR_IFN (t
), nargs
);
363 fndecl
= get_callee_fndecl (t
);
364 call
= gimple_build_call_1 (fndecl
? fndecl
: CALL_EXPR_FN (t
), nargs
);
367 for (i
= 0; i
< nargs
; i
++)
368 gimple_call_set_arg (call
, i
, CALL_EXPR_ARG (t
, i
));
370 gimple_set_block (call
, TREE_BLOCK (t
));
371 gimple_set_location (call
, EXPR_LOCATION (t
));
373 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
374 gimple_call_set_chain (call
, CALL_EXPR_STATIC_CHAIN (t
));
375 gimple_call_set_tail (call
, CALL_EXPR_TAILCALL (t
));
376 gimple_call_set_must_tail (call
, CALL_EXPR_MUST_TAIL_CALL (t
));
377 gimple_call_set_return_slot_opt (call
, CALL_EXPR_RETURN_SLOT_OPT (t
));
379 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
380 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl
)))
381 gimple_call_set_alloca_for_var (call
, CALL_ALLOCA_FOR_VAR_P (t
));
383 gimple_call_set_from_thunk (call
, CALL_FROM_THUNK_P (t
));
384 gimple_call_set_va_arg_pack (call
, CALL_EXPR_VA_ARG_PACK (t
));
385 gimple_call_set_nothrow (call
, TREE_NOTHROW (t
));
386 gimple_call_set_by_descriptor (call
, CALL_EXPR_BY_DESCRIPTOR (t
));
387 gimple_set_no_warning (call
, TREE_NO_WARNING (t
));
388 gimple_call_set_with_bounds (call
, CALL_WITH_BOUNDS_P (t
));
392 gimple_call_set_fntype (call
, TREE_TYPE (fnptrtype
));
394 /* Check if it's an indirect CALL and the type has the
395 nocf_check attribute. In that case propagate the information
396 to the gimple CALL insn. */
399 gcc_assert (POINTER_TYPE_P (fnptrtype
));
400 tree fntype
= TREE_TYPE (fnptrtype
);
402 if (lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (fntype
)))
403 gimple_call_set_nocf_check (call
, TRUE
);
411 /* Build a GIMPLE_ASSIGN statement.
413 LHS of the assignment.
414 RHS of the assignment which can be unary or binary. */
417 gimple_build_assign (tree lhs
, tree rhs MEM_STAT_DECL
)
419 enum tree_code subcode
;
422 extract_ops_from_tree (rhs
, &subcode
, &op1
, &op2
, &op3
);
423 return gimple_build_assign (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
427 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
430 static inline gassign
*
431 gimple_build_assign_1 (tree lhs
, enum tree_code subcode
, tree op1
,
432 tree op2
, tree op3 MEM_STAT_DECL
)
437 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
439 num_ops
= get_gimple_rhs_num_ops (subcode
) + 1;
441 p
= as_a
<gassign
*> (
442 gimple_build_with_ops_stat (GIMPLE_ASSIGN
, (unsigned)subcode
, num_ops
444 gimple_assign_set_lhs (p
, lhs
);
445 gimple_assign_set_rhs1 (p
, op1
);
448 gcc_assert (num_ops
> 2);
449 gimple_assign_set_rhs2 (p
, op2
);
454 gcc_assert (num_ops
> 3);
455 gimple_assign_set_rhs3 (p
, op3
);
461 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
465 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
466 tree op2
, tree op3 MEM_STAT_DECL
)
468 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
471 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
475 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
476 tree op2 MEM_STAT_DECL
)
478 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, NULL_TREE
482 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
485 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1 MEM_STAT_DECL
)
487 return gimple_build_assign_1 (lhs
, subcode
, op1
, NULL_TREE
, NULL_TREE
492 /* Build a GIMPLE_COND statement.
494 PRED is the condition used to compare LHS and the RHS.
495 T_LABEL is the label to jump to if the condition is true.
496 F_LABEL is the label to jump to otherwise. */
499 gimple_build_cond (enum tree_code pred_code
, tree lhs
, tree rhs
,
500 tree t_label
, tree f_label
)
504 gcc_assert (TREE_CODE_CLASS (pred_code
) == tcc_comparison
);
505 p
= as_a
<gcond
*> (gimple_build_with_ops (GIMPLE_COND
, pred_code
, 4));
506 gimple_cond_set_lhs (p
, lhs
);
507 gimple_cond_set_rhs (p
, rhs
);
508 gimple_cond_set_true_label (p
, t_label
);
509 gimple_cond_set_false_label (p
, f_label
);
513 /* Build a GIMPLE_COND statement from the conditional expression tree
514 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
517 gimple_build_cond_from_tree (tree cond
, tree t_label
, tree f_label
)
522 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
523 return gimple_build_cond (code
, lhs
, rhs
, t_label
, f_label
);
526 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
527 boolean expression tree COND. */
530 gimple_cond_set_condition_from_tree (gcond
*stmt
, tree cond
)
535 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
536 gimple_cond_set_condition (stmt
, code
, lhs
, rhs
);
539 /* Build a GIMPLE_LABEL statement for LABEL. */
542 gimple_build_label (tree label
)
545 = as_a
<glabel
*> (gimple_build_with_ops (GIMPLE_LABEL
, ERROR_MARK
, 1));
546 gimple_label_set_label (p
, label
);
550 /* Build a GIMPLE_GOTO statement to label DEST. */
553 gimple_build_goto (tree dest
)
556 = as_a
<ggoto
*> (gimple_build_with_ops (GIMPLE_GOTO
, ERROR_MARK
, 1));
557 gimple_goto_set_dest (p
, dest
);
562 /* Build a GIMPLE_NOP statement. */
565 gimple_build_nop (void)
567 return gimple_alloc (GIMPLE_NOP
, 0);
571 /* Build a GIMPLE_BIND statement.
572 VARS are the variables in BODY.
573 BLOCK is the containing block. */
576 gimple_build_bind (tree vars
, gimple_seq body
, tree block
)
578 gbind
*p
= as_a
<gbind
*> (gimple_alloc (GIMPLE_BIND
, 0));
579 gimple_bind_set_vars (p
, vars
);
581 gimple_bind_set_body (p
, body
);
583 gimple_bind_set_block (p
, block
);
587 /* Helper function to set the simple fields of a asm stmt.
589 STRING is a pointer to a string that is the asm blocks assembly code.
590 NINPUT is the number of register inputs.
591 NOUTPUT is the number of register outputs.
592 NCLOBBERS is the number of clobbered registers.
596 gimple_build_asm_1 (const char *string
, unsigned ninputs
, unsigned noutputs
,
597 unsigned nclobbers
, unsigned nlabels
)
600 int size
= strlen (string
);
602 /* ASMs with labels cannot have outputs. This should have been
603 enforced by the front end. */
604 gcc_assert (nlabels
== 0 || noutputs
== 0);
607 gimple_build_with_ops (GIMPLE_ASM
, ERROR_MARK
,
608 ninputs
+ noutputs
+ nclobbers
+ nlabels
));
614 p
->string
= ggc_alloc_string (string
, size
);
616 if (GATHER_STATISTICS
)
617 gimple_alloc_sizes
[(int) gimple_alloc_kind (GIMPLE_ASM
)] += size
;
622 /* Build a GIMPLE_ASM statement.
624 STRING is the assembly code.
625 NINPUT is the number of register inputs.
626 NOUTPUT is the number of register outputs.
627 NCLOBBERS is the number of clobbered registers.
628 INPUTS is a vector of the input register parameters.
629 OUTPUTS is a vector of the output register parameters.
630 CLOBBERS is a vector of the clobbered register parameters.
631 LABELS is a vector of destination labels. */
634 gimple_build_asm_vec (const char *string
, vec
<tree
, va_gc
> *inputs
,
635 vec
<tree
, va_gc
> *outputs
, vec
<tree
, va_gc
> *clobbers
,
636 vec
<tree
, va_gc
> *labels
)
641 p
= gimple_build_asm_1 (string
,
642 vec_safe_length (inputs
),
643 vec_safe_length (outputs
),
644 vec_safe_length (clobbers
),
645 vec_safe_length (labels
));
647 for (i
= 0; i
< vec_safe_length (inputs
); i
++)
648 gimple_asm_set_input_op (p
, i
, (*inputs
)[i
]);
650 for (i
= 0; i
< vec_safe_length (outputs
); i
++)
651 gimple_asm_set_output_op (p
, i
, (*outputs
)[i
]);
653 for (i
= 0; i
< vec_safe_length (clobbers
); i
++)
654 gimple_asm_set_clobber_op (p
, i
, (*clobbers
)[i
]);
656 for (i
= 0; i
< vec_safe_length (labels
); i
++)
657 gimple_asm_set_label_op (p
, i
, (*labels
)[i
]);
662 /* Build a GIMPLE_CATCH statement.
664 TYPES are the catch types.
665 HANDLER is the exception handler. */
668 gimple_build_catch (tree types
, gimple_seq handler
)
670 gcatch
*p
= as_a
<gcatch
*> (gimple_alloc (GIMPLE_CATCH
, 0));
671 gimple_catch_set_types (p
, types
);
673 gimple_catch_set_handler (p
, handler
);
678 /* Build a GIMPLE_EH_FILTER statement.
680 TYPES are the filter's types.
681 FAILURE is the filter's failure action. */
684 gimple_build_eh_filter (tree types
, gimple_seq failure
)
686 geh_filter
*p
= as_a
<geh_filter
*> (gimple_alloc (GIMPLE_EH_FILTER
, 0));
687 gimple_eh_filter_set_types (p
, types
);
689 gimple_eh_filter_set_failure (p
, failure
);
694 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
697 gimple_build_eh_must_not_throw (tree decl
)
699 geh_mnt
*p
= as_a
<geh_mnt
*> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW
, 0));
701 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
702 gcc_assert (flags_from_decl_or_type (decl
) & ECF_NORETURN
);
703 gimple_eh_must_not_throw_set_fndecl (p
, decl
);
708 /* Build a GIMPLE_EH_ELSE statement. */
711 gimple_build_eh_else (gimple_seq n_body
, gimple_seq e_body
)
713 geh_else
*p
= as_a
<geh_else
*> (gimple_alloc (GIMPLE_EH_ELSE
, 0));
714 gimple_eh_else_set_n_body (p
, n_body
);
715 gimple_eh_else_set_e_body (p
, e_body
);
719 /* Build a GIMPLE_TRY statement.
721 EVAL is the expression to evaluate.
722 CLEANUP is the cleanup expression.
723 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
724 whether this is a try/catch or a try/finally respectively. */
727 gimple_build_try (gimple_seq eval
, gimple_seq cleanup
,
728 enum gimple_try_flags kind
)
732 gcc_assert (kind
== GIMPLE_TRY_CATCH
|| kind
== GIMPLE_TRY_FINALLY
);
733 p
= as_a
<gtry
*> (gimple_alloc (GIMPLE_TRY
, 0));
734 gimple_set_subcode (p
, kind
);
736 gimple_try_set_eval (p
, eval
);
738 gimple_try_set_cleanup (p
, cleanup
);
743 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
745 CLEANUP is the cleanup expression. */
748 gimple_build_wce (gimple_seq cleanup
)
750 gimple
*p
= gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR
, 0);
752 gimple_wce_set_cleanup (p
, cleanup
);
758 /* Build a GIMPLE_RESX statement. */
761 gimple_build_resx (int region
)
764 = as_a
<gresx
*> (gimple_build_with_ops (GIMPLE_RESX
, ERROR_MARK
, 0));
770 /* The helper for constructing a gimple switch statement.
771 INDEX is the switch's index.
772 NLABELS is the number of labels in the switch excluding the default.
773 DEFAULT_LABEL is the default label for the switch statement. */
776 gimple_build_switch_nlabels (unsigned nlabels
, tree index
, tree default_label
)
778 /* nlabels + 1 default label + 1 index. */
779 gcc_checking_assert (default_label
);
780 gswitch
*p
= as_a
<gswitch
*> (gimple_build_with_ops (GIMPLE_SWITCH
,
783 gimple_switch_set_index (p
, index
);
784 gimple_switch_set_default_label (p
, default_label
);
788 /* Build a GIMPLE_SWITCH statement.
790 INDEX is the switch's index.
791 DEFAULT_LABEL is the default label
792 ARGS is a vector of labels excluding the default. */
795 gimple_build_switch (tree index
, tree default_label
, vec
<tree
> args
)
797 unsigned i
, nlabels
= args
.length ();
799 gswitch
*p
= gimple_build_switch_nlabels (nlabels
, index
, default_label
);
801 /* Copy the labels from the vector to the switch statement. */
802 for (i
= 0; i
< nlabels
; i
++)
803 gimple_switch_set_label (p
, i
+ 1, args
[i
]);
808 /* Build a GIMPLE_EH_DISPATCH statement. */
811 gimple_build_eh_dispatch (int region
)
814 = as_a
<geh_dispatch
*> (
815 gimple_build_with_ops (GIMPLE_EH_DISPATCH
, ERROR_MARK
, 0));
820 /* Build a new GIMPLE_DEBUG_BIND statement.
822 VAR is bound to VALUE; block and location are taken from STMT. */
825 gimple_build_debug_bind (tree var
, tree value
, gimple
*stmt MEM_STAT_DECL
)
828 = as_a
<gdebug
*> (gimple_build_with_ops_stat (GIMPLE_DEBUG
,
829 (unsigned)GIMPLE_DEBUG_BIND
, 2
831 gimple_debug_bind_set_var (p
, var
);
832 gimple_debug_bind_set_value (p
, value
);
834 gimple_set_location (p
, gimple_location (stmt
));
840 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
842 VAR is bound to VALUE; block and location are taken from STMT. */
845 gimple_build_debug_source_bind (tree var
, tree value
,
846 gimple
*stmt MEM_STAT_DECL
)
850 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
851 (unsigned)GIMPLE_DEBUG_SOURCE_BIND
, 2
854 gimple_debug_source_bind_set_var (p
, var
);
855 gimple_debug_source_bind_set_value (p
, value
);
857 gimple_set_location (p
, gimple_location (stmt
));
863 /* Build a new GIMPLE_DEBUG_BEGIN_STMT statement in BLOCK at
867 gimple_build_debug_begin_stmt (tree block
, location_t location
872 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
873 (unsigned)GIMPLE_DEBUG_BEGIN_STMT
, 0
876 gimple_set_location (p
, location
);
877 gimple_set_block (p
, block
);
878 cfun
->debug_marker_count
++;
884 /* Build a new GIMPLE_DEBUG_INLINE_ENTRY statement in BLOCK at
885 LOCATION. The BLOCK links to the inlined function. */
888 gimple_build_debug_inline_entry (tree block
, location_t location
893 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
894 (unsigned)GIMPLE_DEBUG_INLINE_ENTRY
, 0
897 gimple_set_location (p
, location
);
898 gimple_set_block (p
, block
);
899 cfun
->debug_marker_count
++;
905 /* Build a GIMPLE_OMP_CRITICAL statement.
907 BODY is the sequence of statements for which only one thread can execute.
908 NAME is optional identifier for this critical block.
909 CLAUSES are clauses for this critical block. */
912 gimple_build_omp_critical (gimple_seq body
, tree name
, tree clauses
)
915 = as_a
<gomp_critical
*> (gimple_alloc (GIMPLE_OMP_CRITICAL
, 0));
916 gimple_omp_critical_set_name (p
, name
);
917 gimple_omp_critical_set_clauses (p
, clauses
);
919 gimple_omp_set_body (p
, body
);
924 /* Build a GIMPLE_OMP_FOR statement.
926 BODY is sequence of statements inside the for loop.
927 KIND is the `for' variant.
928 CLAUSES, are any of the construct's clauses.
929 COLLAPSE is the collapse count.
930 PRE_BODY is the sequence of statements that are loop invariant. */
933 gimple_build_omp_for (gimple_seq body
, int kind
, tree clauses
, size_t collapse
,
936 gomp_for
*p
= as_a
<gomp_for
*> (gimple_alloc (GIMPLE_OMP_FOR
, 0));
938 gimple_omp_set_body (p
, body
);
939 gimple_omp_for_set_clauses (p
, clauses
);
940 gimple_omp_for_set_kind (p
, kind
);
941 p
->collapse
= collapse
;
942 p
->iter
= ggc_cleared_vec_alloc
<gimple_omp_for_iter
> (collapse
);
945 gimple_omp_for_set_pre_body (p
, pre_body
);
951 /* Build a GIMPLE_OMP_PARALLEL statement.
953 BODY is sequence of statements which are executed in parallel.
954 CLAUSES, are the OMP parallel construct's clauses.
955 CHILD_FN is the function created for the parallel threads to execute.
956 DATA_ARG are the shared data argument(s). */
959 gimple_build_omp_parallel (gimple_seq body
, tree clauses
, tree child_fn
,
963 = as_a
<gomp_parallel
*> (gimple_alloc (GIMPLE_OMP_PARALLEL
, 0));
965 gimple_omp_set_body (p
, body
);
966 gimple_omp_parallel_set_clauses (p
, clauses
);
967 gimple_omp_parallel_set_child_fn (p
, child_fn
);
968 gimple_omp_parallel_set_data_arg (p
, data_arg
);
974 /* Build a GIMPLE_OMP_TASK statement.
976 BODY is sequence of statements which are executed by the explicit task.
977 CLAUSES, are the OMP parallel construct's clauses.
978 CHILD_FN is the function created for the parallel threads to execute.
979 DATA_ARG are the shared data argument(s).
980 COPY_FN is the optional function for firstprivate initialization.
981 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
984 gimple_build_omp_task (gimple_seq body
, tree clauses
, tree child_fn
,
985 tree data_arg
, tree copy_fn
, tree arg_size
,
988 gomp_task
*p
= as_a
<gomp_task
*> (gimple_alloc (GIMPLE_OMP_TASK
, 0));
990 gimple_omp_set_body (p
, body
);
991 gimple_omp_task_set_clauses (p
, clauses
);
992 gimple_omp_task_set_child_fn (p
, child_fn
);
993 gimple_omp_task_set_data_arg (p
, data_arg
);
994 gimple_omp_task_set_copy_fn (p
, copy_fn
);
995 gimple_omp_task_set_arg_size (p
, arg_size
);
996 gimple_omp_task_set_arg_align (p
, arg_align
);
1002 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
1004 BODY is the sequence of statements in the section. */
1007 gimple_build_omp_section (gimple_seq body
)
1009 gimple
*p
= gimple_alloc (GIMPLE_OMP_SECTION
, 0);
1011 gimple_omp_set_body (p
, body
);
1017 /* Build a GIMPLE_OMP_MASTER statement.
1019 BODY is the sequence of statements to be executed by just the master. */
1022 gimple_build_omp_master (gimple_seq body
)
1024 gimple
*p
= gimple_alloc (GIMPLE_OMP_MASTER
, 0);
1026 gimple_omp_set_body (p
, body
);
1031 /* Build a GIMPLE_OMP_GRID_BODY statement.
1033 BODY is the sequence of statements to be executed by the kernel. */
1036 gimple_build_omp_grid_body (gimple_seq body
)
1038 gimple
*p
= gimple_alloc (GIMPLE_OMP_GRID_BODY
, 0);
1040 gimple_omp_set_body (p
, body
);
1045 /* Build a GIMPLE_OMP_TASKGROUP statement.
1047 BODY is the sequence of statements to be executed by the taskgroup
1051 gimple_build_omp_taskgroup (gimple_seq body
)
1053 gimple
*p
= gimple_alloc (GIMPLE_OMP_TASKGROUP
, 0);
1055 gimple_omp_set_body (p
, body
);
1061 /* Build a GIMPLE_OMP_CONTINUE statement.
1063 CONTROL_DEF is the definition of the control variable.
1064 CONTROL_USE is the use of the control variable. */
1067 gimple_build_omp_continue (tree control_def
, tree control_use
)
1070 = as_a
<gomp_continue
*> (gimple_alloc (GIMPLE_OMP_CONTINUE
, 0));
1071 gimple_omp_continue_set_control_def (p
, control_def
);
1072 gimple_omp_continue_set_control_use (p
, control_use
);
1076 /* Build a GIMPLE_OMP_ORDERED statement.
1078 BODY is the sequence of statements inside a loop that will executed in
1080 CLAUSES are clauses for this statement. */
1083 gimple_build_omp_ordered (gimple_seq body
, tree clauses
)
1086 = as_a
<gomp_ordered
*> (gimple_alloc (GIMPLE_OMP_ORDERED
, 0));
1087 gimple_omp_ordered_set_clauses (p
, clauses
);
1089 gimple_omp_set_body (p
, body
);
1095 /* Build a GIMPLE_OMP_RETURN statement.
1096 WAIT_P is true if this is a non-waiting return. */
1099 gimple_build_omp_return (bool wait_p
)
1101 gimple
*p
= gimple_alloc (GIMPLE_OMP_RETURN
, 0);
1103 gimple_omp_return_set_nowait (p
);
1109 /* Build a GIMPLE_OMP_SECTIONS statement.
1111 BODY is a sequence of section statements.
1112 CLAUSES are any of the OMP sections contsruct's clauses: private,
1113 firstprivate, lastprivate, reduction, and nowait. */
1116 gimple_build_omp_sections (gimple_seq body
, tree clauses
)
1119 = as_a
<gomp_sections
*> (gimple_alloc (GIMPLE_OMP_SECTIONS
, 0));
1121 gimple_omp_set_body (p
, body
);
1122 gimple_omp_sections_set_clauses (p
, clauses
);
1128 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1131 gimple_build_omp_sections_switch (void)
1133 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH
, 0);
1137 /* Build a GIMPLE_OMP_SINGLE statement.
1139 BODY is the sequence of statements that will be executed once.
1140 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1141 copyprivate, nowait. */
1144 gimple_build_omp_single (gimple_seq body
, tree clauses
)
1147 = as_a
<gomp_single
*> (gimple_alloc (GIMPLE_OMP_SINGLE
, 0));
1149 gimple_omp_set_body (p
, body
);
1150 gimple_omp_single_set_clauses (p
, clauses
);
1156 /* Build a GIMPLE_OMP_TARGET statement.
1158 BODY is the sequence of statements that will be executed.
1159 KIND is the kind of the region.
1160 CLAUSES are any of the construct's clauses. */
1163 gimple_build_omp_target (gimple_seq body
, int kind
, tree clauses
)
1166 = as_a
<gomp_target
*> (gimple_alloc (GIMPLE_OMP_TARGET
, 0));
1168 gimple_omp_set_body (p
, body
);
1169 gimple_omp_target_set_clauses (p
, clauses
);
1170 gimple_omp_target_set_kind (p
, kind
);
1176 /* Build a GIMPLE_OMP_TEAMS statement.
1178 BODY is the sequence of statements that will be executed.
1179 CLAUSES are any of the OMP teams construct's clauses. */
1182 gimple_build_omp_teams (gimple_seq body
, tree clauses
)
1184 gomp_teams
*p
= as_a
<gomp_teams
*> (gimple_alloc (GIMPLE_OMP_TEAMS
, 0));
1186 gimple_omp_set_body (p
, body
);
1187 gimple_omp_teams_set_clauses (p
, clauses
);
1193 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1196 gimple_build_omp_atomic_load (tree lhs
, tree rhs
)
1199 = as_a
<gomp_atomic_load
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD
, 0));
1200 gimple_omp_atomic_load_set_lhs (p
, lhs
);
1201 gimple_omp_atomic_load_set_rhs (p
, rhs
);
1205 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1207 VAL is the value we are storing. */
1210 gimple_build_omp_atomic_store (tree val
)
1212 gomp_atomic_store
*p
1213 = as_a
<gomp_atomic_store
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE
, 0));
1214 gimple_omp_atomic_store_set_val (p
, val
);
1218 /* Build a GIMPLE_TRANSACTION statement. */
1221 gimple_build_transaction (gimple_seq body
)
1224 = as_a
<gtransaction
*> (gimple_alloc (GIMPLE_TRANSACTION
, 0));
1225 gimple_transaction_set_body (p
, body
);
1226 gimple_transaction_set_label_norm (p
, 0);
1227 gimple_transaction_set_label_uninst (p
, 0);
1228 gimple_transaction_set_label_over (p
, 0);
1232 #if defined ENABLE_GIMPLE_CHECKING
1233 /* Complain of a gimple type mismatch and die. */
1236 gimple_check_failed (const gimple
*gs
, const char *file
, int line
,
1237 const char *function
, enum gimple_code code
,
1238 enum tree_code subcode
)
1240 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1241 gimple_code_name
[code
],
1242 get_tree_code_name (subcode
),
1243 gimple_code_name
[gimple_code (gs
)],
1245 ? get_tree_code_name ((enum tree_code
) gs
->subcode
)
1247 function
, trim_filename (file
), line
);
1249 #endif /* ENABLE_GIMPLE_CHECKING */
1252 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1253 *SEQ_P is NULL, a new sequence is allocated. */
1256 gimple_seq_add_stmt (gimple_seq
*seq_p
, gimple
*gs
)
1258 gimple_stmt_iterator si
;
1262 si
= gsi_last (*seq_p
);
1263 gsi_insert_after (&si
, gs
, GSI_NEW_STMT
);
1266 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1267 *SEQ_P is NULL, a new sequence is allocated. This function is
1268 similar to gimple_seq_add_stmt, but does not scan the operands.
1269 During gimplification, we need to manipulate statement sequences
1270 before the def/use vectors have been constructed. */
1273 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple
*gs
)
1275 gimple_stmt_iterator si
;
1280 si
= gsi_last (*seq_p
);
1281 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
1284 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1285 NULL, a new sequence is allocated. */
1288 gimple_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
1290 gimple_stmt_iterator si
;
1294 si
= gsi_last (*dst_p
);
1295 gsi_insert_seq_after (&si
, src
, GSI_NEW_STMT
);
1298 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1299 NULL, a new sequence is allocated. This function is
1300 similar to gimple_seq_add_seq, but does not scan the operands. */
1303 gimple_seq_add_seq_without_update (gimple_seq
*dst_p
, gimple_seq src
)
1305 gimple_stmt_iterator si
;
1309 si
= gsi_last (*dst_p
);
1310 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
1313 /* Determine whether to assign a location to the statement GS. */
1316 should_carry_location_p (gimple
*gs
)
1318 /* Don't emit a line note for a label. We particularly don't want to
1319 emit one for the break label, since it doesn't actually correspond
1320 to the beginning of the loop/switch. */
1321 if (gimple_code (gs
) == GIMPLE_LABEL
)
1327 /* Set the location for gimple statement GS to LOCATION. */
1330 annotate_one_with_location (gimple
*gs
, location_t location
)
1332 if (!gimple_has_location (gs
)
1333 && !gimple_do_not_emit_location_p (gs
)
1334 && should_carry_location_p (gs
))
1335 gimple_set_location (gs
, location
);
1338 /* Set LOCATION for all the statements after iterator GSI in sequence
1339 SEQ. If GSI is pointing to the end of the sequence, start with the
1340 first statement in SEQ. */
1343 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
1344 location_t location
)
1346 if (gsi_end_p (gsi
))
1347 gsi
= gsi_start (seq
);
1351 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
1352 annotate_one_with_location (gsi_stmt (gsi
), location
);
1355 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1358 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
1360 gimple_stmt_iterator i
;
1362 if (gimple_seq_empty_p (stmt_p
))
1365 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
1367 gimple
*gs
= gsi_stmt (i
);
1368 annotate_one_with_location (gs
, location
);
1372 /* Helper function of empty_body_p. Return true if STMT is an empty
1376 empty_stmt_p (gimple
*stmt
)
1378 if (gimple_code (stmt
) == GIMPLE_NOP
)
1380 if (gbind
*bind_stmt
= dyn_cast
<gbind
*> (stmt
))
1381 return empty_body_p (gimple_bind_body (bind_stmt
));
1386 /* Return true if BODY contains nothing but empty statements. */
1389 empty_body_p (gimple_seq body
)
1391 gimple_stmt_iterator i
;
1393 if (gimple_seq_empty_p (body
))
1395 for (i
= gsi_start (body
); !gsi_end_p (i
); gsi_next (&i
))
1396 if (!empty_stmt_p (gsi_stmt (i
))
1397 && !is_gimple_debug (gsi_stmt (i
)))
1404 /* Perform a deep copy of sequence SRC and return the result. */
1407 gimple_seq_copy (gimple_seq src
)
1409 gimple_stmt_iterator gsi
;
1410 gimple_seq new_seq
= NULL
;
1413 for (gsi
= gsi_start (src
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1415 stmt
= gimple_copy (gsi_stmt (gsi
));
1416 gimple_seq_add_stmt (&new_seq
, stmt
);
1424 /* Return true if calls C1 and C2 are known to go to the same function. */
1427 gimple_call_same_target_p (const gimple
*c1
, const gimple
*c2
)
1429 if (gimple_call_internal_p (c1
))
1430 return (gimple_call_internal_p (c2
)
1431 && gimple_call_internal_fn (c1
) == gimple_call_internal_fn (c2
)
1432 && (!gimple_call_internal_unique_p (as_a
<const gcall
*> (c1
))
1435 return (gimple_call_fn (c1
) == gimple_call_fn (c2
)
1436 || (gimple_call_fndecl (c1
)
1437 && gimple_call_fndecl (c1
) == gimple_call_fndecl (c2
)));
1440 /* Detect flags from a GIMPLE_CALL. This is just like
1441 call_expr_flags, but for gimple tuples. */
1444 gimple_call_flags (const gimple
*stmt
)
1447 tree decl
= gimple_call_fndecl (stmt
);
1450 flags
= flags_from_decl_or_type (decl
);
1451 else if (gimple_call_internal_p (stmt
))
1452 flags
= internal_fn_flags (gimple_call_internal_fn (stmt
));
1454 flags
= flags_from_decl_or_type (gimple_call_fntype (stmt
));
1456 if (stmt
->subcode
& GF_CALL_NOTHROW
)
1457 flags
|= ECF_NOTHROW
;
1459 if (stmt
->subcode
& GF_CALL_BY_DESCRIPTOR
)
1460 flags
|= ECF_BY_DESCRIPTOR
;
1465 /* Return the "fn spec" string for call STMT. */
1468 gimple_call_fnspec (const gcall
*stmt
)
1472 if (gimple_call_internal_p (stmt
))
1473 return internal_fn_fnspec (gimple_call_internal_fn (stmt
));
1475 type
= gimple_call_fntype (stmt
);
1479 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
1483 return TREE_VALUE (TREE_VALUE (attr
));
1486 /* Detects argument flags for argument number ARG on call STMT. */
1489 gimple_call_arg_flags (const gcall
*stmt
, unsigned arg
)
1491 const_tree attr
= gimple_call_fnspec (stmt
);
1493 if (!attr
|| 1 + arg
>= (unsigned) TREE_STRING_LENGTH (attr
))
1496 switch (TREE_STRING_POINTER (attr
)[1 + arg
])
1503 return EAF_DIRECT
| EAF_NOCLOBBER
| EAF_NOESCAPE
;
1506 return EAF_NOCLOBBER
| EAF_NOESCAPE
;
1509 return EAF_DIRECT
| EAF_NOESCAPE
;
1512 return EAF_NOESCAPE
;
1520 /* Detects return flags for the call STMT. */
1523 gimple_call_return_flags (const gcall
*stmt
)
1527 if (gimple_call_flags (stmt
) & ECF_MALLOC
)
1530 attr
= gimple_call_fnspec (stmt
);
1531 if (!attr
|| TREE_STRING_LENGTH (attr
) < 1)
1534 switch (TREE_STRING_POINTER (attr
)[0])
1540 return ERF_RETURNS_ARG
| (TREE_STRING_POINTER (attr
)[0] - '1');
1552 /* Return true if GS is a copy assignment. */
1555 gimple_assign_copy_p (gimple
*gs
)
1557 return (gimple_assign_single_p (gs
)
1558 && is_gimple_val (gimple_op (gs
, 1)));
1562 /* Return true if GS is a SSA_NAME copy assignment. */
1565 gimple_assign_ssa_name_copy_p (gimple
*gs
)
1567 return (gimple_assign_single_p (gs
)
1568 && TREE_CODE (gimple_assign_lhs (gs
)) == SSA_NAME
1569 && TREE_CODE (gimple_assign_rhs1 (gs
)) == SSA_NAME
);
1573 /* Return true if GS is an assignment with a unary RHS, but the
1574 operator has no effect on the assigned value. The logic is adapted
1575 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1576 instances in which STRIP_NOPS was previously applied to the RHS of
1579 NOTE: In the use cases that led to the creation of this function
1580 and of gimple_assign_single_p, it is typical to test for either
1581 condition and to proceed in the same manner. In each case, the
1582 assigned value is represented by the single RHS operand of the
1583 assignment. I suspect there may be cases where gimple_assign_copy_p,
1584 gimple_assign_single_p, or equivalent logic is used where a similar
1585 treatment of unary NOPs is appropriate. */
1588 gimple_assign_unary_nop_p (gimple
*gs
)
1590 return (is_gimple_assign (gs
)
1591 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs
))
1592 || gimple_assign_rhs_code (gs
) == NON_LVALUE_EXPR
)
1593 && gimple_assign_rhs1 (gs
) != error_mark_node
1594 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs
)))
1595 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs
)))));
1598 /* Set BB to be the basic block holding G. */
1601 gimple_set_bb (gimple
*stmt
, basic_block bb
)
1605 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1608 /* If the statement is a label, add the label to block-to-labels map
1609 so that we can speed up edge creation for GIMPLE_GOTOs. */
1615 t
= gimple_label_label (as_a
<glabel
*> (stmt
));
1616 uid
= LABEL_DECL_UID (t
);
1620 vec_safe_length (label_to_block_map_for_fn (cfun
));
1621 LABEL_DECL_UID (t
) = uid
= cfun
->cfg
->last_label_uid
++;
1622 if (old_len
<= (unsigned) uid
)
1624 unsigned new_len
= 3 * uid
/ 2 + 1;
1626 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun
),
1631 (*label_to_block_map_for_fn (cfun
))[uid
] = bb
;
1636 /* Modify the RHS of the assignment pointed-to by GSI using the
1637 operands in the expression tree EXPR.
1639 NOTE: The statement pointed-to by GSI may be reallocated if it
1640 did not have enough operand slots.
1642 This function is useful to convert an existing tree expression into
1643 the flat representation used for the RHS of a GIMPLE assignment.
1644 It will reallocate memory as needed to expand or shrink the number
1645 of operand slots needed to represent EXPR.
1647 NOTE: If you find yourself building a tree and then calling this
1648 function, you are most certainly doing it the slow way. It is much
1649 better to build a new assignment or to use the function
1650 gimple_assign_set_rhs_with_ops, which does not require an
1651 expression tree to be built. */
1654 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*gsi
, tree expr
)
1656 enum tree_code subcode
;
1659 extract_ops_from_tree (expr
, &subcode
, &op1
, &op2
, &op3
);
1660 gimple_assign_set_rhs_with_ops (gsi
, subcode
, op1
, op2
, op3
);
1664 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1665 operands OP1, OP2 and OP3.
1667 NOTE: The statement pointed-to by GSI may be reallocated if it
1668 did not have enough operand slots. */
1671 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*gsi
, enum tree_code code
,
1672 tree op1
, tree op2
, tree op3
)
1674 unsigned new_rhs_ops
= get_gimple_rhs_num_ops (code
);
1675 gimple
*stmt
= gsi_stmt (*gsi
);
1677 /* If the new CODE needs more operands, allocate a new statement. */
1678 if (gimple_num_ops (stmt
) < new_rhs_ops
+ 1)
1680 tree lhs
= gimple_assign_lhs (stmt
);
1681 gimple
*new_stmt
= gimple_alloc (gimple_code (stmt
), new_rhs_ops
+ 1);
1682 memcpy (new_stmt
, stmt
, gimple_size (gimple_code (stmt
)));
1683 gimple_init_singleton (new_stmt
);
1684 gsi_replace (gsi
, new_stmt
, false);
1687 /* The LHS needs to be reset as this also changes the SSA name
1689 gimple_assign_set_lhs (stmt
, lhs
);
1692 gimple_set_num_ops (stmt
, new_rhs_ops
+ 1);
1693 gimple_set_subcode (stmt
, code
);
1694 gimple_assign_set_rhs1 (stmt
, op1
);
1695 if (new_rhs_ops
> 1)
1696 gimple_assign_set_rhs2 (stmt
, op2
);
1697 if (new_rhs_ops
> 2)
1698 gimple_assign_set_rhs3 (stmt
, op3
);
1702 /* Return the LHS of a statement that performs an assignment,
1703 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1704 for a call to a function that returns no value, or for a
1705 statement other than an assignment or a call. */
1708 gimple_get_lhs (const gimple
*stmt
)
1710 enum gimple_code code
= gimple_code (stmt
);
1712 if (code
== GIMPLE_ASSIGN
)
1713 return gimple_assign_lhs (stmt
);
1714 else if (code
== GIMPLE_CALL
)
1715 return gimple_call_lhs (stmt
);
1721 /* Set the LHS of a statement that performs an assignment,
1722 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1725 gimple_set_lhs (gimple
*stmt
, tree lhs
)
1727 enum gimple_code code
= gimple_code (stmt
);
1729 if (code
== GIMPLE_ASSIGN
)
1730 gimple_assign_set_lhs (stmt
, lhs
);
1731 else if (code
== GIMPLE_CALL
)
1732 gimple_call_set_lhs (stmt
, lhs
);
1738 /* Return a deep copy of statement STMT. All the operands from STMT
1739 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1740 and VUSE operand arrays are set to empty in the new copy. The new
1741 copy isn't part of any sequence. */
1744 gimple_copy (gimple
*stmt
)
1746 enum gimple_code code
= gimple_code (stmt
);
1747 unsigned num_ops
= gimple_num_ops (stmt
);
1748 gimple
*copy
= gimple_alloc (code
, num_ops
);
1751 /* Shallow copy all the fields from STMT. */
1752 memcpy (copy
, stmt
, gimple_size (code
));
1753 gimple_init_singleton (copy
);
1755 /* If STMT has sub-statements, deep-copy them as well. */
1756 if (gimple_has_substatements (stmt
))
1761 switch (gimple_code (stmt
))
1765 gbind
*bind_stmt
= as_a
<gbind
*> (stmt
);
1766 gbind
*bind_copy
= as_a
<gbind
*> (copy
);
1767 new_seq
= gimple_seq_copy (gimple_bind_body (bind_stmt
));
1768 gimple_bind_set_body (bind_copy
, new_seq
);
1769 gimple_bind_set_vars (bind_copy
,
1770 unshare_expr (gimple_bind_vars (bind_stmt
)));
1771 gimple_bind_set_block (bind_copy
, gimple_bind_block (bind_stmt
));
1777 gcatch
*catch_stmt
= as_a
<gcatch
*> (stmt
);
1778 gcatch
*catch_copy
= as_a
<gcatch
*> (copy
);
1779 new_seq
= gimple_seq_copy (gimple_catch_handler (catch_stmt
));
1780 gimple_catch_set_handler (catch_copy
, new_seq
);
1781 t
= unshare_expr (gimple_catch_types (catch_stmt
));
1782 gimple_catch_set_types (catch_copy
, t
);
1786 case GIMPLE_EH_FILTER
:
1788 geh_filter
*eh_filter_stmt
= as_a
<geh_filter
*> (stmt
);
1789 geh_filter
*eh_filter_copy
= as_a
<geh_filter
*> (copy
);
1791 = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt
));
1792 gimple_eh_filter_set_failure (eh_filter_copy
, new_seq
);
1793 t
= unshare_expr (gimple_eh_filter_types (eh_filter_stmt
));
1794 gimple_eh_filter_set_types (eh_filter_copy
, t
);
1798 case GIMPLE_EH_ELSE
:
1800 geh_else
*eh_else_stmt
= as_a
<geh_else
*> (stmt
);
1801 geh_else
*eh_else_copy
= as_a
<geh_else
*> (copy
);
1802 new_seq
= gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt
));
1803 gimple_eh_else_set_n_body (eh_else_copy
, new_seq
);
1804 new_seq
= gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt
));
1805 gimple_eh_else_set_e_body (eh_else_copy
, new_seq
);
1811 gtry
*try_stmt
= as_a
<gtry
*> (stmt
);
1812 gtry
*try_copy
= as_a
<gtry
*> (copy
);
1813 new_seq
= gimple_seq_copy (gimple_try_eval (try_stmt
));
1814 gimple_try_set_eval (try_copy
, new_seq
);
1815 new_seq
= gimple_seq_copy (gimple_try_cleanup (try_stmt
));
1816 gimple_try_set_cleanup (try_copy
, new_seq
);
1820 case GIMPLE_OMP_FOR
:
1821 new_seq
= gimple_seq_copy (gimple_omp_for_pre_body (stmt
));
1822 gimple_omp_for_set_pre_body (copy
, new_seq
);
1823 t
= unshare_expr (gimple_omp_for_clauses (stmt
));
1824 gimple_omp_for_set_clauses (copy
, t
);
1826 gomp_for
*omp_for_copy
= as_a
<gomp_for
*> (copy
);
1827 omp_for_copy
->iter
= ggc_vec_alloc
<gimple_omp_for_iter
>
1828 ( gimple_omp_for_collapse (stmt
));
1830 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1832 gimple_omp_for_set_cond (copy
, i
,
1833 gimple_omp_for_cond (stmt
, i
));
1834 gimple_omp_for_set_index (copy
, i
,
1835 gimple_omp_for_index (stmt
, i
));
1836 t
= unshare_expr (gimple_omp_for_initial (stmt
, i
));
1837 gimple_omp_for_set_initial (copy
, i
, t
);
1838 t
= unshare_expr (gimple_omp_for_final (stmt
, i
));
1839 gimple_omp_for_set_final (copy
, i
, t
);
1840 t
= unshare_expr (gimple_omp_for_incr (stmt
, i
));
1841 gimple_omp_for_set_incr (copy
, i
, t
);
1845 case GIMPLE_OMP_PARALLEL
:
1847 gomp_parallel
*omp_par_stmt
= as_a
<gomp_parallel
*> (stmt
);
1848 gomp_parallel
*omp_par_copy
= as_a
<gomp_parallel
*> (copy
);
1849 t
= unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt
));
1850 gimple_omp_parallel_set_clauses (omp_par_copy
, t
);
1851 t
= unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt
));
1852 gimple_omp_parallel_set_child_fn (omp_par_copy
, t
);
1853 t
= unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt
));
1854 gimple_omp_parallel_set_data_arg (omp_par_copy
, t
);
1858 case GIMPLE_OMP_TASK
:
1859 t
= unshare_expr (gimple_omp_task_clauses (stmt
));
1860 gimple_omp_task_set_clauses (copy
, t
);
1861 t
= unshare_expr (gimple_omp_task_child_fn (stmt
));
1862 gimple_omp_task_set_child_fn (copy
, t
);
1863 t
= unshare_expr (gimple_omp_task_data_arg (stmt
));
1864 gimple_omp_task_set_data_arg (copy
, t
);
1865 t
= unshare_expr (gimple_omp_task_copy_fn (stmt
));
1866 gimple_omp_task_set_copy_fn (copy
, t
);
1867 t
= unshare_expr (gimple_omp_task_arg_size (stmt
));
1868 gimple_omp_task_set_arg_size (copy
, t
);
1869 t
= unshare_expr (gimple_omp_task_arg_align (stmt
));
1870 gimple_omp_task_set_arg_align (copy
, t
);
1873 case GIMPLE_OMP_CRITICAL
:
1874 t
= unshare_expr (gimple_omp_critical_name
1875 (as_a
<gomp_critical
*> (stmt
)));
1876 gimple_omp_critical_set_name (as_a
<gomp_critical
*> (copy
), t
);
1877 t
= unshare_expr (gimple_omp_critical_clauses
1878 (as_a
<gomp_critical
*> (stmt
)));
1879 gimple_omp_critical_set_clauses (as_a
<gomp_critical
*> (copy
), t
);
1882 case GIMPLE_OMP_ORDERED
:
1883 t
= unshare_expr (gimple_omp_ordered_clauses
1884 (as_a
<gomp_ordered
*> (stmt
)));
1885 gimple_omp_ordered_set_clauses (as_a
<gomp_ordered
*> (copy
), t
);
1888 case GIMPLE_OMP_SECTIONS
:
1889 t
= unshare_expr (gimple_omp_sections_clauses (stmt
));
1890 gimple_omp_sections_set_clauses (copy
, t
);
1891 t
= unshare_expr (gimple_omp_sections_control (stmt
));
1892 gimple_omp_sections_set_control (copy
, t
);
1895 case GIMPLE_OMP_SINGLE
:
1897 gomp_single
*omp_single_copy
= as_a
<gomp_single
*> (copy
);
1898 t
= unshare_expr (gimple_omp_single_clauses (stmt
));
1899 gimple_omp_single_set_clauses (omp_single_copy
, t
);
1903 case GIMPLE_OMP_TARGET
:
1905 gomp_target
*omp_target_stmt
= as_a
<gomp_target
*> (stmt
);
1906 gomp_target
*omp_target_copy
= as_a
<gomp_target
*> (copy
);
1907 t
= unshare_expr (gimple_omp_target_clauses (omp_target_stmt
));
1908 gimple_omp_target_set_clauses (omp_target_copy
, t
);
1909 t
= unshare_expr (gimple_omp_target_data_arg (omp_target_stmt
));
1910 gimple_omp_target_set_data_arg (omp_target_copy
, t
);
1914 case GIMPLE_OMP_TEAMS
:
1916 gomp_teams
*omp_teams_copy
= as_a
<gomp_teams
*> (copy
);
1917 t
= unshare_expr (gimple_omp_teams_clauses (stmt
));
1918 gimple_omp_teams_set_clauses (omp_teams_copy
, t
);
1922 case GIMPLE_OMP_SECTION
:
1923 case GIMPLE_OMP_MASTER
:
1924 case GIMPLE_OMP_TASKGROUP
:
1925 case GIMPLE_OMP_GRID_BODY
:
1927 new_seq
= gimple_seq_copy (gimple_omp_body (stmt
));
1928 gimple_omp_set_body (copy
, new_seq
);
1931 case GIMPLE_TRANSACTION
:
1932 new_seq
= gimple_seq_copy (gimple_transaction_body (
1933 as_a
<gtransaction
*> (stmt
)));
1934 gimple_transaction_set_body (as_a
<gtransaction
*> (copy
),
1938 case GIMPLE_WITH_CLEANUP_EXPR
:
1939 new_seq
= gimple_seq_copy (gimple_wce_cleanup (stmt
));
1940 gimple_wce_set_cleanup (copy
, new_seq
);
1948 /* Make copy of operands. */
1949 for (i
= 0; i
< num_ops
; i
++)
1950 gimple_set_op (copy
, i
, unshare_expr (gimple_op (stmt
, i
)));
1952 if (gimple_has_mem_ops (stmt
))
1954 gimple_set_vdef (copy
, gimple_vdef (stmt
));
1955 gimple_set_vuse (copy
, gimple_vuse (stmt
));
1958 /* Clear out SSA operand vectors on COPY. */
1959 if (gimple_has_ops (stmt
))
1961 gimple_set_use_ops (copy
, NULL
);
1963 /* SSA operands need to be updated. */
1964 gimple_set_modified (copy
, true);
1967 if (gimple_debug_nonbind_marker_p (stmt
))
1968 cfun
->debug_marker_count
++;
1974 /* Return true if statement S has side-effects. We consider a
1975 statement to have side effects if:
1977 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
1978 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
1981 gimple_has_side_effects (const gimple
*s
)
1983 if (is_gimple_debug (s
))
1986 /* We don't have to scan the arguments to check for
1987 volatile arguments, though, at present, we still
1988 do a scan to check for TREE_SIDE_EFFECTS. */
1989 if (gimple_has_volatile_ops (s
))
1992 if (gimple_code (s
) == GIMPLE_ASM
1993 && gimple_asm_volatile_p (as_a
<const gasm
*> (s
)))
1996 if (is_gimple_call (s
))
1998 int flags
= gimple_call_flags (s
);
2000 /* An infinite loop is considered a side effect. */
2001 if (!(flags
& (ECF_CONST
| ECF_PURE
))
2002 || (flags
& ECF_LOOPING_CONST_OR_PURE
))
2011 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
2012 Return true if S can trap. When INCLUDE_MEM is true, check whether
2013 the memory operations could trap. When INCLUDE_STORES is true and
2014 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
2017 gimple_could_trap_p_1 (gimple
*s
, bool include_mem
, bool include_stores
)
2019 tree t
, div
= NULL_TREE
;
2024 unsigned i
, start
= (is_gimple_assign (s
) && !include_stores
) ? 1 : 0;
2026 for (i
= start
; i
< gimple_num_ops (s
); i
++)
2027 if (tree_could_trap_p (gimple_op (s
, i
)))
2031 switch (gimple_code (s
))
2034 return gimple_asm_volatile_p (as_a
<gasm
*> (s
));
2037 t
= gimple_call_fndecl (s
);
2038 /* Assume that calls to weak functions may trap. */
2039 if (!t
|| !DECL_P (t
) || DECL_WEAK (t
))
2044 t
= gimple_expr_type (s
);
2045 op
= gimple_assign_rhs_code (s
);
2046 if (get_gimple_rhs_class (op
) == GIMPLE_BINARY_RHS
)
2047 div
= gimple_assign_rhs2 (s
);
2048 return (operation_could_trap_p (op
, FLOAT_TYPE_P (t
),
2049 (INTEGRAL_TYPE_P (t
)
2050 && TYPE_OVERFLOW_TRAPS (t
)),
2054 t
= TREE_TYPE (gimple_cond_lhs (s
));
2055 return operation_could_trap_p (gimple_cond_code (s
),
2056 FLOAT_TYPE_P (t
), false, NULL_TREE
);
2065 /* Return true if statement S can trap. */
2068 gimple_could_trap_p (gimple
*s
)
2070 return gimple_could_trap_p_1 (s
, true, true);
2073 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
2076 gimple_assign_rhs_could_trap_p (gimple
*s
)
2078 gcc_assert (is_gimple_assign (s
));
2079 return gimple_could_trap_p_1 (s
, true, false);
2083 /* Print debugging information for gimple stmts generated. */
2086 dump_gimple_statistics (void)
2089 uint64_t total_tuples
= 0, total_bytes
= 0;
2091 if (! GATHER_STATISTICS
)
2093 fprintf (stderr
, "No GIMPLE statistics\n");
2097 fprintf (stderr
, "\nGIMPLE statements\n");
2098 fprintf (stderr
, "Kind Stmts Bytes\n");
2099 fprintf (stderr
, "---------------------------------------\n");
2100 for (i
= 0; i
< (int) gimple_alloc_kind_all
; ++i
)
2102 fprintf (stderr
, "%-20s %7" PRIu64
" %10" PRIu64
"\n",
2103 gimple_alloc_kind_names
[i
], gimple_alloc_counts
[i
],
2104 gimple_alloc_sizes
[i
]);
2105 total_tuples
+= gimple_alloc_counts
[i
];
2106 total_bytes
+= gimple_alloc_sizes
[i
];
2108 fprintf (stderr
, "---------------------------------------\n");
2109 fprintf (stderr
, "%-20s %7" PRIu64
" %10" PRIu64
"\n", "Total",
2110 total_tuples
, total_bytes
);
2111 fprintf (stderr
, "---------------------------------------\n");
2115 /* Return the number of operands needed on the RHS of a GIMPLE
2116 assignment for an expression with tree code CODE. */
2119 get_gimple_rhs_num_ops (enum tree_code code
)
2121 enum gimple_rhs_class rhs_class
= get_gimple_rhs_class (code
);
2123 if (rhs_class
== GIMPLE_UNARY_RHS
|| rhs_class
== GIMPLE_SINGLE_RHS
)
2125 else if (rhs_class
== GIMPLE_BINARY_RHS
)
2127 else if (rhs_class
== GIMPLE_TERNARY_RHS
)
2133 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2135 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2136 : ((TYPE) == tcc_binary \
2137 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2138 : ((TYPE) == tcc_constant \
2139 || (TYPE) == tcc_declaration \
2140 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2141 : ((SYM) == TRUTH_AND_EXPR \
2142 || (SYM) == TRUTH_OR_EXPR \
2143 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2144 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2145 : ((SYM) == COND_EXPR \
2146 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2147 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2148 || (SYM) == DOT_PROD_EXPR \
2149 || (SYM) == SAD_EXPR \
2150 || (SYM) == REALIGN_LOAD_EXPR \
2151 || (SYM) == VEC_COND_EXPR \
2152 || (SYM) == VEC_PERM_EXPR \
2153 || (SYM) == BIT_INSERT_EXPR \
2154 || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS \
2155 : ((SYM) == CONSTRUCTOR \
2156 || (SYM) == OBJ_TYPE_REF \
2157 || (SYM) == ASSERT_EXPR \
2158 || (SYM) == ADDR_EXPR \
2159 || (SYM) == WITH_SIZE_EXPR \
2160 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2161 : GIMPLE_INVALID_RHS),
2162 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2164 const unsigned char gimple_rhs_class_table
[] = {
2165 #include "all-tree.def"
2169 #undef END_OF_BASE_TREE_CODES
2171 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2172 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2173 we failed to create one. */
2176 canonicalize_cond_expr_cond (tree t
)
2178 /* Strip conversions around boolean operations. */
2179 if (CONVERT_EXPR_P (t
)
2180 && (truth_value_p (TREE_CODE (TREE_OPERAND (t
, 0)))
2181 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
2183 t
= TREE_OPERAND (t
, 0);
2185 /* For !x use x == 0. */
2186 if (TREE_CODE (t
) == TRUTH_NOT_EXPR
)
2188 tree top0
= TREE_OPERAND (t
, 0);
2189 t
= build2 (EQ_EXPR
, TREE_TYPE (t
),
2190 top0
, build_int_cst (TREE_TYPE (top0
), 0));
2192 /* For cmp ? 1 : 0 use cmp. */
2193 else if (TREE_CODE (t
) == COND_EXPR
2194 && COMPARISON_CLASS_P (TREE_OPERAND (t
, 0))
2195 && integer_onep (TREE_OPERAND (t
, 1))
2196 && integer_zerop (TREE_OPERAND (t
, 2)))
2198 tree top0
= TREE_OPERAND (t
, 0);
2199 t
= build2 (TREE_CODE (top0
), TREE_TYPE (t
),
2200 TREE_OPERAND (top0
, 0), TREE_OPERAND (top0
, 1));
2202 /* For x ^ y use x != y. */
2203 else if (TREE_CODE (t
) == BIT_XOR_EXPR
)
2204 t
= build2 (NE_EXPR
, TREE_TYPE (t
),
2205 TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1));
2207 if (is_gimple_condexpr (t
))
2213 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2214 the positions marked by the set ARGS_TO_SKIP. */
2217 gimple_call_copy_skip_args (gcall
*stmt
, bitmap args_to_skip
)
2220 int nargs
= gimple_call_num_args (stmt
);
2221 auto_vec
<tree
> vargs (nargs
);
2224 for (i
= 0; i
< nargs
; i
++)
2225 if (!bitmap_bit_p (args_to_skip
, i
))
2226 vargs
.quick_push (gimple_call_arg (stmt
, i
));
2228 if (gimple_call_internal_p (stmt
))
2229 new_stmt
= gimple_build_call_internal_vec (gimple_call_internal_fn (stmt
),
2232 new_stmt
= gimple_build_call_vec (gimple_call_fn (stmt
), vargs
);
2234 if (gimple_call_lhs (stmt
))
2235 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2237 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2238 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
2240 if (gimple_has_location (stmt
))
2241 gimple_set_location (new_stmt
, gimple_location (stmt
));
2242 gimple_call_copy_flags (new_stmt
, stmt
);
2243 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2245 gimple_set_modified (new_stmt
, true);
2252 /* Return true if the field decls F1 and F2 are at the same offset.
2254 This is intended to be used on GIMPLE types only. */
2257 gimple_compare_field_offset (tree f1
, tree f2
)
2259 if (DECL_OFFSET_ALIGN (f1
) == DECL_OFFSET_ALIGN (f2
))
2261 tree offset1
= DECL_FIELD_OFFSET (f1
);
2262 tree offset2
= DECL_FIELD_OFFSET (f2
);
2263 return ((offset1
== offset2
2264 /* Once gimplification is done, self-referential offsets are
2265 instantiated as operand #2 of the COMPONENT_REF built for
2266 each access and reset. Therefore, they are not relevant
2267 anymore and fields are interchangeable provided that they
2268 represent the same access. */
2269 || (TREE_CODE (offset1
) == PLACEHOLDER_EXPR
2270 && TREE_CODE (offset2
) == PLACEHOLDER_EXPR
2271 && (DECL_SIZE (f1
) == DECL_SIZE (f2
)
2272 || (TREE_CODE (DECL_SIZE (f1
)) == PLACEHOLDER_EXPR
2273 && TREE_CODE (DECL_SIZE (f2
)) == PLACEHOLDER_EXPR
)
2274 || operand_equal_p (DECL_SIZE (f1
), DECL_SIZE (f2
), 0))
2275 && DECL_ALIGN (f1
) == DECL_ALIGN (f2
))
2276 || operand_equal_p (offset1
, offset2
, 0))
2277 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1
),
2278 DECL_FIELD_BIT_OFFSET (f2
)));
2281 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2282 should be, so handle differing ones specially by decomposing
2283 the offset into a byte and bit offset manually. */
2284 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1
))
2285 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2
)))
2287 unsigned HOST_WIDE_INT byte_offset1
, byte_offset2
;
2288 unsigned HOST_WIDE_INT bit_offset1
, bit_offset2
;
2289 bit_offset1
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1
));
2290 byte_offset1
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1
))
2291 + bit_offset1
/ BITS_PER_UNIT
);
2292 bit_offset2
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2
));
2293 byte_offset2
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2
))
2294 + bit_offset2
/ BITS_PER_UNIT
);
2295 if (byte_offset1
!= byte_offset2
)
2297 return bit_offset1
% BITS_PER_UNIT
== bit_offset2
% BITS_PER_UNIT
;
2304 /* Return a type the same as TYPE except unsigned or
2305 signed according to UNSIGNEDP. */
2308 gimple_signed_or_unsigned_type (bool unsignedp
, tree type
)
2313 type1
= TYPE_MAIN_VARIANT (type
);
2314 if (type1
== signed_char_type_node
2315 || type1
== char_type_node
2316 || type1
== unsigned_char_type_node
)
2317 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2318 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2319 return unsignedp
? unsigned_type_node
: integer_type_node
;
2320 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2321 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2322 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2323 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2324 if (type1
== long_long_integer_type_node
2325 || type1
== long_long_unsigned_type_node
)
2327 ? long_long_unsigned_type_node
2328 : long_long_integer_type_node
;
2330 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2331 if (int_n_enabled_p
[i
]
2332 && (type1
== int_n_trees
[i
].unsigned_type
2333 || type1
== int_n_trees
[i
].signed_type
))
2335 ? int_n_trees
[i
].unsigned_type
2336 : int_n_trees
[i
].signed_type
;
2338 #if HOST_BITS_PER_WIDE_INT >= 64
2339 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2340 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2342 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2343 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2344 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2345 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2346 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2347 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2348 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2349 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2351 #define GIMPLE_FIXED_TYPES(NAME) \
2352 if (type1 == short_ ## NAME ## _type_node \
2353 || type1 == unsigned_short_ ## NAME ## _type_node) \
2354 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2355 : short_ ## NAME ## _type_node; \
2356 if (type1 == NAME ## _type_node \
2357 || type1 == unsigned_ ## NAME ## _type_node) \
2358 return unsignedp ? unsigned_ ## NAME ## _type_node \
2359 : NAME ## _type_node; \
2360 if (type1 == long_ ## NAME ## _type_node \
2361 || type1 == unsigned_long_ ## NAME ## _type_node) \
2362 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2363 : long_ ## NAME ## _type_node; \
2364 if (type1 == long_long_ ## NAME ## _type_node \
2365 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2366 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2367 : long_long_ ## NAME ## _type_node;
2369 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2370 if (type1 == NAME ## _type_node \
2371 || type1 == u ## NAME ## _type_node) \
2372 return unsignedp ? u ## NAME ## _type_node \
2373 : NAME ## _type_node;
2375 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2376 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2377 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2378 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2379 : sat_ ## short_ ## NAME ## _type_node; \
2380 if (type1 == sat_ ## NAME ## _type_node \
2381 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2382 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2383 : sat_ ## NAME ## _type_node; \
2384 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2385 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2386 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2387 : sat_ ## long_ ## NAME ## _type_node; \
2388 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2389 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2390 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2391 : sat_ ## long_long_ ## NAME ## _type_node;
2393 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2394 if (type1 == sat_ ## NAME ## _type_node \
2395 || type1 == sat_ ## u ## NAME ## _type_node) \
2396 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2397 : sat_ ## NAME ## _type_node;
2399 GIMPLE_FIXED_TYPES (fract
);
2400 GIMPLE_FIXED_TYPES_SAT (fract
);
2401 GIMPLE_FIXED_TYPES (accum
);
2402 GIMPLE_FIXED_TYPES_SAT (accum
);
2404 GIMPLE_FIXED_MODE_TYPES (qq
);
2405 GIMPLE_FIXED_MODE_TYPES (hq
);
2406 GIMPLE_FIXED_MODE_TYPES (sq
);
2407 GIMPLE_FIXED_MODE_TYPES (dq
);
2408 GIMPLE_FIXED_MODE_TYPES (tq
);
2409 GIMPLE_FIXED_MODE_TYPES_SAT (qq
);
2410 GIMPLE_FIXED_MODE_TYPES_SAT (hq
);
2411 GIMPLE_FIXED_MODE_TYPES_SAT (sq
);
2412 GIMPLE_FIXED_MODE_TYPES_SAT (dq
);
2413 GIMPLE_FIXED_MODE_TYPES_SAT (tq
);
2414 GIMPLE_FIXED_MODE_TYPES (ha
);
2415 GIMPLE_FIXED_MODE_TYPES (sa
);
2416 GIMPLE_FIXED_MODE_TYPES (da
);
2417 GIMPLE_FIXED_MODE_TYPES (ta
);
2418 GIMPLE_FIXED_MODE_TYPES_SAT (ha
);
2419 GIMPLE_FIXED_MODE_TYPES_SAT (sa
);
2420 GIMPLE_FIXED_MODE_TYPES_SAT (da
);
2421 GIMPLE_FIXED_MODE_TYPES_SAT (ta
);
2423 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2424 the precision; they have precision set to match their range, but
2425 may use a wider mode to match an ABI. If we change modes, we may
2426 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2427 the precision as well, so as to yield correct results for
2428 bit-field types. C++ does not have these separate bit-field
2429 types, and producing a signed or unsigned variant of an
2430 ENUMERAL_TYPE may cause other problems as well. */
2431 if (!INTEGRAL_TYPE_P (type
)
2432 || TYPE_UNSIGNED (type
) == unsignedp
)
2435 #define TYPE_OK(node) \
2436 (TYPE_MODE (type) == TYPE_MODE (node) \
2437 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2438 if (TYPE_OK (signed_char_type_node
))
2439 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2440 if (TYPE_OK (integer_type_node
))
2441 return unsignedp
? unsigned_type_node
: integer_type_node
;
2442 if (TYPE_OK (short_integer_type_node
))
2443 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2444 if (TYPE_OK (long_integer_type_node
))
2445 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2446 if (TYPE_OK (long_long_integer_type_node
))
2448 ? long_long_unsigned_type_node
2449 : long_long_integer_type_node
);
2451 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2452 if (int_n_enabled_p
[i
]
2453 && TYPE_MODE (type
) == int_n_data
[i
].m
2454 && TYPE_PRECISION (type
) == int_n_data
[i
].bitsize
)
2456 ? int_n_trees
[i
].unsigned_type
2457 : int_n_trees
[i
].signed_type
;
2459 #if HOST_BITS_PER_WIDE_INT >= 64
2460 if (TYPE_OK (intTI_type_node
))
2461 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2463 if (TYPE_OK (intDI_type_node
))
2464 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2465 if (TYPE_OK (intSI_type_node
))
2466 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2467 if (TYPE_OK (intHI_type_node
))
2468 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2469 if (TYPE_OK (intQI_type_node
))
2470 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2472 #undef GIMPLE_FIXED_TYPES
2473 #undef GIMPLE_FIXED_MODE_TYPES
2474 #undef GIMPLE_FIXED_TYPES_SAT
2475 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2478 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2482 /* Return an unsigned type the same as TYPE in other respects. */
2485 gimple_unsigned_type (tree type
)
2487 return gimple_signed_or_unsigned_type (true, type
);
2491 /* Return a signed type the same as TYPE in other respects. */
2494 gimple_signed_type (tree type
)
2496 return gimple_signed_or_unsigned_type (false, type
);
2500 /* Return the typed-based alias set for T, which may be an expression
2501 or a type. Return -1 if we don't do anything special. */
2504 gimple_get_alias_set (tree t
)
2506 /* That's all the expressions we handle specially. */
2510 /* For convenience, follow the C standard when dealing with
2511 character types. Any object may be accessed via an lvalue that
2512 has character type. */
2513 if (t
== char_type_node
2514 || t
== signed_char_type_node
2515 || t
== unsigned_char_type_node
)
2518 /* Allow aliasing between signed and unsigned variants of the same
2519 type. We treat the signed variant as canonical. */
2520 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2522 tree t1
= gimple_signed_type (t
);
2524 /* t1 == t can happen for boolean nodes which are always unsigned. */
2526 return get_alias_set (t1
);
2533 /* Helper for gimple_ior_addresses_taken_1. */
2536 gimple_ior_addresses_taken_1 (gimple
*, tree addr
, tree
, void *data
)
2538 bitmap addresses_taken
= (bitmap
)data
;
2539 addr
= get_base_address (addr
);
2543 bitmap_set_bit (addresses_taken
, DECL_UID (addr
));
2549 /* Set the bit for the uid of all decls that have their address taken
2550 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2551 were any in this stmt. */
2554 gimple_ior_addresses_taken (bitmap addresses_taken
, gimple
*stmt
)
2556 return walk_stmt_load_store_addr_ops (stmt
, addresses_taken
, NULL
, NULL
,
2557 gimple_ior_addresses_taken_1
);
2561 /* Return true when STMTs arguments and return value match those of FNDECL,
2562 a decl of a builtin function. */
2565 gimple_builtin_call_types_compatible_p (const gimple
*stmt
, tree fndecl
)
2567 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
);
2569 tree ret
= gimple_call_lhs (stmt
);
2571 && !useless_type_conversion_p (TREE_TYPE (ret
),
2572 TREE_TYPE (TREE_TYPE (fndecl
))))
2575 tree targs
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2576 unsigned nargs
= gimple_call_num_args (stmt
);
2577 for (unsigned i
= 0; i
< nargs
; ++i
)
2579 /* Variadic args follow. */
2582 tree arg
= gimple_call_arg (stmt
, i
);
2583 tree type
= TREE_VALUE (targs
);
2584 if (!useless_type_conversion_p (type
, TREE_TYPE (arg
))
2585 /* char/short integral arguments are promoted to int
2586 by several frontends if targetm.calls.promote_prototypes
2587 is true. Allow such promotion too. */
2588 && !(INTEGRAL_TYPE_P (type
)
2589 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)
2590 && targetm
.calls
.promote_prototypes (TREE_TYPE (fndecl
))
2591 && useless_type_conversion_p (integer_type_node
,
2594 targs
= TREE_CHAIN (targs
);
2596 if (targs
&& !VOID_TYPE_P (TREE_VALUE (targs
)))
2601 /* Return true when STMT is builtins call. */
2604 gimple_call_builtin_p (const gimple
*stmt
)
2607 if (is_gimple_call (stmt
)
2608 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2609 && DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
)
2610 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2614 /* Return true when STMT is builtins call to CLASS. */
2617 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_class klass
)
2620 if (is_gimple_call (stmt
)
2621 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2622 && DECL_BUILT_IN_CLASS (fndecl
) == klass
)
2623 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2627 /* Return true when STMT is builtins call to CODE of CLASS. */
2630 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_function code
)
2633 if (is_gimple_call (stmt
)
2634 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2635 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
2636 && DECL_FUNCTION_CODE (fndecl
) == code
)
2637 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2641 /* If CALL is a call to a combined_fn (i.e. an internal function or
2642 a normal built-in function), return its code, otherwise return
2646 gimple_call_combined_fn (const gimple
*stmt
)
2648 if (const gcall
*call
= dyn_cast
<const gcall
*> (stmt
))
2650 if (gimple_call_internal_p (call
))
2651 return as_combined_fn (gimple_call_internal_fn (call
));
2653 tree fndecl
= gimple_call_fndecl (stmt
);
2655 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
2656 && gimple_builtin_call_types_compatible_p (stmt
, fndecl
))
2657 return as_combined_fn (DECL_FUNCTION_CODE (fndecl
));
2662 /* Return true if STMT clobbers memory. STMT is required to be a
2666 gimple_asm_clobbers_memory_p (const gasm
*stmt
)
2670 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
2672 tree op
= gimple_asm_clobber_op (stmt
, i
);
2673 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op
)), "memory") == 0)
2677 /* Non-empty basic ASM implicitly clobbers memory. */
2678 if (gimple_asm_input_p (stmt
) && strlen (gimple_asm_string (stmt
)) != 0)
2684 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2687 dump_decl_set (FILE *file
, bitmap set
)
2694 fprintf (file
, "{ ");
2696 EXECUTE_IF_SET_IN_BITMAP (set
, 0, i
, bi
)
2698 fprintf (file
, "D.%u", i
);
2699 fprintf (file
, " ");
2702 fprintf (file
, "}");
2705 fprintf (file
, "NIL");
2708 /* Return true when CALL is a call stmt that definitely doesn't
2709 free any memory or makes it unavailable otherwise. */
2711 nonfreeing_call_p (gimple
*call
)
2713 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2714 && gimple_call_flags (call
) & ECF_LEAF
)
2715 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call
)))
2717 /* Just in case these become ECF_LEAF in the future. */
2719 case BUILT_IN_TM_FREE
:
2720 case BUILT_IN_REALLOC
:
2721 case BUILT_IN_STACK_RESTORE
:
2726 else if (gimple_call_internal_p (call
))
2727 switch (gimple_call_internal_fn (call
))
2729 case IFN_ABNORMAL_DISPATCHER
:
2732 return tree_to_uhwi (gimple_call_arg (call
, 0)) == ASAN_MARK_UNPOISON
;
2734 if (gimple_call_flags (call
) & ECF_LEAF
)
2739 tree fndecl
= gimple_call_fndecl (call
);
2742 struct cgraph_node
*n
= cgraph_node::get (fndecl
);
2745 enum availability availability
;
2746 n
= n
->function_symbol (&availability
);
2747 if (!n
|| availability
<= AVAIL_INTERPOSABLE
)
2749 return n
->nonfreeing_fn
;
2752 /* Return true when CALL is a call stmt that definitely need not
2753 be considered to be a memory barrier. */
2755 nonbarrier_call_p (gimple
*call
)
2757 if (gimple_call_flags (call
) & (ECF_PURE
| ECF_CONST
))
2759 /* Should extend this to have a nonbarrier_fn flag, just as above in
2760 the nonfreeing case. */
2764 /* Callback for walk_stmt_load_store_ops.
2766 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2769 This routine only makes a superficial check for a dereference. Thus
2770 it must only be used if it is safe to return a false negative. */
2772 check_loadstore (gimple
*, tree op
, tree
, void *data
)
2774 if (TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
2776 /* Some address spaces may legitimately dereference zero. */
2777 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (op
));
2778 if (targetm
.addr_space
.zero_address_valid (as
))
2781 return operand_equal_p (TREE_OPERAND (op
, 0), (tree
)data
, 0);
2787 /* Return true if OP can be inferred to be non-NULL after STMT executes,
2788 either by using a pointer dereference or attributes. */
2790 infer_nonnull_range (gimple
*stmt
, tree op
)
2792 return infer_nonnull_range_by_dereference (stmt
, op
)
2793 || infer_nonnull_range_by_attribute (stmt
, op
);
2796 /* Return true if OP can be inferred to be non-NULL after STMT
2797 executes by using a pointer dereference. */
2799 infer_nonnull_range_by_dereference (gimple
*stmt
, tree op
)
2801 /* We can only assume that a pointer dereference will yield
2802 non-NULL if -fdelete-null-pointer-checks is enabled. */
2803 if (!flag_delete_null_pointer_checks
2804 || !POINTER_TYPE_P (TREE_TYPE (op
))
2805 || gimple_code (stmt
) == GIMPLE_ASM
)
2808 if (walk_stmt_load_store_ops (stmt
, (void *)op
,
2809 check_loadstore
, check_loadstore
))
2815 /* Return true if OP can be inferred to be a non-NULL after STMT
2816 executes by using attributes. */
2818 infer_nonnull_range_by_attribute (gimple
*stmt
, tree op
)
2820 /* We can only assume that a pointer dereference will yield
2821 non-NULL if -fdelete-null-pointer-checks is enabled. */
2822 if (!flag_delete_null_pointer_checks
2823 || !POINTER_TYPE_P (TREE_TYPE (op
))
2824 || gimple_code (stmt
) == GIMPLE_ASM
)
2827 if (is_gimple_call (stmt
) && !gimple_call_internal_p (stmt
))
2829 tree fntype
= gimple_call_fntype (stmt
);
2830 tree attrs
= TYPE_ATTRIBUTES (fntype
);
2831 for (; attrs
; attrs
= TREE_CHAIN (attrs
))
2833 attrs
= lookup_attribute ("nonnull", attrs
);
2835 /* If "nonnull" wasn't specified, we know nothing about
2837 if (attrs
== NULL_TREE
)
2840 /* If "nonnull" applies to all the arguments, then ARG
2841 is non-null if it's in the argument list. */
2842 if (TREE_VALUE (attrs
) == NULL_TREE
)
2844 for (unsigned int i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2846 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt
, i
)))
2847 && operand_equal_p (op
, gimple_call_arg (stmt
, i
), 0))
2853 /* Now see if op appears in the nonnull list. */
2854 for (tree t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
2856 unsigned int idx
= TREE_INT_CST_LOW (TREE_VALUE (t
)) - 1;
2857 if (idx
< gimple_call_num_args (stmt
))
2859 tree arg
= gimple_call_arg (stmt
, idx
);
2860 if (operand_equal_p (op
, arg
, 0))
2867 /* If this function is marked as returning non-null, then we can
2868 infer OP is non-null if it is used in the return statement. */
2869 if (greturn
*return_stmt
= dyn_cast
<greturn
*> (stmt
))
2870 if (gimple_return_retval (return_stmt
)
2871 && operand_equal_p (gimple_return_retval (return_stmt
), op
, 0)
2872 && lookup_attribute ("returns_nonnull",
2873 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
))))
2879 /* Compare two case labels. Because the front end should already have
2880 made sure that case ranges do not overlap, it is enough to only compare
2881 the CASE_LOW values of each case label. */
2884 compare_case_labels (const void *p1
, const void *p2
)
2886 const_tree
const case1
= *(const_tree
const*)p1
;
2887 const_tree
const case2
= *(const_tree
const*)p2
;
2889 /* The 'default' case label always goes first. */
2890 if (!CASE_LOW (case1
))
2892 else if (!CASE_LOW (case2
))
2895 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
2898 /* Sort the case labels in LABEL_VEC in place in ascending order. */
2901 sort_case_labels (vec
<tree
> label_vec
)
2903 label_vec
.qsort (compare_case_labels
);
2906 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2908 LABELS is a vector that contains all case labels to look at.
2910 INDEX_TYPE is the type of the switch index expression. Case labels
2911 in LABELS are discarded if their values are not in the value range
2912 covered by INDEX_TYPE. The remaining case label values are folded
2915 If a default case exists in LABELS, it is removed from LABELS and
2916 returned in DEFAULT_CASEP. If no default case exists, but the
2917 case labels already cover the whole range of INDEX_TYPE, a default
2918 case is returned pointing to one of the existing case labels.
2919 Otherwise DEFAULT_CASEP is set to NULL_TREE.
2921 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2922 apply and no action is taken regardless of whether a default case is
2926 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
2928 tree
*default_casep
)
2930 tree min_value
, max_value
;
2931 tree default_case
= NULL_TREE
;
2935 min_value
= TYPE_MIN_VALUE (index_type
);
2936 max_value
= TYPE_MAX_VALUE (index_type
);
2937 while (i
< labels
.length ())
2939 tree elt
= labels
[i
];
2940 tree low
= CASE_LOW (elt
);
2941 tree high
= CASE_HIGH (elt
);
2942 bool remove_element
= FALSE
;
2946 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
2947 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
2949 /* This is a non-default case label, i.e. it has a value.
2951 See if the case label is reachable within the range of
2952 the index type. Remove out-of-range case values. Turn
2953 case ranges into a canonical form (high > low strictly)
2954 and convert the case label values to the index type.
2956 NB: The type of gimple_switch_index() may be the promoted
2957 type, but the case labels retain the original type. */
2961 /* This is a case range. Discard empty ranges.
2962 If the bounds or the range are equal, turn this
2963 into a simple (one-value) case. */
2964 int cmp
= tree_int_cst_compare (high
, low
);
2966 remove_element
= TRUE
;
2973 /* If the simple case value is unreachable, ignore it. */
2974 if ((TREE_CODE (min_value
) == INTEGER_CST
2975 && tree_int_cst_compare (low
, min_value
) < 0)
2976 || (TREE_CODE (max_value
) == INTEGER_CST
2977 && tree_int_cst_compare (low
, max_value
) > 0))
2978 remove_element
= TRUE
;
2980 low
= fold_convert (index_type
, low
);
2984 /* If the entire case range is unreachable, ignore it. */
2985 if ((TREE_CODE (min_value
) == INTEGER_CST
2986 && tree_int_cst_compare (high
, min_value
) < 0)
2987 || (TREE_CODE (max_value
) == INTEGER_CST
2988 && tree_int_cst_compare (low
, max_value
) > 0))
2989 remove_element
= TRUE
;
2992 /* If the lower bound is less than the index type's
2993 minimum value, truncate the range bounds. */
2994 if (TREE_CODE (min_value
) == INTEGER_CST
2995 && tree_int_cst_compare (low
, min_value
) < 0)
2997 low
= fold_convert (index_type
, low
);
2999 /* If the upper bound is greater than the index type's
3000 maximum value, truncate the range bounds. */
3001 if (TREE_CODE (max_value
) == INTEGER_CST
3002 && tree_int_cst_compare (high
, max_value
) > 0)
3004 high
= fold_convert (index_type
, high
);
3006 /* We may have folded a case range to a one-value case. */
3007 if (tree_int_cst_equal (low
, high
))
3012 CASE_LOW (elt
) = low
;
3013 CASE_HIGH (elt
) = high
;
3017 gcc_assert (!default_case
);
3019 /* The default case must be passed separately to the
3020 gimple_build_switch routine. But if DEFAULT_CASEP
3021 is NULL, we do not remove the default case (it would
3022 be completely lost). */
3024 remove_element
= TRUE
;
3028 labels
.ordered_remove (i
);
3034 if (!labels
.is_empty ())
3035 sort_case_labels (labels
);
3037 if (default_casep
&& !default_case
)
3039 /* If the switch has no default label, add one, so that we jump
3040 around the switch body. If the labels already cover the whole
3041 range of the switch index_type, add the default label pointing
3042 to one of the existing labels. */
3044 && TYPE_MIN_VALUE (index_type
)
3045 && TYPE_MAX_VALUE (index_type
)
3046 && tree_int_cst_equal (CASE_LOW (labels
[0]),
3047 TYPE_MIN_VALUE (index_type
)))
3049 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
3051 high
= CASE_LOW (labels
[len
- 1]);
3052 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
3054 tree widest_label
= labels
[0];
3055 for (i
= 1; i
< len
; i
++)
3057 high
= CASE_LOW (labels
[i
]);
3058 low
= CASE_HIGH (labels
[i
- 1]);
3060 low
= CASE_LOW (labels
[i
- 1]);
3062 if (CASE_HIGH (labels
[i
]) != NULL_TREE
3063 && (CASE_HIGH (widest_label
) == NULL_TREE
3065 (wi::to_wide (CASE_HIGH (labels
[i
]))
3066 - wi::to_wide (CASE_LOW (labels
[i
])),
3067 wi::to_wide (CASE_HIGH (widest_label
))
3068 - wi::to_wide (CASE_LOW (widest_label
))))))
3069 widest_label
= labels
[i
];
3071 if (wi::to_wide (low
) + 1 != wi::to_wide (high
))
3076 /* Designate the label with the widest range to be the
3078 tree label
= CASE_LABEL (widest_label
);
3079 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
3087 *default_casep
= default_case
;
3090 /* Set the location of all statements in SEQ to LOC. */
3093 gimple_seq_set_location (gimple_seq seq
, location_t loc
)
3095 for (gimple_stmt_iterator i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
3096 gimple_set_location (gsi_stmt (i
), loc
);
3099 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
3102 gimple_seq_discard (gimple_seq seq
)
3104 gimple_stmt_iterator gsi
;
3106 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); )
3108 gimple
*stmt
= gsi_stmt (gsi
);
3109 gsi_remove (&gsi
, true);
3110 release_defs (stmt
);
3115 /* See if STMT now calls function that takes no parameters and if so, drop
3116 call arguments. This is used when devirtualization machinery redirects
3117 to __builtin_unreachable or __cxa_pure_virtual. */
3120 maybe_remove_unused_call_args (struct function
*fn
, gimple
*stmt
)
3122 tree decl
= gimple_call_fndecl (stmt
);
3123 if (TYPE_ARG_TYPES (TREE_TYPE (decl
))
3124 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
))) == void_type_node
3125 && gimple_call_num_args (stmt
))
3127 gimple_set_num_ops (stmt
, 3);
3128 update_stmt_fn (fn
, stmt
);
3132 /* Return false if STMT will likely expand to real function call. */
3135 gimple_inexpensive_call_p (gcall
*stmt
)
3137 if (gimple_call_internal_p (stmt
))
3139 tree decl
= gimple_call_fndecl (stmt
);
3140 if (decl
&& is_inexpensive_builtin (decl
))
3147 namespace selftest
{
3149 /* Selftests for core gimple structures. */
3151 /* Verify that STMT is pretty-printed as EXPECTED.
3152 Helper function for selftests. */
3155 verify_gimple_pp (const char *expected
, gimple
*stmt
)
3158 pp_gimple_stmt_1 (&pp
, stmt
, 0 /* spc */, 0 /* flags */);
3159 ASSERT_STREQ (expected
, pp_formatted_text (&pp
));
3162 /* Build a GIMPLE_ASSIGN equivalent to
3164 and verify various properties of it. */
3167 test_assign_single ()
3169 tree type
= integer_type_node
;
3170 tree lhs
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3171 get_identifier ("tmp"),
3173 tree rhs
= build_int_cst (type
, 5);
3174 gassign
*stmt
= gimple_build_assign (lhs
, rhs
);
3175 verify_gimple_pp ("tmp = 5;", stmt
);
3177 ASSERT_TRUE (is_gimple_assign (stmt
));
3178 ASSERT_EQ (lhs
, gimple_assign_lhs (stmt
));
3179 ASSERT_EQ (lhs
, gimple_get_lhs (stmt
));
3180 ASSERT_EQ (rhs
, gimple_assign_rhs1 (stmt
));
3181 ASSERT_EQ (NULL
, gimple_assign_rhs2 (stmt
));
3182 ASSERT_EQ (NULL
, gimple_assign_rhs3 (stmt
));
3183 ASSERT_TRUE (gimple_assign_single_p (stmt
));
3184 ASSERT_EQ (INTEGER_CST
, gimple_assign_rhs_code (stmt
));
3187 /* Build a GIMPLE_ASSIGN equivalent to
3189 and verify various properties of it. */
3192 test_assign_binop ()
3194 tree type
= integer_type_node
;
3195 tree lhs
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3196 get_identifier ("tmp"),
3198 tree a
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3199 get_identifier ("a"),
3201 tree b
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3202 get_identifier ("b"),
3204 gassign
*stmt
= gimple_build_assign (lhs
, MULT_EXPR
, a
, b
);
3205 verify_gimple_pp ("tmp = a * b;", stmt
);
3207 ASSERT_TRUE (is_gimple_assign (stmt
));
3208 ASSERT_EQ (lhs
, gimple_assign_lhs (stmt
));
3209 ASSERT_EQ (lhs
, gimple_get_lhs (stmt
));
3210 ASSERT_EQ (a
, gimple_assign_rhs1 (stmt
));
3211 ASSERT_EQ (b
, gimple_assign_rhs2 (stmt
));
3212 ASSERT_EQ (NULL
, gimple_assign_rhs3 (stmt
));
3213 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3214 ASSERT_EQ (MULT_EXPR
, gimple_assign_rhs_code (stmt
));
3217 /* Build a GIMPLE_NOP and verify various properties of it. */
3222 gimple
*stmt
= gimple_build_nop ();
3223 verify_gimple_pp ("GIMPLE_NOP", stmt
);
3224 ASSERT_EQ (GIMPLE_NOP
, gimple_code (stmt
));
3225 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3226 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3229 /* Build a GIMPLE_RETURN equivalent to
3231 and verify various properties of it. */
3236 tree type
= integer_type_node
;
3237 tree val
= build_int_cst (type
, 7);
3238 greturn
*stmt
= gimple_build_return (val
);
3239 verify_gimple_pp ("return 7;", stmt
);
3241 ASSERT_EQ (GIMPLE_RETURN
, gimple_code (stmt
));
3242 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3243 ASSERT_EQ (val
, gimple_return_retval (stmt
));
3244 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3247 /* Build a GIMPLE_RETURN equivalent to
3249 and verify various properties of it. */
3252 test_return_without_value ()
3254 greturn
*stmt
= gimple_build_return (NULL
);
3255 verify_gimple_pp ("return;", stmt
);
3257 ASSERT_EQ (GIMPLE_RETURN
, gimple_code (stmt
));
3258 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3259 ASSERT_EQ (NULL
, gimple_return_retval (stmt
));
3260 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3263 /* Run all of the selftests within this file. */
3268 test_assign_single ();
3269 test_assign_binop ();
3271 test_return_stmt ();
3272 test_return_without_value ();
3275 } // namespace selftest
3278 #endif /* CHECKING_P */