1 /* Gimple IR support functions.
3 Copyright (C) 2007-2020 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"
47 #include "langhooks.h"
48 #include "attr-fnspec.h"
51 /* All the tuples have their operand vector (if present) at the very bottom
52 of the structure. Therefore, the offset required to find the
53 operands vector the size of the structure minus the size of the 1
54 element tree array at the end (see gimple_ops). */
55 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
56 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
57 EXPORTED_CONST
size_t gimple_ops_offset_
[] = {
58 #include "gsstruct.def"
62 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
63 static const size_t gsstruct_code_size
[] = {
64 #include "gsstruct.def"
68 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
69 const char *const gimple_code_name
[] = {
74 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
75 EXPORTED_CONST
enum gimple_statement_structure_enum gss_for_code_
[] = {
82 uint64_t gimple_alloc_counts
[(int) gimple_alloc_kind_all
];
83 uint64_t gimple_alloc_sizes
[(int) gimple_alloc_kind_all
];
85 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
86 static const char * const gimple_alloc_kind_names
[] = {
93 /* Static gimple tuple members. */
94 const enum gimple_code
gassign::code_
;
95 const enum gimple_code
gcall::code_
;
96 const enum gimple_code
gcond::code_
;
99 /* Gimple tuple constructors.
100 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
101 be passed a NULL to start with an empty sequence. */
103 /* Set the code for statement G to CODE. */
106 gimple_set_code (gimple
*g
, enum gimple_code code
)
111 /* Return the number of bytes needed to hold a GIMPLE statement with
115 gimple_size (enum gimple_code code
, unsigned num_ops
)
117 size_t size
= gsstruct_code_size
[gss_for_code (code
)];
119 size
+= (sizeof (tree
) * (num_ops
- 1));
123 /* Initialize GIMPLE statement G with CODE and NUM_OPS. */
126 gimple_init (gimple
*g
, enum gimple_code code
, unsigned num_ops
)
128 gimple_set_code (g
, code
);
129 gimple_set_num_ops (g
, num_ops
);
131 /* Do not call gimple_set_modified here as it has other side
132 effects and this tuple is still not completely built. */
134 gimple_init_singleton (g
);
137 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
141 gimple_alloc (enum gimple_code code
, unsigned num_ops MEM_STAT_DECL
)
146 size
= gimple_size (code
, num_ops
);
147 if (GATHER_STATISTICS
)
149 enum gimple_alloc_kind kind
= gimple_alloc_kind (code
);
150 gimple_alloc_counts
[(int) kind
]++;
151 gimple_alloc_sizes
[(int) kind
] += size
;
154 stmt
= ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT
);
155 gimple_init (stmt
, code
, num_ops
);
159 /* Set SUBCODE to be the code of the expression computed by statement G. */
162 gimple_set_subcode (gimple
*g
, unsigned subcode
)
164 /* We only have 16 bits for the RHS code. Assert that we are not
166 gcc_assert (subcode
< (1 << 16));
167 g
->subcode
= subcode
;
172 /* Build a tuple with operands. CODE is the statement to build (which
173 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
174 for the new tuple. NUM_OPS is the number of operands to allocate. */
176 #define gimple_build_with_ops(c, s, n) \
177 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
180 gimple_build_with_ops_stat (enum gimple_code code
, unsigned subcode
,
181 unsigned num_ops MEM_STAT_DECL
)
183 gimple
*s
= gimple_alloc (code
, num_ops PASS_MEM_STAT
);
184 gimple_set_subcode (s
, subcode
);
190 /* Build a GIMPLE_RETURN statement returning RETVAL. */
193 gimple_build_return (tree retval
)
196 = as_a
<greturn
*> (gimple_build_with_ops (GIMPLE_RETURN
, ERROR_MARK
,
199 gimple_return_set_retval (s
, retval
);
203 /* Reset alias information on call S. */
206 gimple_call_reset_alias_info (gcall
*s
)
208 if (gimple_call_flags (s
) & ECF_CONST
)
209 memset (gimple_call_use_set (s
), 0, sizeof (struct pt_solution
));
211 pt_solution_reset (gimple_call_use_set (s
));
212 if (gimple_call_flags (s
) & (ECF_CONST
|ECF_PURE
|ECF_NOVOPS
))
213 memset (gimple_call_clobber_set (s
), 0, sizeof (struct pt_solution
));
215 pt_solution_reset (gimple_call_clobber_set (s
));
218 /* Helper for gimple_build_call, gimple_build_call_valist,
219 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
220 components of a GIMPLE_CALL statement to function FN with NARGS
223 static inline gcall
*
224 gimple_build_call_1 (tree fn
, unsigned nargs
)
227 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
229 if (TREE_CODE (fn
) == FUNCTION_DECL
)
230 fn
= build_fold_addr_expr (fn
);
231 gimple_set_op (s
, 1, fn
);
232 gimple_call_set_fntype (s
, TREE_TYPE (TREE_TYPE (fn
)));
233 gimple_call_reset_alias_info (s
);
238 /* Build a GIMPLE_CALL statement to function FN with the arguments
239 specified in vector ARGS. */
242 gimple_build_call_vec (tree fn
, vec
<tree
> args
)
245 unsigned nargs
= args
.length ();
246 gcall
*call
= gimple_build_call_1 (fn
, nargs
);
248 for (i
= 0; i
< nargs
; i
++)
249 gimple_call_set_arg (call
, i
, args
[i
]);
255 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
256 arguments. The ... are the arguments. */
259 gimple_build_call (tree fn
, unsigned nargs
, ...)
265 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
267 call
= gimple_build_call_1 (fn
, nargs
);
269 va_start (ap
, nargs
);
270 for (i
= 0; i
< nargs
; i
++)
271 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
278 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
279 arguments. AP contains the arguments. */
282 gimple_build_call_valist (tree fn
, unsigned nargs
, va_list ap
)
287 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
289 call
= gimple_build_call_1 (fn
, nargs
);
291 for (i
= 0; i
< nargs
; i
++)
292 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
298 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
299 Build the basic components of a GIMPLE_CALL statement to internal
300 function FN with NARGS arguments. */
302 static inline gcall
*
303 gimple_build_call_internal_1 (enum internal_fn fn
, unsigned nargs
)
306 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
308 s
->subcode
|= GF_CALL_INTERNAL
;
309 gimple_call_set_internal_fn (s
, fn
);
310 gimple_call_reset_alias_info (s
);
315 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
316 the number of arguments. The ... are the arguments. */
319 gimple_build_call_internal (enum internal_fn fn
, unsigned nargs
, ...)
325 call
= gimple_build_call_internal_1 (fn
, nargs
);
326 va_start (ap
, nargs
);
327 for (i
= 0; i
< nargs
; i
++)
328 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
335 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
336 specified in vector ARGS. */
339 gimple_build_call_internal_vec (enum internal_fn fn
, vec
<tree
> args
)
344 nargs
= args
.length ();
345 call
= gimple_build_call_internal_1 (fn
, nargs
);
346 for (i
= 0; i
< nargs
; i
++)
347 gimple_call_set_arg (call
, i
, args
[i
]);
353 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
354 assumed to be in GIMPLE form already. Minimal checking is done of
358 gimple_build_call_from_tree (tree t
, tree fnptrtype
)
363 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
365 nargs
= call_expr_nargs (t
);
367 tree fndecl
= NULL_TREE
;
368 if (CALL_EXPR_FN (t
) == NULL_TREE
)
369 call
= gimple_build_call_internal_1 (CALL_EXPR_IFN (t
), nargs
);
372 fndecl
= get_callee_fndecl (t
);
373 call
= gimple_build_call_1 (fndecl
? fndecl
: CALL_EXPR_FN (t
), nargs
);
376 for (i
= 0; i
< nargs
; i
++)
377 gimple_call_set_arg (call
, i
, CALL_EXPR_ARG (t
, i
));
379 gimple_set_block (call
, TREE_BLOCK (t
));
380 gimple_set_location (call
, EXPR_LOCATION (t
));
382 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
383 gimple_call_set_chain (call
, CALL_EXPR_STATIC_CHAIN (t
));
384 gimple_call_set_tail (call
, CALL_EXPR_TAILCALL (t
));
385 gimple_call_set_must_tail (call
, CALL_EXPR_MUST_TAIL_CALL (t
));
386 gimple_call_set_return_slot_opt (call
, CALL_EXPR_RETURN_SLOT_OPT (t
));
388 && fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
)
389 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl
)))
390 gimple_call_set_alloca_for_var (call
, CALL_ALLOCA_FOR_VAR_P (t
));
392 && (DECL_IS_OPERATOR_NEW_P (fndecl
)
393 || DECL_IS_OPERATOR_DELETE_P (fndecl
)))
394 gimple_call_set_from_new_or_delete (call
, CALL_FROM_NEW_OR_DELETE_P (t
));
396 gimple_call_set_from_thunk (call
, CALL_FROM_THUNK_P (t
));
397 gimple_call_set_va_arg_pack (call
, CALL_EXPR_VA_ARG_PACK (t
));
398 gimple_call_set_nothrow (call
, TREE_NOTHROW (t
));
399 gimple_call_set_by_descriptor (call
, CALL_EXPR_BY_DESCRIPTOR (t
));
400 gimple_set_no_warning (call
, TREE_NO_WARNING (t
));
404 gimple_call_set_fntype (call
, TREE_TYPE (fnptrtype
));
406 /* Check if it's an indirect CALL and the type has the
407 nocf_check attribute. In that case propagate the information
408 to the gimple CALL insn. */
411 gcc_assert (POINTER_TYPE_P (fnptrtype
));
412 tree fntype
= TREE_TYPE (fnptrtype
);
414 if (lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (fntype
)))
415 gimple_call_set_nocf_check (call
, TRUE
);
423 /* Build a GIMPLE_ASSIGN statement.
425 LHS of the assignment.
426 RHS of the assignment which can be unary or binary. */
429 gimple_build_assign (tree lhs
, tree rhs MEM_STAT_DECL
)
431 enum tree_code subcode
;
434 extract_ops_from_tree (rhs
, &subcode
, &op1
, &op2
, &op3
);
435 return gimple_build_assign (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
439 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
442 static inline gassign
*
443 gimple_build_assign_1 (tree lhs
, enum tree_code subcode
, tree op1
,
444 tree op2
, tree op3 MEM_STAT_DECL
)
449 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
451 num_ops
= get_gimple_rhs_num_ops (subcode
) + 1;
453 p
= as_a
<gassign
*> (
454 gimple_build_with_ops_stat (GIMPLE_ASSIGN
, (unsigned)subcode
, num_ops
456 gimple_assign_set_lhs (p
, lhs
);
457 gimple_assign_set_rhs1 (p
, op1
);
460 gcc_assert (num_ops
> 2);
461 gimple_assign_set_rhs2 (p
, op2
);
466 gcc_assert (num_ops
> 3);
467 gimple_assign_set_rhs3 (p
, op3
);
473 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
477 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
478 tree op2
, tree op3 MEM_STAT_DECL
)
480 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
483 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
487 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
488 tree op2 MEM_STAT_DECL
)
490 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, NULL_TREE
494 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
497 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1 MEM_STAT_DECL
)
499 return gimple_build_assign_1 (lhs
, subcode
, op1
, NULL_TREE
, NULL_TREE
504 /* Build a GIMPLE_COND statement.
506 PRED is the condition used to compare LHS and the RHS.
507 T_LABEL is the label to jump to if the condition is true.
508 F_LABEL is the label to jump to otherwise. */
511 gimple_build_cond (enum tree_code pred_code
, tree lhs
, tree rhs
,
512 tree t_label
, tree f_label
)
516 gcc_assert (TREE_CODE_CLASS (pred_code
) == tcc_comparison
);
517 p
= as_a
<gcond
*> (gimple_build_with_ops (GIMPLE_COND
, pred_code
, 4));
518 gimple_cond_set_lhs (p
, lhs
);
519 gimple_cond_set_rhs (p
, rhs
);
520 gimple_cond_set_true_label (p
, t_label
);
521 gimple_cond_set_false_label (p
, f_label
);
525 /* Build a GIMPLE_COND statement from the conditional expression tree
526 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
529 gimple_build_cond_from_tree (tree cond
, tree t_label
, tree f_label
)
534 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
535 return gimple_build_cond (code
, lhs
, rhs
, t_label
, f_label
);
538 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
539 boolean expression tree COND. */
542 gimple_cond_set_condition_from_tree (gcond
*stmt
, tree cond
)
547 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
548 gimple_cond_set_condition (stmt
, code
, lhs
, rhs
);
551 /* Build a GIMPLE_LABEL statement for LABEL. */
554 gimple_build_label (tree label
)
557 = as_a
<glabel
*> (gimple_build_with_ops (GIMPLE_LABEL
, ERROR_MARK
, 1));
558 gimple_label_set_label (p
, label
);
562 /* Build a GIMPLE_GOTO statement to label DEST. */
565 gimple_build_goto (tree dest
)
568 = as_a
<ggoto
*> (gimple_build_with_ops (GIMPLE_GOTO
, ERROR_MARK
, 1));
569 gimple_goto_set_dest (p
, dest
);
574 /* Build a GIMPLE_NOP statement. */
577 gimple_build_nop (void)
579 return gimple_alloc (GIMPLE_NOP
, 0);
583 /* Build a GIMPLE_BIND statement.
584 VARS are the variables in BODY.
585 BLOCK is the containing block. */
588 gimple_build_bind (tree vars
, gimple_seq body
, tree block
)
590 gbind
*p
= as_a
<gbind
*> (gimple_alloc (GIMPLE_BIND
, 0));
591 gimple_bind_set_vars (p
, vars
);
593 gimple_bind_set_body (p
, body
);
595 gimple_bind_set_block (p
, block
);
599 /* Helper function to set the simple fields of a asm stmt.
601 STRING is a pointer to a string that is the asm blocks assembly code.
602 NINPUT is the number of register inputs.
603 NOUTPUT is the number of register outputs.
604 NCLOBBERS is the number of clobbered registers.
608 gimple_build_asm_1 (const char *string
, unsigned ninputs
, unsigned noutputs
,
609 unsigned nclobbers
, unsigned nlabels
)
612 int size
= strlen (string
);
614 /* ASMs with labels cannot have outputs. This should have been
615 enforced by the front end. */
616 gcc_assert (nlabels
== 0 || noutputs
== 0);
619 gimple_build_with_ops (GIMPLE_ASM
, ERROR_MARK
,
620 ninputs
+ noutputs
+ nclobbers
+ nlabels
));
626 p
->string
= ggc_alloc_string (string
, size
);
628 if (GATHER_STATISTICS
)
629 gimple_alloc_sizes
[(int) gimple_alloc_kind (GIMPLE_ASM
)] += size
;
634 /* Build a GIMPLE_ASM statement.
636 STRING is the assembly code.
637 NINPUT is the number of register inputs.
638 NOUTPUT is the number of register outputs.
639 NCLOBBERS is the number of clobbered registers.
640 INPUTS is a vector of the input register parameters.
641 OUTPUTS is a vector of the output register parameters.
642 CLOBBERS is a vector of the clobbered register parameters.
643 LABELS is a vector of destination labels. */
646 gimple_build_asm_vec (const char *string
, vec
<tree
, va_gc
> *inputs
,
647 vec
<tree
, va_gc
> *outputs
, vec
<tree
, va_gc
> *clobbers
,
648 vec
<tree
, va_gc
> *labels
)
653 p
= gimple_build_asm_1 (string
,
654 vec_safe_length (inputs
),
655 vec_safe_length (outputs
),
656 vec_safe_length (clobbers
),
657 vec_safe_length (labels
));
659 for (i
= 0; i
< vec_safe_length (inputs
); i
++)
660 gimple_asm_set_input_op (p
, i
, (*inputs
)[i
]);
662 for (i
= 0; i
< vec_safe_length (outputs
); i
++)
663 gimple_asm_set_output_op (p
, i
, (*outputs
)[i
]);
665 for (i
= 0; i
< vec_safe_length (clobbers
); i
++)
666 gimple_asm_set_clobber_op (p
, i
, (*clobbers
)[i
]);
668 for (i
= 0; i
< vec_safe_length (labels
); i
++)
669 gimple_asm_set_label_op (p
, i
, (*labels
)[i
]);
674 /* Build a GIMPLE_CATCH statement.
676 TYPES are the catch types.
677 HANDLER is the exception handler. */
680 gimple_build_catch (tree types
, gimple_seq handler
)
682 gcatch
*p
= as_a
<gcatch
*> (gimple_alloc (GIMPLE_CATCH
, 0));
683 gimple_catch_set_types (p
, types
);
685 gimple_catch_set_handler (p
, handler
);
690 /* Build a GIMPLE_EH_FILTER statement.
692 TYPES are the filter's types.
693 FAILURE is the filter's failure action. */
696 gimple_build_eh_filter (tree types
, gimple_seq failure
)
698 geh_filter
*p
= as_a
<geh_filter
*> (gimple_alloc (GIMPLE_EH_FILTER
, 0));
699 gimple_eh_filter_set_types (p
, types
);
701 gimple_eh_filter_set_failure (p
, failure
);
706 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
709 gimple_build_eh_must_not_throw (tree decl
)
711 geh_mnt
*p
= as_a
<geh_mnt
*> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW
, 0));
713 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
714 gcc_assert (flags_from_decl_or_type (decl
) & ECF_NORETURN
);
715 gimple_eh_must_not_throw_set_fndecl (p
, decl
);
720 /* Build a GIMPLE_EH_ELSE statement. */
723 gimple_build_eh_else (gimple_seq n_body
, gimple_seq e_body
)
725 geh_else
*p
= as_a
<geh_else
*> (gimple_alloc (GIMPLE_EH_ELSE
, 0));
726 gimple_eh_else_set_n_body (p
, n_body
);
727 gimple_eh_else_set_e_body (p
, e_body
);
731 /* Build a GIMPLE_TRY statement.
733 EVAL is the expression to evaluate.
734 CLEANUP is the cleanup expression.
735 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
736 whether this is a try/catch or a try/finally respectively. */
739 gimple_build_try (gimple_seq eval
, gimple_seq cleanup
,
740 enum gimple_try_flags kind
)
744 gcc_assert (kind
== GIMPLE_TRY_CATCH
|| kind
== GIMPLE_TRY_FINALLY
);
745 p
= as_a
<gtry
*> (gimple_alloc (GIMPLE_TRY
, 0));
746 gimple_set_subcode (p
, kind
);
748 gimple_try_set_eval (p
, eval
);
750 gimple_try_set_cleanup (p
, cleanup
);
755 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
757 CLEANUP is the cleanup expression. */
760 gimple_build_wce (gimple_seq cleanup
)
762 gimple
*p
= gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR
, 0);
764 gimple_wce_set_cleanup (p
, cleanup
);
770 /* Build a GIMPLE_RESX statement. */
773 gimple_build_resx (int region
)
776 = as_a
<gresx
*> (gimple_build_with_ops (GIMPLE_RESX
, ERROR_MARK
, 0));
782 /* The helper for constructing a gimple switch statement.
783 INDEX is the switch's index.
784 NLABELS is the number of labels in the switch excluding the default.
785 DEFAULT_LABEL is the default label for the switch statement. */
788 gimple_build_switch_nlabels (unsigned nlabels
, tree index
, tree default_label
)
790 /* nlabels + 1 default label + 1 index. */
791 gcc_checking_assert (default_label
);
792 gswitch
*p
= as_a
<gswitch
*> (gimple_build_with_ops (GIMPLE_SWITCH
,
795 gimple_switch_set_index (p
, index
);
796 gimple_switch_set_default_label (p
, default_label
);
800 /* Build a GIMPLE_SWITCH statement.
802 INDEX is the switch's index.
803 DEFAULT_LABEL is the default label
804 ARGS is a vector of labels excluding the default. */
807 gimple_build_switch (tree index
, tree default_label
, vec
<tree
> args
)
809 unsigned i
, nlabels
= args
.length ();
811 gswitch
*p
= gimple_build_switch_nlabels (nlabels
, index
, default_label
);
813 /* Copy the labels from the vector to the switch statement. */
814 for (i
= 0; i
< nlabels
; i
++)
815 gimple_switch_set_label (p
, i
+ 1, args
[i
]);
820 /* Build a GIMPLE_EH_DISPATCH statement. */
823 gimple_build_eh_dispatch (int region
)
826 = as_a
<geh_dispatch
*> (
827 gimple_build_with_ops (GIMPLE_EH_DISPATCH
, ERROR_MARK
, 0));
832 /* Build a new GIMPLE_DEBUG_BIND statement.
834 VAR is bound to VALUE; block and location are taken from STMT. */
837 gimple_build_debug_bind (tree var
, tree value
, gimple
*stmt MEM_STAT_DECL
)
840 = as_a
<gdebug
*> (gimple_build_with_ops_stat (GIMPLE_DEBUG
,
841 (unsigned)GIMPLE_DEBUG_BIND
, 2
843 gimple_debug_bind_set_var (p
, var
);
844 gimple_debug_bind_set_value (p
, value
);
846 gimple_set_location (p
, gimple_location (stmt
));
852 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
854 VAR is bound to VALUE; block and location are taken from STMT. */
857 gimple_build_debug_source_bind (tree var
, tree value
,
858 gimple
*stmt MEM_STAT_DECL
)
862 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
863 (unsigned)GIMPLE_DEBUG_SOURCE_BIND
, 2
866 gimple_debug_source_bind_set_var (p
, var
);
867 gimple_debug_source_bind_set_value (p
, value
);
869 gimple_set_location (p
, gimple_location (stmt
));
875 /* Build a new GIMPLE_DEBUG_BEGIN_STMT statement in BLOCK at
879 gimple_build_debug_begin_stmt (tree block
, location_t location
884 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
885 (unsigned)GIMPLE_DEBUG_BEGIN_STMT
, 0
888 gimple_set_location (p
, location
);
889 gimple_set_block (p
, block
);
890 cfun
->debug_marker_count
++;
896 /* Build a new GIMPLE_DEBUG_INLINE_ENTRY statement in BLOCK at
897 LOCATION. The BLOCK links to the inlined function. */
900 gimple_build_debug_inline_entry (tree block
, location_t location
905 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
906 (unsigned)GIMPLE_DEBUG_INLINE_ENTRY
, 0
909 gimple_set_location (p
, location
);
910 gimple_set_block (p
, block
);
911 cfun
->debug_marker_count
++;
917 /* Build a GIMPLE_OMP_CRITICAL statement.
919 BODY is the sequence of statements for which only one thread can execute.
920 NAME is optional identifier for this critical block.
921 CLAUSES are clauses for this critical block. */
924 gimple_build_omp_critical (gimple_seq body
, tree name
, tree clauses
)
927 = as_a
<gomp_critical
*> (gimple_alloc (GIMPLE_OMP_CRITICAL
, 0));
928 gimple_omp_critical_set_name (p
, name
);
929 gimple_omp_critical_set_clauses (p
, clauses
);
931 gimple_omp_set_body (p
, body
);
936 /* Build a GIMPLE_OMP_FOR statement.
938 BODY is sequence of statements inside the for loop.
939 KIND is the `for' variant.
940 CLAUSES are any of the construct's clauses.
941 COLLAPSE is the collapse count.
942 PRE_BODY is the sequence of statements that are loop invariant. */
945 gimple_build_omp_for (gimple_seq body
, int kind
, tree clauses
, size_t collapse
,
948 gomp_for
*p
= as_a
<gomp_for
*> (gimple_alloc (GIMPLE_OMP_FOR
, 0));
950 gimple_omp_set_body (p
, body
);
951 gimple_omp_for_set_clauses (p
, clauses
);
952 gimple_omp_for_set_kind (p
, kind
);
953 p
->collapse
= collapse
;
954 p
->iter
= ggc_cleared_vec_alloc
<gimple_omp_for_iter
> (collapse
);
957 gimple_omp_for_set_pre_body (p
, pre_body
);
963 /* Build a GIMPLE_OMP_PARALLEL statement.
965 BODY is sequence of statements which are executed in parallel.
966 CLAUSES are the OMP parallel construct's clauses.
967 CHILD_FN is the function created for the parallel threads to execute.
968 DATA_ARG are the shared data argument(s). */
971 gimple_build_omp_parallel (gimple_seq body
, tree clauses
, tree child_fn
,
975 = as_a
<gomp_parallel
*> (gimple_alloc (GIMPLE_OMP_PARALLEL
, 0));
977 gimple_omp_set_body (p
, body
);
978 gimple_omp_parallel_set_clauses (p
, clauses
);
979 gimple_omp_parallel_set_child_fn (p
, child_fn
);
980 gimple_omp_parallel_set_data_arg (p
, data_arg
);
986 /* Build a GIMPLE_OMP_TASK statement.
988 BODY is sequence of statements which are executed by the explicit task.
989 CLAUSES are the OMP task construct's clauses.
990 CHILD_FN is the function created for the parallel threads to execute.
991 DATA_ARG are the shared data argument(s).
992 COPY_FN is the optional function for firstprivate initialization.
993 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
996 gimple_build_omp_task (gimple_seq body
, tree clauses
, tree child_fn
,
997 tree data_arg
, tree copy_fn
, tree arg_size
,
1000 gomp_task
*p
= as_a
<gomp_task
*> (gimple_alloc (GIMPLE_OMP_TASK
, 0));
1002 gimple_omp_set_body (p
, body
);
1003 gimple_omp_task_set_clauses (p
, clauses
);
1004 gimple_omp_task_set_child_fn (p
, child_fn
);
1005 gimple_omp_task_set_data_arg (p
, data_arg
);
1006 gimple_omp_task_set_copy_fn (p
, copy_fn
);
1007 gimple_omp_task_set_arg_size (p
, arg_size
);
1008 gimple_omp_task_set_arg_align (p
, arg_align
);
1014 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
1016 BODY is the sequence of statements in the section. */
1019 gimple_build_omp_section (gimple_seq body
)
1021 gimple
*p
= gimple_alloc (GIMPLE_OMP_SECTION
, 0);
1023 gimple_omp_set_body (p
, body
);
1029 /* Build a GIMPLE_OMP_MASTER statement.
1031 BODY is the sequence of statements to be executed by just the master. */
1034 gimple_build_omp_master (gimple_seq body
)
1036 gimple
*p
= gimple_alloc (GIMPLE_OMP_MASTER
, 0);
1038 gimple_omp_set_body (p
, body
);
1043 /* Build a GIMPLE_OMP_TASKGROUP statement.
1045 BODY is the sequence of statements to be executed by the taskgroup
1047 CLAUSES are any of the construct's clauses. */
1050 gimple_build_omp_taskgroup (gimple_seq body
, tree clauses
)
1052 gimple
*p
= gimple_alloc (GIMPLE_OMP_TASKGROUP
, 0);
1053 gimple_omp_taskgroup_set_clauses (p
, clauses
);
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_SCAN statement.
1111 BODY is the sequence of statements to be executed by the scan
1113 CLAUSES are any of the construct's clauses. */
1116 gimple_build_omp_scan (gimple_seq body
, tree clauses
)
1119 = as_a
<gomp_scan
*> (gimple_alloc (GIMPLE_OMP_SCAN
, 0));
1120 gimple_omp_scan_set_clauses (p
, clauses
);
1122 gimple_omp_set_body (p
, body
);
1128 /* Build a GIMPLE_OMP_SECTIONS statement.
1130 BODY is a sequence of section statements.
1131 CLAUSES are any of the OMP sections contsruct's clauses: private,
1132 firstprivate, lastprivate, reduction, and nowait. */
1135 gimple_build_omp_sections (gimple_seq body
, tree clauses
)
1138 = as_a
<gomp_sections
*> (gimple_alloc (GIMPLE_OMP_SECTIONS
, 0));
1140 gimple_omp_set_body (p
, body
);
1141 gimple_omp_sections_set_clauses (p
, clauses
);
1147 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1150 gimple_build_omp_sections_switch (void)
1152 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH
, 0);
1156 /* Build a GIMPLE_OMP_SINGLE statement.
1158 BODY is the sequence of statements that will be executed once.
1159 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1160 copyprivate, nowait. */
1163 gimple_build_omp_single (gimple_seq body
, tree clauses
)
1166 = as_a
<gomp_single
*> (gimple_alloc (GIMPLE_OMP_SINGLE
, 0));
1168 gimple_omp_set_body (p
, body
);
1169 gimple_omp_single_set_clauses (p
, clauses
);
1175 /* Build a GIMPLE_OMP_TARGET statement.
1177 BODY is the sequence of statements that will be executed.
1178 KIND is the kind of the region.
1179 CLAUSES are any of the construct's clauses. */
1182 gimple_build_omp_target (gimple_seq body
, int kind
, tree clauses
)
1185 = as_a
<gomp_target
*> (gimple_alloc (GIMPLE_OMP_TARGET
, 0));
1187 gimple_omp_set_body (p
, body
);
1188 gimple_omp_target_set_clauses (p
, clauses
);
1189 gimple_omp_target_set_kind (p
, kind
);
1195 /* Build a GIMPLE_OMP_TEAMS statement.
1197 BODY is the sequence of statements that will be executed.
1198 CLAUSES are any of the OMP teams construct's clauses. */
1201 gimple_build_omp_teams (gimple_seq body
, tree clauses
)
1203 gomp_teams
*p
= as_a
<gomp_teams
*> (gimple_alloc (GIMPLE_OMP_TEAMS
, 0));
1205 gimple_omp_set_body (p
, body
);
1206 gimple_omp_teams_set_clauses (p
, clauses
);
1212 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1215 gimple_build_omp_atomic_load (tree lhs
, tree rhs
, enum omp_memory_order mo
)
1218 = as_a
<gomp_atomic_load
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD
, 0));
1219 gimple_omp_atomic_load_set_lhs (p
, lhs
);
1220 gimple_omp_atomic_load_set_rhs (p
, rhs
);
1221 gimple_omp_atomic_set_memory_order (p
, mo
);
1225 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1227 VAL is the value we are storing. */
1230 gimple_build_omp_atomic_store (tree val
, enum omp_memory_order mo
)
1232 gomp_atomic_store
*p
1233 = as_a
<gomp_atomic_store
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE
, 0));
1234 gimple_omp_atomic_store_set_val (p
, val
);
1235 gimple_omp_atomic_set_memory_order (p
, mo
);
1239 /* Build a GIMPLE_TRANSACTION statement. */
1242 gimple_build_transaction (gimple_seq body
)
1245 = as_a
<gtransaction
*> (gimple_alloc (GIMPLE_TRANSACTION
, 0));
1246 gimple_transaction_set_body (p
, body
);
1247 gimple_transaction_set_label_norm (p
, 0);
1248 gimple_transaction_set_label_uninst (p
, 0);
1249 gimple_transaction_set_label_over (p
, 0);
1253 #if defined ENABLE_GIMPLE_CHECKING
1254 /* Complain of a gimple type mismatch and die. */
1257 gimple_check_failed (const gimple
*gs
, const char *file
, int line
,
1258 const char *function
, enum gimple_code code
,
1259 enum tree_code subcode
)
1261 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1262 gimple_code_name
[code
],
1263 get_tree_code_name (subcode
),
1264 gimple_code_name
[gimple_code (gs
)],
1266 ? get_tree_code_name ((enum tree_code
) gs
->subcode
)
1268 function
, trim_filename (file
), line
);
1270 #endif /* ENABLE_GIMPLE_CHECKING */
1273 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1274 *SEQ_P is NULL, a new sequence is allocated. */
1277 gimple_seq_add_stmt (gimple_seq
*seq_p
, gimple
*gs
)
1279 gimple_stmt_iterator si
;
1283 si
= gsi_last (*seq_p
);
1284 gsi_insert_after (&si
, gs
, GSI_NEW_STMT
);
1287 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1288 *SEQ_P is NULL, a new sequence is allocated. This function is
1289 similar to gimple_seq_add_stmt, but does not scan the operands.
1290 During gimplification, we need to manipulate statement sequences
1291 before the def/use vectors have been constructed. */
1294 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple
*gs
)
1296 gimple_stmt_iterator si
;
1301 si
= gsi_last (*seq_p
);
1302 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
1305 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1306 NULL, a new sequence is allocated. */
1309 gimple_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
1311 gimple_stmt_iterator si
;
1315 si
= gsi_last (*dst_p
);
1316 gsi_insert_seq_after (&si
, src
, GSI_NEW_STMT
);
1319 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1320 NULL, a new sequence is allocated. This function is
1321 similar to gimple_seq_add_seq, but does not scan the operands. */
1324 gimple_seq_add_seq_without_update (gimple_seq
*dst_p
, gimple_seq src
)
1326 gimple_stmt_iterator si
;
1330 si
= gsi_last (*dst_p
);
1331 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
1334 /* Determine whether to assign a location to the statement GS. */
1337 should_carry_location_p (gimple
*gs
)
1339 /* Don't emit a line note for a label. We particularly don't want to
1340 emit one for the break label, since it doesn't actually correspond
1341 to the beginning of the loop/switch. */
1342 if (gimple_code (gs
) == GIMPLE_LABEL
)
1348 /* Set the location for gimple statement GS to LOCATION. */
1351 annotate_one_with_location (gimple
*gs
, location_t location
)
1353 if (!gimple_has_location (gs
)
1354 && !gimple_do_not_emit_location_p (gs
)
1355 && should_carry_location_p (gs
))
1356 gimple_set_location (gs
, location
);
1359 /* Set LOCATION for all the statements after iterator GSI in sequence
1360 SEQ. If GSI is pointing to the end of the sequence, start with the
1361 first statement in SEQ. */
1364 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
1365 location_t location
)
1367 if (gsi_end_p (gsi
))
1368 gsi
= gsi_start (seq
);
1372 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
1373 annotate_one_with_location (gsi_stmt (gsi
), location
);
1376 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1379 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
1381 gimple_stmt_iterator i
;
1383 if (gimple_seq_empty_p (stmt_p
))
1386 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
1388 gimple
*gs
= gsi_stmt (i
);
1389 annotate_one_with_location (gs
, location
);
1393 /* Helper function of empty_body_p. Return true if STMT is an empty
1397 empty_stmt_p (gimple
*stmt
)
1399 if (gimple_code (stmt
) == GIMPLE_NOP
)
1401 if (gbind
*bind_stmt
= dyn_cast
<gbind
*> (stmt
))
1402 return empty_body_p (gimple_bind_body (bind_stmt
));
1407 /* Return true if BODY contains nothing but empty statements. */
1410 empty_body_p (gimple_seq body
)
1412 gimple_stmt_iterator i
;
1414 if (gimple_seq_empty_p (body
))
1416 for (i
= gsi_start (body
); !gsi_end_p (i
); gsi_next (&i
))
1417 if (!empty_stmt_p (gsi_stmt (i
))
1418 && !is_gimple_debug (gsi_stmt (i
)))
1425 /* Perform a deep copy of sequence SRC and return the result. */
1428 gimple_seq_copy (gimple_seq src
)
1430 gimple_stmt_iterator gsi
;
1431 gimple_seq new_seq
= NULL
;
1434 for (gsi
= gsi_start (src
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1436 stmt
= gimple_copy (gsi_stmt (gsi
));
1437 gimple_seq_add_stmt (&new_seq
, stmt
);
1445 /* Return true if calls C1 and C2 are known to go to the same function. */
1448 gimple_call_same_target_p (const gimple
*c1
, const gimple
*c2
)
1450 if (gimple_call_internal_p (c1
))
1451 return (gimple_call_internal_p (c2
)
1452 && gimple_call_internal_fn (c1
) == gimple_call_internal_fn (c2
)
1453 && (!gimple_call_internal_unique_p (as_a
<const gcall
*> (c1
))
1456 return (gimple_call_fn (c1
) == gimple_call_fn (c2
)
1457 || (gimple_call_fndecl (c1
)
1458 && gimple_call_fndecl (c1
) == gimple_call_fndecl (c2
)));
1461 /* Detect flags from a GIMPLE_CALL. This is just like
1462 call_expr_flags, but for gimple tuples. */
1465 gimple_call_flags (const gimple
*stmt
)
1469 if (gimple_call_internal_p (stmt
))
1470 flags
= internal_fn_flags (gimple_call_internal_fn (stmt
));
1473 tree decl
= gimple_call_fndecl (stmt
);
1475 flags
= flags_from_decl_or_type (decl
);
1476 flags
|= flags_from_decl_or_type (gimple_call_fntype (stmt
));
1479 if (stmt
->subcode
& GF_CALL_NOTHROW
)
1480 flags
|= ECF_NOTHROW
;
1482 if (stmt
->subcode
& GF_CALL_BY_DESCRIPTOR
)
1483 flags
|= ECF_BY_DESCRIPTOR
;
1488 /* Return the "fn spec" string for call STMT. */
1491 gimple_call_fnspec (const gcall
*stmt
)
1495 if (gimple_call_internal_p (stmt
))
1497 const_tree spec
= internal_fn_fnspec (gimple_call_internal_fn (stmt
));
1504 type
= gimple_call_fntype (stmt
);
1507 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
1509 return TREE_VALUE (TREE_VALUE (attr
));
1511 if (gimple_call_builtin_p (stmt
, BUILT_IN_NORMAL
))
1512 return builtin_fnspec (gimple_call_fndecl (stmt
));
1513 tree fndecl
= gimple_call_fndecl (stmt
);
1514 /* If the call is to a replaceable operator delete and results
1515 from a delete expression as opposed to a direct call to
1516 such operator, then we can treat it as free. */
1518 && DECL_IS_OPERATOR_DELETE_P (fndecl
)
1519 && gimple_call_from_new_or_delete (stmt
))
1521 /* Similarly operator new can be treated as malloc. */
1523 && DECL_IS_OPERATOR_NEW_P (fndecl
)
1524 && gimple_call_from_new_or_delete (stmt
))
1529 /* Detects argument flags for argument number ARG on call STMT. */
1532 gimple_call_arg_flags (const gcall
*stmt
, unsigned arg
)
1534 attr_fnspec fnspec
= gimple_call_fnspec (stmt
);
1536 if (!fnspec
.known_p ())
1541 if (!fnspec
.arg_specified_p (arg
))
1543 else if (!fnspec
.arg_used_p (arg
))
1547 if (fnspec
.arg_direct_p (arg
))
1548 flags
|= EAF_DIRECT
;
1549 if (fnspec
.arg_noescape_p (arg
))
1550 flags
|= EAF_NOESCAPE
;
1551 if (fnspec
.arg_readonly_p (arg
))
1552 flags
|= EAF_NOCLOBBER
;
1557 /* Detects return flags for the call STMT. */
1560 gimple_call_return_flags (const gcall
*stmt
)
1562 if (gimple_call_flags (stmt
) & ECF_MALLOC
)
1565 attr_fnspec fnspec
= gimple_call_fnspec (stmt
);
1567 unsigned int arg_no
;
1568 if (fnspec
.returns_arg (&arg_no
))
1569 return ERF_RETURNS_ARG
| arg_no
;
1571 if (fnspec
.returns_noalias_p ())
1577 /* Return true if call STMT is known to return a non-zero result. */
1580 gimple_call_nonnull_result_p (gcall
*call
)
1582 tree fndecl
= gimple_call_fndecl (call
);
1585 if (flag_delete_null_pointer_checks
&& !flag_check_new
1586 && DECL_IS_OPERATOR_NEW_P (fndecl
)
1587 && !TREE_NOTHROW (fndecl
))
1590 /* References are always non-NULL. */
1591 if (flag_delete_null_pointer_checks
1592 && TREE_CODE (TREE_TYPE (fndecl
)) == REFERENCE_TYPE
)
1595 if (flag_delete_null_pointer_checks
1596 && lookup_attribute ("returns_nonnull",
1597 TYPE_ATTRIBUTES (gimple_call_fntype (call
))))
1599 return gimple_alloca_call_p (call
);
1603 /* If CALL returns a non-null result in an argument, return that arg. */
1606 gimple_call_nonnull_arg (gcall
*call
)
1608 tree fndecl
= gimple_call_fndecl (call
);
1612 unsigned rf
= gimple_call_return_flags (call
);
1613 if (rf
& ERF_RETURNS_ARG
)
1615 unsigned argnum
= rf
& ERF_RETURN_ARG_MASK
;
1616 if (argnum
< gimple_call_num_args (call
))
1618 tree arg
= gimple_call_arg (call
, argnum
);
1620 && infer_nonnull_range_by_attribute (call
, arg
))
1628 /* Return true if GS is a copy assignment. */
1631 gimple_assign_copy_p (gimple
*gs
)
1633 return (gimple_assign_single_p (gs
)
1634 && is_gimple_val (gimple_op (gs
, 1)));
1638 /* Return true if GS is a SSA_NAME copy assignment. */
1641 gimple_assign_ssa_name_copy_p (gimple
*gs
)
1643 return (gimple_assign_single_p (gs
)
1644 && TREE_CODE (gimple_assign_lhs (gs
)) == SSA_NAME
1645 && TREE_CODE (gimple_assign_rhs1 (gs
)) == SSA_NAME
);
1649 /* Return true if GS is an assignment with a unary RHS, but the
1650 operator has no effect on the assigned value. The logic is adapted
1651 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1652 instances in which STRIP_NOPS was previously applied to the RHS of
1655 NOTE: In the use cases that led to the creation of this function
1656 and of gimple_assign_single_p, it is typical to test for either
1657 condition and to proceed in the same manner. In each case, the
1658 assigned value is represented by the single RHS operand of the
1659 assignment. I suspect there may be cases where gimple_assign_copy_p,
1660 gimple_assign_single_p, or equivalent logic is used where a similar
1661 treatment of unary NOPs is appropriate. */
1664 gimple_assign_unary_nop_p (gimple
*gs
)
1666 return (is_gimple_assign (gs
)
1667 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs
))
1668 || gimple_assign_rhs_code (gs
) == NON_LVALUE_EXPR
)
1669 && gimple_assign_rhs1 (gs
) != error_mark_node
1670 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs
)))
1671 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs
)))));
1674 /* Set BB to be the basic block holding G. */
1677 gimple_set_bb (gimple
*stmt
, basic_block bb
)
1681 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1684 /* If the statement is a label, add the label to block-to-labels map
1685 so that we can speed up edge creation for GIMPLE_GOTOs. */
1691 t
= gimple_label_label (as_a
<glabel
*> (stmt
));
1692 uid
= LABEL_DECL_UID (t
);
1696 vec_safe_length (label_to_block_map_for_fn (cfun
));
1697 LABEL_DECL_UID (t
) = uid
= cfun
->cfg
->last_label_uid
++;
1698 if (old_len
<= (unsigned) uid
)
1699 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun
), uid
+ 1);
1702 (*label_to_block_map_for_fn (cfun
))[uid
] = bb
;
1707 /* Modify the RHS of the assignment pointed-to by GSI using the
1708 operands in the expression tree EXPR.
1710 NOTE: The statement pointed-to by GSI may be reallocated if it
1711 did not have enough operand slots.
1713 This function is useful to convert an existing tree expression into
1714 the flat representation used for the RHS of a GIMPLE assignment.
1715 It will reallocate memory as needed to expand or shrink the number
1716 of operand slots needed to represent EXPR.
1718 NOTE: If you find yourself building a tree and then calling this
1719 function, you are most certainly doing it the slow way. It is much
1720 better to build a new assignment or to use the function
1721 gimple_assign_set_rhs_with_ops, which does not require an
1722 expression tree to be built. */
1725 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*gsi
, tree expr
)
1727 enum tree_code subcode
;
1730 extract_ops_from_tree (expr
, &subcode
, &op1
, &op2
, &op3
);
1731 gimple_assign_set_rhs_with_ops (gsi
, subcode
, op1
, op2
, op3
);
1735 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1736 operands OP1, OP2 and OP3.
1738 NOTE: The statement pointed-to by GSI may be reallocated if it
1739 did not have enough operand slots. */
1742 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*gsi
, enum tree_code code
,
1743 tree op1
, tree op2
, tree op3
)
1745 unsigned new_rhs_ops
= get_gimple_rhs_num_ops (code
);
1746 gimple
*stmt
= gsi_stmt (*gsi
);
1747 gimple
*old_stmt
= stmt
;
1749 /* If the new CODE needs more operands, allocate a new statement. */
1750 if (gimple_num_ops (stmt
) < new_rhs_ops
+ 1)
1752 tree lhs
= gimple_assign_lhs (old_stmt
);
1753 stmt
= gimple_alloc (gimple_code (old_stmt
), new_rhs_ops
+ 1);
1754 memcpy (stmt
, old_stmt
, gimple_size (gimple_code (old_stmt
)));
1755 gimple_init_singleton (stmt
);
1757 /* The LHS needs to be reset as this also changes the SSA name
1759 gimple_assign_set_lhs (stmt
, lhs
);
1762 gimple_set_num_ops (stmt
, new_rhs_ops
+ 1);
1763 gimple_set_subcode (stmt
, code
);
1764 gimple_assign_set_rhs1 (stmt
, op1
);
1765 if (new_rhs_ops
> 1)
1766 gimple_assign_set_rhs2 (stmt
, op2
);
1767 if (new_rhs_ops
> 2)
1768 gimple_assign_set_rhs3 (stmt
, op3
);
1769 if (stmt
!= old_stmt
)
1770 gsi_replace (gsi
, stmt
, false);
1774 /* Return the LHS of a statement that performs an assignment,
1775 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1776 for a call to a function that returns no value, or for a
1777 statement other than an assignment or a call. */
1780 gimple_get_lhs (const gimple
*stmt
)
1782 enum gimple_code code
= gimple_code (stmt
);
1784 if (code
== GIMPLE_ASSIGN
)
1785 return gimple_assign_lhs (stmt
);
1786 else if (code
== GIMPLE_CALL
)
1787 return gimple_call_lhs (stmt
);
1788 else if (code
== GIMPLE_PHI
)
1789 return gimple_phi_result (stmt
);
1795 /* Set the LHS of a statement that performs an assignment,
1796 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1799 gimple_set_lhs (gimple
*stmt
, tree lhs
)
1801 enum gimple_code code
= gimple_code (stmt
);
1803 if (code
== GIMPLE_ASSIGN
)
1804 gimple_assign_set_lhs (stmt
, lhs
);
1805 else if (code
== GIMPLE_CALL
)
1806 gimple_call_set_lhs (stmt
, lhs
);
1812 /* Return a deep copy of statement STMT. All the operands from STMT
1813 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1814 and VUSE operand arrays are set to empty in the new copy. The new
1815 copy isn't part of any sequence. */
1818 gimple_copy (gimple
*stmt
)
1820 enum gimple_code code
= gimple_code (stmt
);
1821 unsigned num_ops
= gimple_num_ops (stmt
);
1822 gimple
*copy
= gimple_alloc (code
, num_ops
);
1825 /* Shallow copy all the fields from STMT. */
1826 memcpy (copy
, stmt
, gimple_size (code
));
1827 gimple_init_singleton (copy
);
1829 /* If STMT has sub-statements, deep-copy them as well. */
1830 if (gimple_has_substatements (stmt
))
1835 switch (gimple_code (stmt
))
1839 gbind
*bind_stmt
= as_a
<gbind
*> (stmt
);
1840 gbind
*bind_copy
= as_a
<gbind
*> (copy
);
1841 new_seq
= gimple_seq_copy (gimple_bind_body (bind_stmt
));
1842 gimple_bind_set_body (bind_copy
, new_seq
);
1843 gimple_bind_set_vars (bind_copy
,
1844 unshare_expr (gimple_bind_vars (bind_stmt
)));
1845 gimple_bind_set_block (bind_copy
, gimple_bind_block (bind_stmt
));
1851 gcatch
*catch_stmt
= as_a
<gcatch
*> (stmt
);
1852 gcatch
*catch_copy
= as_a
<gcatch
*> (copy
);
1853 new_seq
= gimple_seq_copy (gimple_catch_handler (catch_stmt
));
1854 gimple_catch_set_handler (catch_copy
, new_seq
);
1855 t
= unshare_expr (gimple_catch_types (catch_stmt
));
1856 gimple_catch_set_types (catch_copy
, t
);
1860 case GIMPLE_EH_FILTER
:
1862 geh_filter
*eh_filter_stmt
= as_a
<geh_filter
*> (stmt
);
1863 geh_filter
*eh_filter_copy
= as_a
<geh_filter
*> (copy
);
1865 = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt
));
1866 gimple_eh_filter_set_failure (eh_filter_copy
, new_seq
);
1867 t
= unshare_expr (gimple_eh_filter_types (eh_filter_stmt
));
1868 gimple_eh_filter_set_types (eh_filter_copy
, t
);
1872 case GIMPLE_EH_ELSE
:
1874 geh_else
*eh_else_stmt
= as_a
<geh_else
*> (stmt
);
1875 geh_else
*eh_else_copy
= as_a
<geh_else
*> (copy
);
1876 new_seq
= gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt
));
1877 gimple_eh_else_set_n_body (eh_else_copy
, new_seq
);
1878 new_seq
= gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt
));
1879 gimple_eh_else_set_e_body (eh_else_copy
, new_seq
);
1885 gtry
*try_stmt
= as_a
<gtry
*> (stmt
);
1886 gtry
*try_copy
= as_a
<gtry
*> (copy
);
1887 new_seq
= gimple_seq_copy (gimple_try_eval (try_stmt
));
1888 gimple_try_set_eval (try_copy
, new_seq
);
1889 new_seq
= gimple_seq_copy (gimple_try_cleanup (try_stmt
));
1890 gimple_try_set_cleanup (try_copy
, new_seq
);
1894 case GIMPLE_OMP_FOR
:
1895 new_seq
= gimple_seq_copy (gimple_omp_for_pre_body (stmt
));
1896 gimple_omp_for_set_pre_body (copy
, new_seq
);
1897 t
= unshare_expr (gimple_omp_for_clauses (stmt
));
1898 gimple_omp_for_set_clauses (copy
, t
);
1900 gomp_for
*omp_for_copy
= as_a
<gomp_for
*> (copy
);
1901 omp_for_copy
->iter
= ggc_vec_alloc
<gimple_omp_for_iter
>
1902 ( gimple_omp_for_collapse (stmt
));
1904 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1906 gimple_omp_for_set_cond (copy
, i
,
1907 gimple_omp_for_cond (stmt
, i
));
1908 gimple_omp_for_set_index (copy
, i
,
1909 gimple_omp_for_index (stmt
, i
));
1910 t
= unshare_expr (gimple_omp_for_initial (stmt
, i
));
1911 gimple_omp_for_set_initial (copy
, i
, t
);
1912 t
= unshare_expr (gimple_omp_for_final (stmt
, i
));
1913 gimple_omp_for_set_final (copy
, i
, t
);
1914 t
= unshare_expr (gimple_omp_for_incr (stmt
, i
));
1915 gimple_omp_for_set_incr (copy
, i
, t
);
1919 case GIMPLE_OMP_PARALLEL
:
1921 gomp_parallel
*omp_par_stmt
= as_a
<gomp_parallel
*> (stmt
);
1922 gomp_parallel
*omp_par_copy
= as_a
<gomp_parallel
*> (copy
);
1923 t
= unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt
));
1924 gimple_omp_parallel_set_clauses (omp_par_copy
, t
);
1925 t
= unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt
));
1926 gimple_omp_parallel_set_child_fn (omp_par_copy
, t
);
1927 t
= unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt
));
1928 gimple_omp_parallel_set_data_arg (omp_par_copy
, t
);
1932 case GIMPLE_OMP_TASK
:
1933 t
= unshare_expr (gimple_omp_task_clauses (stmt
));
1934 gimple_omp_task_set_clauses (copy
, t
);
1935 t
= unshare_expr (gimple_omp_task_child_fn (stmt
));
1936 gimple_omp_task_set_child_fn (copy
, t
);
1937 t
= unshare_expr (gimple_omp_task_data_arg (stmt
));
1938 gimple_omp_task_set_data_arg (copy
, t
);
1939 t
= unshare_expr (gimple_omp_task_copy_fn (stmt
));
1940 gimple_omp_task_set_copy_fn (copy
, t
);
1941 t
= unshare_expr (gimple_omp_task_arg_size (stmt
));
1942 gimple_omp_task_set_arg_size (copy
, t
);
1943 t
= unshare_expr (gimple_omp_task_arg_align (stmt
));
1944 gimple_omp_task_set_arg_align (copy
, t
);
1947 case GIMPLE_OMP_CRITICAL
:
1948 t
= unshare_expr (gimple_omp_critical_name
1949 (as_a
<gomp_critical
*> (stmt
)));
1950 gimple_omp_critical_set_name (as_a
<gomp_critical
*> (copy
), t
);
1951 t
= unshare_expr (gimple_omp_critical_clauses
1952 (as_a
<gomp_critical
*> (stmt
)));
1953 gimple_omp_critical_set_clauses (as_a
<gomp_critical
*> (copy
), t
);
1956 case GIMPLE_OMP_ORDERED
:
1957 t
= unshare_expr (gimple_omp_ordered_clauses
1958 (as_a
<gomp_ordered
*> (stmt
)));
1959 gimple_omp_ordered_set_clauses (as_a
<gomp_ordered
*> (copy
), t
);
1962 case GIMPLE_OMP_SCAN
:
1963 t
= gimple_omp_scan_clauses (as_a
<gomp_scan
*> (stmt
));
1964 t
= unshare_expr (t
);
1965 gimple_omp_scan_set_clauses (as_a
<gomp_scan
*> (copy
), t
);
1968 case GIMPLE_OMP_TASKGROUP
:
1969 t
= unshare_expr (gimple_omp_taskgroup_clauses (stmt
));
1970 gimple_omp_taskgroup_set_clauses (copy
, t
);
1973 case GIMPLE_OMP_SECTIONS
:
1974 t
= unshare_expr (gimple_omp_sections_clauses (stmt
));
1975 gimple_omp_sections_set_clauses (copy
, t
);
1976 t
= unshare_expr (gimple_omp_sections_control (stmt
));
1977 gimple_omp_sections_set_control (copy
, t
);
1980 case GIMPLE_OMP_SINGLE
:
1982 gomp_single
*omp_single_copy
= as_a
<gomp_single
*> (copy
);
1983 t
= unshare_expr (gimple_omp_single_clauses (stmt
));
1984 gimple_omp_single_set_clauses (omp_single_copy
, t
);
1988 case GIMPLE_OMP_TARGET
:
1990 gomp_target
*omp_target_stmt
= as_a
<gomp_target
*> (stmt
);
1991 gomp_target
*omp_target_copy
= as_a
<gomp_target
*> (copy
);
1992 t
= unshare_expr (gimple_omp_target_clauses (omp_target_stmt
));
1993 gimple_omp_target_set_clauses (omp_target_copy
, t
);
1994 t
= unshare_expr (gimple_omp_target_data_arg (omp_target_stmt
));
1995 gimple_omp_target_set_data_arg (omp_target_copy
, t
);
1999 case GIMPLE_OMP_TEAMS
:
2001 gomp_teams
*omp_teams_copy
= as_a
<gomp_teams
*> (copy
);
2002 t
= unshare_expr (gimple_omp_teams_clauses (stmt
));
2003 gimple_omp_teams_set_clauses (omp_teams_copy
, t
);
2007 case GIMPLE_OMP_SECTION
:
2008 case GIMPLE_OMP_MASTER
:
2010 new_seq
= gimple_seq_copy (gimple_omp_body (stmt
));
2011 gimple_omp_set_body (copy
, new_seq
);
2014 case GIMPLE_TRANSACTION
:
2015 new_seq
= gimple_seq_copy (gimple_transaction_body (
2016 as_a
<gtransaction
*> (stmt
)));
2017 gimple_transaction_set_body (as_a
<gtransaction
*> (copy
),
2021 case GIMPLE_WITH_CLEANUP_EXPR
:
2022 new_seq
= gimple_seq_copy (gimple_wce_cleanup (stmt
));
2023 gimple_wce_set_cleanup (copy
, new_seq
);
2031 /* Make copy of operands. */
2032 for (i
= 0; i
< num_ops
; i
++)
2033 gimple_set_op (copy
, i
, unshare_expr (gimple_op (stmt
, i
)));
2035 if (gimple_has_mem_ops (stmt
))
2037 gimple_set_vdef (copy
, gimple_vdef (stmt
));
2038 gimple_set_vuse (copy
, gimple_vuse (stmt
));
2041 /* Clear out SSA operand vectors on COPY. */
2042 if (gimple_has_ops (stmt
))
2044 gimple_set_use_ops (copy
, NULL
);
2046 /* SSA operands need to be updated. */
2047 gimple_set_modified (copy
, true);
2050 if (gimple_debug_nonbind_marker_p (stmt
))
2051 cfun
->debug_marker_count
++;
2056 /* Move OLD_STMT's vuse and vdef operands to NEW_STMT, on the assumption
2057 that OLD_STMT is about to be removed. */
2060 gimple_move_vops (gimple
*new_stmt
, gimple
*old_stmt
)
2062 tree vdef
= gimple_vdef (old_stmt
);
2063 gimple_set_vuse (new_stmt
, gimple_vuse (old_stmt
));
2064 gimple_set_vdef (new_stmt
, vdef
);
2065 if (vdef
&& TREE_CODE (vdef
) == SSA_NAME
)
2066 SSA_NAME_DEF_STMT (vdef
) = new_stmt
;
2069 /* Return true if statement S has side-effects. We consider a
2070 statement to have side effects if:
2072 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
2073 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
2076 gimple_has_side_effects (const gimple
*s
)
2078 if (is_gimple_debug (s
))
2081 /* We don't have to scan the arguments to check for
2082 volatile arguments, though, at present, we still
2083 do a scan to check for TREE_SIDE_EFFECTS. */
2084 if (gimple_has_volatile_ops (s
))
2087 if (gimple_code (s
) == GIMPLE_ASM
2088 && gimple_asm_volatile_p (as_a
<const gasm
*> (s
)))
2091 if (is_gimple_call (s
))
2093 int flags
= gimple_call_flags (s
);
2095 /* An infinite loop is considered a side effect. */
2096 if (!(flags
& (ECF_CONST
| ECF_PURE
))
2097 || (flags
& ECF_LOOPING_CONST_OR_PURE
))
2106 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
2107 Return true if S can trap. When INCLUDE_MEM is true, check whether
2108 the memory operations could trap. When INCLUDE_STORES is true and
2109 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
2112 gimple_could_trap_p_1 (gimple
*s
, bool include_mem
, bool include_stores
)
2114 tree t
, div
= NULL_TREE
;
2119 unsigned i
, start
= (is_gimple_assign (s
) && !include_stores
) ? 1 : 0;
2121 for (i
= start
; i
< gimple_num_ops (s
); i
++)
2122 if (tree_could_trap_p (gimple_op (s
, i
)))
2126 switch (gimple_code (s
))
2129 return gimple_asm_volatile_p (as_a
<gasm
*> (s
));
2132 t
= gimple_call_fndecl (s
);
2133 /* Assume that calls to weak functions may trap. */
2134 if (!t
|| !DECL_P (t
) || DECL_WEAK (t
))
2139 op
= gimple_assign_rhs_code (s
);
2141 /* For COND_EXPR and VEC_COND_EXPR only the condition may trap. */
2142 if (op
== COND_EXPR
|| op
== VEC_COND_EXPR
)
2143 return tree_could_trap_p (gimple_assign_rhs1 (s
));
2145 /* For comparisons we need to check rhs operand types instead of rhs type
2146 (which is BOOLEAN_TYPE). */
2147 if (TREE_CODE_CLASS (op
) == tcc_comparison
)
2148 t
= TREE_TYPE (gimple_assign_rhs1 (s
));
2150 t
= gimple_expr_type (s
);
2152 if (get_gimple_rhs_class (op
) == GIMPLE_BINARY_RHS
)
2153 div
= gimple_assign_rhs2 (s
);
2155 return (operation_could_trap_p (op
, FLOAT_TYPE_P (t
),
2156 (INTEGRAL_TYPE_P (t
)
2157 && TYPE_OVERFLOW_TRAPS (t
)),
2161 t
= TREE_TYPE (gimple_cond_lhs (s
));
2162 return operation_could_trap_p (gimple_cond_code (s
),
2163 FLOAT_TYPE_P (t
), false, NULL_TREE
);
2172 /* Return true if statement S can trap. */
2175 gimple_could_trap_p (gimple
*s
)
2177 return gimple_could_trap_p_1 (s
, true, true);
2180 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
2183 gimple_assign_rhs_could_trap_p (gimple
*s
)
2185 gcc_assert (is_gimple_assign (s
));
2186 return gimple_could_trap_p_1 (s
, true, false);
2190 /* Print debugging information for gimple stmts generated. */
2193 dump_gimple_statistics (void)
2196 uint64_t total_tuples
= 0, total_bytes
= 0;
2198 if (! GATHER_STATISTICS
)
2200 fprintf (stderr
, "No GIMPLE statistics\n");
2204 fprintf (stderr
, "\nGIMPLE statements\n");
2205 fprintf (stderr
, "Kind Stmts Bytes\n");
2206 fprintf (stderr
, "---------------------------------------\n");
2207 for (i
= 0; i
< (int) gimple_alloc_kind_all
; ++i
)
2209 fprintf (stderr
, "%-20s %7" PRIu64
"%c %10" PRIu64
"%c\n",
2210 gimple_alloc_kind_names
[i
],
2211 SIZE_AMOUNT (gimple_alloc_counts
[i
]),
2212 SIZE_AMOUNT (gimple_alloc_sizes
[i
]));
2213 total_tuples
+= gimple_alloc_counts
[i
];
2214 total_bytes
+= gimple_alloc_sizes
[i
];
2216 fprintf (stderr
, "---------------------------------------\n");
2217 fprintf (stderr
, "%-20s %7" PRIu64
"%c %10" PRIu64
"%c\n", "Total",
2218 SIZE_AMOUNT (total_tuples
), SIZE_AMOUNT (total_bytes
));
2219 fprintf (stderr
, "---------------------------------------\n");
2223 /* Return the number of operands needed on the RHS of a GIMPLE
2224 assignment for an expression with tree code CODE. */
2227 get_gimple_rhs_num_ops (enum tree_code code
)
2229 switch (get_gimple_rhs_class (code
))
2231 case GIMPLE_UNARY_RHS
:
2232 case GIMPLE_SINGLE_RHS
:
2234 case GIMPLE_BINARY_RHS
:
2236 case GIMPLE_TERNARY_RHS
:
2243 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2245 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2246 : ((TYPE) == tcc_binary \
2247 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2248 : ((TYPE) == tcc_constant \
2249 || (TYPE) == tcc_declaration \
2250 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2251 : ((SYM) == TRUTH_AND_EXPR \
2252 || (SYM) == TRUTH_OR_EXPR \
2253 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2254 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2255 : ((SYM) == COND_EXPR \
2256 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2257 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2258 || (SYM) == DOT_PROD_EXPR \
2259 || (SYM) == SAD_EXPR \
2260 || (SYM) == REALIGN_LOAD_EXPR \
2261 || (SYM) == VEC_COND_EXPR \
2262 || (SYM) == VEC_PERM_EXPR \
2263 || (SYM) == BIT_INSERT_EXPR) ? GIMPLE_TERNARY_RHS \
2264 : ((SYM) == CONSTRUCTOR \
2265 || (SYM) == OBJ_TYPE_REF \
2266 || (SYM) == ASSERT_EXPR \
2267 || (SYM) == ADDR_EXPR \
2268 || (SYM) == WITH_SIZE_EXPR \
2269 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2270 : GIMPLE_INVALID_RHS),
2271 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2273 const unsigned char gimple_rhs_class_table
[] = {
2274 #include "all-tree.def"
2278 #undef END_OF_BASE_TREE_CODES
2280 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2281 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2282 we failed to create one. */
2285 canonicalize_cond_expr_cond (tree t
)
2287 /* Strip conversions around boolean operations. */
2288 if (CONVERT_EXPR_P (t
)
2289 && (truth_value_p (TREE_CODE (TREE_OPERAND (t
, 0)))
2290 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
2292 t
= TREE_OPERAND (t
, 0);
2294 /* For !x use x == 0. */
2295 if (TREE_CODE (t
) == TRUTH_NOT_EXPR
)
2297 tree top0
= TREE_OPERAND (t
, 0);
2298 t
= build2 (EQ_EXPR
, TREE_TYPE (t
),
2299 top0
, build_int_cst (TREE_TYPE (top0
), 0));
2301 /* For cmp ? 1 : 0 use cmp. */
2302 else if (TREE_CODE (t
) == COND_EXPR
2303 && COMPARISON_CLASS_P (TREE_OPERAND (t
, 0))
2304 && integer_onep (TREE_OPERAND (t
, 1))
2305 && integer_zerop (TREE_OPERAND (t
, 2)))
2307 tree top0
= TREE_OPERAND (t
, 0);
2308 t
= build2 (TREE_CODE (top0
), TREE_TYPE (t
),
2309 TREE_OPERAND (top0
, 0), TREE_OPERAND (top0
, 1));
2311 /* For x ^ y use x != y. */
2312 else if (TREE_CODE (t
) == BIT_XOR_EXPR
)
2313 t
= build2 (NE_EXPR
, TREE_TYPE (t
),
2314 TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1));
2316 if (is_gimple_condexpr (t
))
2322 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2323 the positions marked by the set ARGS_TO_SKIP. */
2326 gimple_call_copy_skip_args (gcall
*stmt
, bitmap args_to_skip
)
2329 int nargs
= gimple_call_num_args (stmt
);
2330 auto_vec
<tree
> vargs (nargs
);
2333 for (i
= 0; i
< nargs
; i
++)
2334 if (!bitmap_bit_p (args_to_skip
, i
))
2335 vargs
.quick_push (gimple_call_arg (stmt
, i
));
2337 if (gimple_call_internal_p (stmt
))
2338 new_stmt
= gimple_build_call_internal_vec (gimple_call_internal_fn (stmt
),
2341 new_stmt
= gimple_build_call_vec (gimple_call_fn (stmt
), vargs
);
2343 if (gimple_call_lhs (stmt
))
2344 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2346 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2347 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
2349 if (gimple_has_location (stmt
))
2350 gimple_set_location (new_stmt
, gimple_location (stmt
));
2351 gimple_call_copy_flags (new_stmt
, stmt
);
2352 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2354 gimple_set_modified (new_stmt
, true);
2361 /* Return true if the field decls F1 and F2 are at the same offset.
2363 This is intended to be used on GIMPLE types only. */
2366 gimple_compare_field_offset (tree f1
, tree f2
)
2368 if (DECL_OFFSET_ALIGN (f1
) == DECL_OFFSET_ALIGN (f2
))
2370 tree offset1
= DECL_FIELD_OFFSET (f1
);
2371 tree offset2
= DECL_FIELD_OFFSET (f2
);
2372 return ((offset1
== offset2
2373 /* Once gimplification is done, self-referential offsets are
2374 instantiated as operand #2 of the COMPONENT_REF built for
2375 each access and reset. Therefore, they are not relevant
2376 anymore and fields are interchangeable provided that they
2377 represent the same access. */
2378 || (TREE_CODE (offset1
) == PLACEHOLDER_EXPR
2379 && TREE_CODE (offset2
) == PLACEHOLDER_EXPR
2380 && (DECL_SIZE (f1
) == DECL_SIZE (f2
)
2381 || (TREE_CODE (DECL_SIZE (f1
)) == PLACEHOLDER_EXPR
2382 && TREE_CODE (DECL_SIZE (f2
)) == PLACEHOLDER_EXPR
)
2383 || operand_equal_p (DECL_SIZE (f1
), DECL_SIZE (f2
), 0))
2384 && DECL_ALIGN (f1
) == DECL_ALIGN (f2
))
2385 || operand_equal_p (offset1
, offset2
, 0))
2386 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1
),
2387 DECL_FIELD_BIT_OFFSET (f2
)));
2390 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2391 should be, so handle differing ones specially by decomposing
2392 the offset into a byte and bit offset manually. */
2393 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1
))
2394 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2
)))
2396 unsigned HOST_WIDE_INT byte_offset1
, byte_offset2
;
2397 unsigned HOST_WIDE_INT bit_offset1
, bit_offset2
;
2398 bit_offset1
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1
));
2399 byte_offset1
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1
))
2400 + bit_offset1
/ BITS_PER_UNIT
);
2401 bit_offset2
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2
));
2402 byte_offset2
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2
))
2403 + bit_offset2
/ BITS_PER_UNIT
);
2404 if (byte_offset1
!= byte_offset2
)
2406 return bit_offset1
% BITS_PER_UNIT
== bit_offset2
% BITS_PER_UNIT
;
2413 /* Return a type the same as TYPE except unsigned or
2414 signed according to UNSIGNEDP. */
2417 gimple_signed_or_unsigned_type (bool unsignedp
, tree type
)
2422 type1
= TYPE_MAIN_VARIANT (type
);
2423 if (type1
== signed_char_type_node
2424 || type1
== char_type_node
2425 || type1
== unsigned_char_type_node
)
2426 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2427 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2428 return unsignedp
? unsigned_type_node
: integer_type_node
;
2429 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2430 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2431 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2432 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2433 if (type1
== long_long_integer_type_node
2434 || type1
== long_long_unsigned_type_node
)
2436 ? long_long_unsigned_type_node
2437 : long_long_integer_type_node
;
2439 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2440 if (int_n_enabled_p
[i
]
2441 && (type1
== int_n_trees
[i
].unsigned_type
2442 || type1
== int_n_trees
[i
].signed_type
))
2444 ? int_n_trees
[i
].unsigned_type
2445 : int_n_trees
[i
].signed_type
;
2447 #if HOST_BITS_PER_WIDE_INT >= 64
2448 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2449 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2451 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2452 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2453 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2454 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2455 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2456 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2457 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2458 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2460 #define GIMPLE_FIXED_TYPES(NAME) \
2461 if (type1 == short_ ## NAME ## _type_node \
2462 || type1 == unsigned_short_ ## NAME ## _type_node) \
2463 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2464 : short_ ## NAME ## _type_node; \
2465 if (type1 == NAME ## _type_node \
2466 || type1 == unsigned_ ## NAME ## _type_node) \
2467 return unsignedp ? unsigned_ ## NAME ## _type_node \
2468 : NAME ## _type_node; \
2469 if (type1 == long_ ## NAME ## _type_node \
2470 || type1 == unsigned_long_ ## NAME ## _type_node) \
2471 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2472 : long_ ## NAME ## _type_node; \
2473 if (type1 == long_long_ ## NAME ## _type_node \
2474 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2475 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2476 : long_long_ ## NAME ## _type_node;
2478 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2479 if (type1 == NAME ## _type_node \
2480 || type1 == u ## NAME ## _type_node) \
2481 return unsignedp ? u ## NAME ## _type_node \
2482 : NAME ## _type_node;
2484 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2485 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2486 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2487 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2488 : sat_ ## short_ ## NAME ## _type_node; \
2489 if (type1 == sat_ ## NAME ## _type_node \
2490 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2491 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2492 : sat_ ## NAME ## _type_node; \
2493 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2494 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2495 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2496 : sat_ ## long_ ## NAME ## _type_node; \
2497 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2498 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2499 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2500 : sat_ ## long_long_ ## NAME ## _type_node;
2502 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2503 if (type1 == sat_ ## NAME ## _type_node \
2504 || type1 == sat_ ## u ## NAME ## _type_node) \
2505 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2506 : sat_ ## NAME ## _type_node;
2508 GIMPLE_FIXED_TYPES (fract
);
2509 GIMPLE_FIXED_TYPES_SAT (fract
);
2510 GIMPLE_FIXED_TYPES (accum
);
2511 GIMPLE_FIXED_TYPES_SAT (accum
);
2513 GIMPLE_FIXED_MODE_TYPES (qq
);
2514 GIMPLE_FIXED_MODE_TYPES (hq
);
2515 GIMPLE_FIXED_MODE_TYPES (sq
);
2516 GIMPLE_FIXED_MODE_TYPES (dq
);
2517 GIMPLE_FIXED_MODE_TYPES (tq
);
2518 GIMPLE_FIXED_MODE_TYPES_SAT (qq
);
2519 GIMPLE_FIXED_MODE_TYPES_SAT (hq
);
2520 GIMPLE_FIXED_MODE_TYPES_SAT (sq
);
2521 GIMPLE_FIXED_MODE_TYPES_SAT (dq
);
2522 GIMPLE_FIXED_MODE_TYPES_SAT (tq
);
2523 GIMPLE_FIXED_MODE_TYPES (ha
);
2524 GIMPLE_FIXED_MODE_TYPES (sa
);
2525 GIMPLE_FIXED_MODE_TYPES (da
);
2526 GIMPLE_FIXED_MODE_TYPES (ta
);
2527 GIMPLE_FIXED_MODE_TYPES_SAT (ha
);
2528 GIMPLE_FIXED_MODE_TYPES_SAT (sa
);
2529 GIMPLE_FIXED_MODE_TYPES_SAT (da
);
2530 GIMPLE_FIXED_MODE_TYPES_SAT (ta
);
2532 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2533 the precision; they have precision set to match their range, but
2534 may use a wider mode to match an ABI. If we change modes, we may
2535 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2536 the precision as well, so as to yield correct results for
2537 bit-field types. C++ does not have these separate bit-field
2538 types, and producing a signed or unsigned variant of an
2539 ENUMERAL_TYPE may cause other problems as well. */
2540 if (!INTEGRAL_TYPE_P (type
)
2541 || TYPE_UNSIGNED (type
) == unsignedp
)
2544 #define TYPE_OK(node) \
2545 (TYPE_MODE (type) == TYPE_MODE (node) \
2546 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2547 if (TYPE_OK (signed_char_type_node
))
2548 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2549 if (TYPE_OK (integer_type_node
))
2550 return unsignedp
? unsigned_type_node
: integer_type_node
;
2551 if (TYPE_OK (short_integer_type_node
))
2552 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2553 if (TYPE_OK (long_integer_type_node
))
2554 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2555 if (TYPE_OK (long_long_integer_type_node
))
2557 ? long_long_unsigned_type_node
2558 : long_long_integer_type_node
);
2560 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2561 if (int_n_enabled_p
[i
]
2562 && TYPE_MODE (type
) == int_n_data
[i
].m
2563 && TYPE_PRECISION (type
) == int_n_data
[i
].bitsize
)
2565 ? int_n_trees
[i
].unsigned_type
2566 : int_n_trees
[i
].signed_type
;
2568 #if HOST_BITS_PER_WIDE_INT >= 64
2569 if (TYPE_OK (intTI_type_node
))
2570 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2572 if (TYPE_OK (intDI_type_node
))
2573 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2574 if (TYPE_OK (intSI_type_node
))
2575 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2576 if (TYPE_OK (intHI_type_node
))
2577 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2578 if (TYPE_OK (intQI_type_node
))
2579 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2581 #undef GIMPLE_FIXED_TYPES
2582 #undef GIMPLE_FIXED_MODE_TYPES
2583 #undef GIMPLE_FIXED_TYPES_SAT
2584 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2587 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2591 /* Return an unsigned type the same as TYPE in other respects. */
2594 gimple_unsigned_type (tree type
)
2596 return gimple_signed_or_unsigned_type (true, type
);
2600 /* Return a signed type the same as TYPE in other respects. */
2603 gimple_signed_type (tree type
)
2605 return gimple_signed_or_unsigned_type (false, type
);
2609 /* Return the typed-based alias set for T, which may be an expression
2610 or a type. Return -1 if we don't do anything special. */
2613 gimple_get_alias_set (tree t
)
2615 /* That's all the expressions we handle specially. */
2619 /* For convenience, follow the C standard when dealing with
2620 character types. Any object may be accessed via an lvalue that
2621 has character type. */
2622 if (t
== char_type_node
2623 || t
== signed_char_type_node
2624 || t
== unsigned_char_type_node
)
2627 /* Allow aliasing between signed and unsigned variants of the same
2628 type. We treat the signed variant as canonical. */
2629 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2631 tree t1
= gimple_signed_type (t
);
2633 /* t1 == t can happen for boolean nodes which are always unsigned. */
2635 return get_alias_set (t1
);
2638 /* Allow aliasing between enumeral types and the underlying
2639 integer type. This is required for C since those are
2640 compatible types. */
2641 else if (TREE_CODE (t
) == ENUMERAL_TYPE
)
2643 tree t1
= lang_hooks
.types
.type_for_size (tree_to_uhwi (TYPE_SIZE (t
)),
2644 false /* short-cut above */);
2645 return get_alias_set (t1
);
2652 /* Helper for gimple_ior_addresses_taken_1. */
2655 gimple_ior_addresses_taken_1 (gimple
*, tree addr
, tree
, void *data
)
2657 bitmap addresses_taken
= (bitmap
)data
;
2658 addr
= get_base_address (addr
);
2662 bitmap_set_bit (addresses_taken
, DECL_UID (addr
));
2668 /* Set the bit for the uid of all decls that have their address taken
2669 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2670 were any in this stmt. */
2673 gimple_ior_addresses_taken (bitmap addresses_taken
, gimple
*stmt
)
2675 return walk_stmt_load_store_addr_ops (stmt
, addresses_taken
, NULL
, NULL
,
2676 gimple_ior_addresses_taken_1
);
2680 /* Return true when STMTs arguments and return value match those of FNDECL,
2681 a decl of a builtin function. */
2684 gimple_builtin_call_types_compatible_p (const gimple
*stmt
, tree fndecl
)
2686 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
);
2688 tree ret
= gimple_call_lhs (stmt
);
2690 && !useless_type_conversion_p (TREE_TYPE (ret
),
2691 TREE_TYPE (TREE_TYPE (fndecl
))))
2694 tree targs
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2695 unsigned nargs
= gimple_call_num_args (stmt
);
2696 for (unsigned i
= 0; i
< nargs
; ++i
)
2698 /* Variadic args follow. */
2701 tree arg
= gimple_call_arg (stmt
, i
);
2702 tree type
= TREE_VALUE (targs
);
2703 if (!useless_type_conversion_p (type
, TREE_TYPE (arg
))
2704 /* char/short integral arguments are promoted to int
2705 by several frontends if targetm.calls.promote_prototypes
2706 is true. Allow such promotion too. */
2707 && !(INTEGRAL_TYPE_P (type
)
2708 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)
2709 && targetm
.calls
.promote_prototypes (TREE_TYPE (fndecl
))
2710 && useless_type_conversion_p (integer_type_node
,
2713 targs
= TREE_CHAIN (targs
);
2715 if (targs
&& !VOID_TYPE_P (TREE_VALUE (targs
)))
2720 /* Return true when STMT is operator a replaceable delete call. */
2723 gimple_call_operator_delete_p (const gcall
*stmt
)
2727 if ((fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
)
2728 return DECL_IS_OPERATOR_DELETE_P (fndecl
);
2732 /* Return true when STMT is builtins call. */
2735 gimple_call_builtin_p (const gimple
*stmt
)
2738 if (is_gimple_call (stmt
)
2739 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2740 && DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
)
2741 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2745 /* Return true when STMT is builtins call to CLASS. */
2748 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_class klass
)
2751 if (is_gimple_call (stmt
)
2752 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2753 && DECL_BUILT_IN_CLASS (fndecl
) == klass
)
2754 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2758 /* Return true when STMT is builtins call to CODE of CLASS. */
2761 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_function code
)
2764 if (is_gimple_call (stmt
)
2765 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2766 && fndecl_built_in_p (fndecl
, code
))
2767 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2771 /* If CALL is a call to a combined_fn (i.e. an internal function or
2772 a normal built-in function), return its code, otherwise return
2776 gimple_call_combined_fn (const gimple
*stmt
)
2778 if (const gcall
*call
= dyn_cast
<const gcall
*> (stmt
))
2780 if (gimple_call_internal_p (call
))
2781 return as_combined_fn (gimple_call_internal_fn (call
));
2783 tree fndecl
= gimple_call_fndecl (stmt
);
2785 && fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
)
2786 && gimple_builtin_call_types_compatible_p (stmt
, fndecl
))
2787 return as_combined_fn (DECL_FUNCTION_CODE (fndecl
));
2792 /* Return true if STMT clobbers memory. STMT is required to be a
2796 gimple_asm_clobbers_memory_p (const gasm
*stmt
)
2800 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
2802 tree op
= gimple_asm_clobber_op (stmt
, i
);
2803 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op
)), "memory") == 0)
2807 /* Non-empty basic ASM implicitly clobbers memory. */
2808 if (gimple_asm_input_p (stmt
) && strlen (gimple_asm_string (stmt
)) != 0)
2814 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2817 dump_decl_set (FILE *file
, bitmap set
)
2824 fprintf (file
, "{ ");
2826 EXECUTE_IF_SET_IN_BITMAP (set
, 0, i
, bi
)
2828 fprintf (file
, "D.%u", i
);
2829 fprintf (file
, " ");
2832 fprintf (file
, "}");
2835 fprintf (file
, "NIL");
2838 /* Return true when CALL is a call stmt that definitely doesn't
2839 free any memory or makes it unavailable otherwise. */
2841 nonfreeing_call_p (gimple
*call
)
2843 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2844 && gimple_call_flags (call
) & ECF_LEAF
)
2845 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call
)))
2847 /* Just in case these become ECF_LEAF in the future. */
2849 case BUILT_IN_TM_FREE
:
2850 case BUILT_IN_REALLOC
:
2851 case BUILT_IN_STACK_RESTORE
:
2856 else if (gimple_call_internal_p (call
))
2857 switch (gimple_call_internal_fn (call
))
2859 case IFN_ABNORMAL_DISPATCHER
:
2862 return tree_to_uhwi (gimple_call_arg (call
, 0)) == ASAN_MARK_UNPOISON
;
2864 if (gimple_call_flags (call
) & ECF_LEAF
)
2869 tree fndecl
= gimple_call_fndecl (call
);
2872 struct cgraph_node
*n
= cgraph_node::get (fndecl
);
2875 enum availability availability
;
2876 n
= n
->function_symbol (&availability
);
2877 if (!n
|| availability
<= AVAIL_INTERPOSABLE
)
2879 return n
->nonfreeing_fn
;
2882 /* Return true when CALL is a call stmt that definitely need not
2883 be considered to be a memory barrier. */
2885 nonbarrier_call_p (gimple
*call
)
2887 if (gimple_call_flags (call
) & (ECF_PURE
| ECF_CONST
))
2889 /* Should extend this to have a nonbarrier_fn flag, just as above in
2890 the nonfreeing case. */
2894 /* Callback for walk_stmt_load_store_ops.
2896 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2899 This routine only makes a superficial check for a dereference. Thus
2900 it must only be used if it is safe to return a false negative. */
2902 check_loadstore (gimple
*, tree op
, tree
, void *data
)
2904 if (TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
2906 /* Some address spaces may legitimately dereference zero. */
2907 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (op
));
2908 if (targetm
.addr_space
.zero_address_valid (as
))
2911 return operand_equal_p (TREE_OPERAND (op
, 0), (tree
)data
, 0);
2917 /* Return true if OP can be inferred to be non-NULL after STMT executes,
2918 either by using a pointer dereference or attributes. */
2920 infer_nonnull_range (gimple
*stmt
, tree op
)
2922 return (infer_nonnull_range_by_dereference (stmt
, op
)
2923 || infer_nonnull_range_by_attribute (stmt
, op
));
2926 /* Return true if OP can be inferred to be non-NULL after STMT
2927 executes by using a pointer dereference. */
2929 infer_nonnull_range_by_dereference (gimple
*stmt
, tree op
)
2931 /* We can only assume that a pointer dereference will yield
2932 non-NULL if -fdelete-null-pointer-checks is enabled. */
2933 if (!flag_delete_null_pointer_checks
2934 || !POINTER_TYPE_P (TREE_TYPE (op
))
2935 || gimple_code (stmt
) == GIMPLE_ASM
2936 || gimple_clobber_p (stmt
))
2939 if (walk_stmt_load_store_ops (stmt
, (void *)op
,
2940 check_loadstore
, check_loadstore
))
2946 /* Return true if OP can be inferred to be a non-NULL after STMT
2947 executes by using attributes. */
2949 infer_nonnull_range_by_attribute (gimple
*stmt
, tree op
)
2951 /* We can only assume that a pointer dereference will yield
2952 non-NULL if -fdelete-null-pointer-checks is enabled. */
2953 if (!flag_delete_null_pointer_checks
2954 || !POINTER_TYPE_P (TREE_TYPE (op
))
2955 || gimple_code (stmt
) == GIMPLE_ASM
)
2958 if (is_gimple_call (stmt
) && !gimple_call_internal_p (stmt
))
2960 tree fntype
= gimple_call_fntype (stmt
);
2961 tree attrs
= TYPE_ATTRIBUTES (fntype
);
2962 for (; attrs
; attrs
= TREE_CHAIN (attrs
))
2964 attrs
= lookup_attribute ("nonnull", attrs
);
2966 /* If "nonnull" wasn't specified, we know nothing about
2968 if (attrs
== NULL_TREE
)
2971 /* If "nonnull" applies to all the arguments, then ARG
2972 is non-null if it's in the argument list. */
2973 if (TREE_VALUE (attrs
) == NULL_TREE
)
2975 for (unsigned int i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2977 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt
, i
)))
2978 && operand_equal_p (op
, gimple_call_arg (stmt
, i
), 0))
2984 /* Now see if op appears in the nonnull list. */
2985 for (tree t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
2987 unsigned int idx
= TREE_INT_CST_LOW (TREE_VALUE (t
)) - 1;
2988 if (idx
< gimple_call_num_args (stmt
))
2990 tree arg
= gimple_call_arg (stmt
, idx
);
2991 if (operand_equal_p (op
, arg
, 0))
2998 /* If this function is marked as returning non-null, then we can
2999 infer OP is non-null if it is used in the return statement. */
3000 if (greturn
*return_stmt
= dyn_cast
<greturn
*> (stmt
))
3001 if (gimple_return_retval (return_stmt
)
3002 && operand_equal_p (gimple_return_retval (return_stmt
), op
, 0)
3003 && lookup_attribute ("returns_nonnull",
3004 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
))))
3010 /* Compare two case labels. Because the front end should already have
3011 made sure that case ranges do not overlap, it is enough to only compare
3012 the CASE_LOW values of each case label. */
3015 compare_case_labels (const void *p1
, const void *p2
)
3017 const_tree
const case1
= *(const_tree
const*)p1
;
3018 const_tree
const case2
= *(const_tree
const*)p2
;
3020 /* The 'default' case label always goes first. */
3021 if (!CASE_LOW (case1
))
3023 else if (!CASE_LOW (case2
))
3026 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
3029 /* Sort the case labels in LABEL_VEC in place in ascending order. */
3032 sort_case_labels (vec
<tree
> label_vec
)
3034 label_vec
.qsort (compare_case_labels
);
3037 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
3039 LABELS is a vector that contains all case labels to look at.
3041 INDEX_TYPE is the type of the switch index expression. Case labels
3042 in LABELS are discarded if their values are not in the value range
3043 covered by INDEX_TYPE. The remaining case label values are folded
3046 If a default case exists in LABELS, it is removed from LABELS and
3047 returned in DEFAULT_CASEP. If no default case exists, but the
3048 case labels already cover the whole range of INDEX_TYPE, a default
3049 case is returned pointing to one of the existing case labels.
3050 Otherwise DEFAULT_CASEP is set to NULL_TREE.
3052 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
3053 apply and no action is taken regardless of whether a default case is
3057 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
3059 tree
*default_casep
)
3061 tree min_value
, max_value
;
3062 tree default_case
= NULL_TREE
;
3066 min_value
= TYPE_MIN_VALUE (index_type
);
3067 max_value
= TYPE_MAX_VALUE (index_type
);
3068 while (i
< labels
.length ())
3070 tree elt
= labels
[i
];
3071 tree low
= CASE_LOW (elt
);
3072 tree high
= CASE_HIGH (elt
);
3073 bool remove_element
= FALSE
;
3077 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
3078 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
3080 /* This is a non-default case label, i.e. it has a value.
3082 See if the case label is reachable within the range of
3083 the index type. Remove out-of-range case values. Turn
3084 case ranges into a canonical form (high > low strictly)
3085 and convert the case label values to the index type.
3087 NB: The type of gimple_switch_index() may be the promoted
3088 type, but the case labels retain the original type. */
3092 /* This is a case range. Discard empty ranges.
3093 If the bounds or the range are equal, turn this
3094 into a simple (one-value) case. */
3095 int cmp
= tree_int_cst_compare (high
, low
);
3097 remove_element
= TRUE
;
3104 /* If the simple case value is unreachable, ignore it. */
3105 if ((TREE_CODE (min_value
) == INTEGER_CST
3106 && tree_int_cst_compare (low
, min_value
) < 0)
3107 || (TREE_CODE (max_value
) == INTEGER_CST
3108 && tree_int_cst_compare (low
, max_value
) > 0))
3109 remove_element
= TRUE
;
3111 low
= fold_convert (index_type
, low
);
3115 /* If the entire case range is unreachable, ignore it. */
3116 if ((TREE_CODE (min_value
) == INTEGER_CST
3117 && tree_int_cst_compare (high
, min_value
) < 0)
3118 || (TREE_CODE (max_value
) == INTEGER_CST
3119 && tree_int_cst_compare (low
, max_value
) > 0))
3120 remove_element
= TRUE
;
3123 /* If the lower bound is less than the index type's
3124 minimum value, truncate the range bounds. */
3125 if (TREE_CODE (min_value
) == INTEGER_CST
3126 && tree_int_cst_compare (low
, min_value
) < 0)
3128 low
= fold_convert (index_type
, low
);
3130 /* If the upper bound is greater than the index type's
3131 maximum value, truncate the range bounds. */
3132 if (TREE_CODE (max_value
) == INTEGER_CST
3133 && tree_int_cst_compare (high
, max_value
) > 0)
3135 high
= fold_convert (index_type
, high
);
3137 /* We may have folded a case range to a one-value case. */
3138 if (tree_int_cst_equal (low
, high
))
3143 CASE_LOW (elt
) = low
;
3144 CASE_HIGH (elt
) = high
;
3148 gcc_assert (!default_case
);
3150 /* The default case must be passed separately to the
3151 gimple_build_switch routine. But if DEFAULT_CASEP
3152 is NULL, we do not remove the default case (it would
3153 be completely lost). */
3155 remove_element
= TRUE
;
3159 labels
.ordered_remove (i
);
3165 if (!labels
.is_empty ())
3166 sort_case_labels (labels
);
3168 if (default_casep
&& !default_case
)
3170 /* If the switch has no default label, add one, so that we jump
3171 around the switch body. If the labels already cover the whole
3172 range of the switch index_type, add the default label pointing
3173 to one of the existing labels. */
3175 && TYPE_MIN_VALUE (index_type
)
3176 && TYPE_MAX_VALUE (index_type
)
3177 && tree_int_cst_equal (CASE_LOW (labels
[0]),
3178 TYPE_MIN_VALUE (index_type
)))
3180 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
3182 high
= CASE_LOW (labels
[len
- 1]);
3183 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
3185 tree widest_label
= labels
[0];
3186 for (i
= 1; i
< len
; i
++)
3188 high
= CASE_LOW (labels
[i
]);
3189 low
= CASE_HIGH (labels
[i
- 1]);
3191 low
= CASE_LOW (labels
[i
- 1]);
3193 if (CASE_HIGH (labels
[i
]) != NULL_TREE
3194 && (CASE_HIGH (widest_label
) == NULL_TREE
3196 (wi::to_wide (CASE_HIGH (labels
[i
]))
3197 - wi::to_wide (CASE_LOW (labels
[i
])),
3198 wi::to_wide (CASE_HIGH (widest_label
))
3199 - wi::to_wide (CASE_LOW (widest_label
))))))
3200 widest_label
= labels
[i
];
3202 if (wi::to_wide (low
) + 1 != wi::to_wide (high
))
3207 /* Designate the label with the widest range to be the
3209 tree label
= CASE_LABEL (widest_label
);
3210 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
3218 *default_casep
= default_case
;
3221 /* Set the location of all statements in SEQ to LOC. */
3224 gimple_seq_set_location (gimple_seq seq
, location_t loc
)
3226 for (gimple_stmt_iterator i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
3227 gimple_set_location (gsi_stmt (i
), loc
);
3230 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
3233 gimple_seq_discard (gimple_seq seq
)
3235 gimple_stmt_iterator gsi
;
3237 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); )
3239 gimple
*stmt
= gsi_stmt (gsi
);
3240 gsi_remove (&gsi
, true);
3241 release_defs (stmt
);
3246 /* See if STMT now calls function that takes no parameters and if so, drop
3247 call arguments. This is used when devirtualization machinery redirects
3248 to __builtin_unreachable or __cxa_pure_virtual. */
3251 maybe_remove_unused_call_args (struct function
*fn
, gimple
*stmt
)
3253 tree decl
= gimple_call_fndecl (stmt
);
3254 if (TYPE_ARG_TYPES (TREE_TYPE (decl
))
3255 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
))) == void_type_node
3256 && gimple_call_num_args (stmt
))
3258 gimple_set_num_ops (stmt
, 3);
3259 update_stmt_fn (fn
, stmt
);
3263 /* Return false if STMT will likely expand to real function call. */
3266 gimple_inexpensive_call_p (gcall
*stmt
)
3268 if (gimple_call_internal_p (stmt
))
3270 tree decl
= gimple_call_fndecl (stmt
);
3271 if (decl
&& is_inexpensive_builtin (decl
))
3276 /* Return a non-artificial location for STMT. If STMT does not have
3277 location information, get the location from EXPR. */
3280 gimple_or_expr_nonartificial_location (gimple
*stmt
, tree expr
)
3282 location_t loc
= gimple_nonartificial_location (stmt
);
3283 if (loc
== UNKNOWN_LOCATION
&& EXPR_HAS_LOCATION (expr
))
3284 loc
= tree_nonartificial_location (expr
);
3285 return expansion_point_location_if_in_system_header (loc
);
3291 namespace selftest
{
3293 /* Selftests for core gimple structures. */
3295 /* Verify that STMT is pretty-printed as EXPECTED.
3296 Helper function for selftests. */
3299 verify_gimple_pp (const char *expected
, gimple
*stmt
)
3302 pp_gimple_stmt_1 (&pp
, stmt
, 0 /* spc */, TDF_NONE
/* flags */);
3303 ASSERT_STREQ (expected
, pp_formatted_text (&pp
));
3306 /* Build a GIMPLE_ASSIGN equivalent to
3308 and verify various properties of it. */
3311 test_assign_single ()
3313 tree type
= integer_type_node
;
3314 tree lhs
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3315 get_identifier ("tmp"),
3317 tree rhs
= build_int_cst (type
, 5);
3318 gassign
*stmt
= gimple_build_assign (lhs
, rhs
);
3319 verify_gimple_pp ("tmp = 5;", stmt
);
3321 ASSERT_TRUE (is_gimple_assign (stmt
));
3322 ASSERT_EQ (lhs
, gimple_assign_lhs (stmt
));
3323 ASSERT_EQ (lhs
, gimple_get_lhs (stmt
));
3324 ASSERT_EQ (rhs
, gimple_assign_rhs1 (stmt
));
3325 ASSERT_EQ (NULL
, gimple_assign_rhs2 (stmt
));
3326 ASSERT_EQ (NULL
, gimple_assign_rhs3 (stmt
));
3327 ASSERT_TRUE (gimple_assign_single_p (stmt
));
3328 ASSERT_EQ (INTEGER_CST
, gimple_assign_rhs_code (stmt
));
3331 /* Build a GIMPLE_ASSIGN equivalent to
3333 and verify various properties of it. */
3336 test_assign_binop ()
3338 tree type
= integer_type_node
;
3339 tree lhs
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3340 get_identifier ("tmp"),
3342 tree a
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3343 get_identifier ("a"),
3345 tree b
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3346 get_identifier ("b"),
3348 gassign
*stmt
= gimple_build_assign (lhs
, MULT_EXPR
, a
, b
);
3349 verify_gimple_pp ("tmp = a * b;", stmt
);
3351 ASSERT_TRUE (is_gimple_assign (stmt
));
3352 ASSERT_EQ (lhs
, gimple_assign_lhs (stmt
));
3353 ASSERT_EQ (lhs
, gimple_get_lhs (stmt
));
3354 ASSERT_EQ (a
, gimple_assign_rhs1 (stmt
));
3355 ASSERT_EQ (b
, gimple_assign_rhs2 (stmt
));
3356 ASSERT_EQ (NULL
, gimple_assign_rhs3 (stmt
));
3357 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3358 ASSERT_EQ (MULT_EXPR
, gimple_assign_rhs_code (stmt
));
3361 /* Build a GIMPLE_NOP and verify various properties of it. */
3366 gimple
*stmt
= gimple_build_nop ();
3367 verify_gimple_pp ("GIMPLE_NOP", stmt
);
3368 ASSERT_EQ (GIMPLE_NOP
, gimple_code (stmt
));
3369 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3370 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3373 /* Build a GIMPLE_RETURN equivalent to
3375 and verify various properties of it. */
3380 tree type
= integer_type_node
;
3381 tree val
= build_int_cst (type
, 7);
3382 greturn
*stmt
= gimple_build_return (val
);
3383 verify_gimple_pp ("return 7;", stmt
);
3385 ASSERT_EQ (GIMPLE_RETURN
, gimple_code (stmt
));
3386 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3387 ASSERT_EQ (val
, gimple_return_retval (stmt
));
3388 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3391 /* Build a GIMPLE_RETURN equivalent to
3393 and verify various properties of it. */
3396 test_return_without_value ()
3398 greturn
*stmt
= gimple_build_return (NULL
);
3399 verify_gimple_pp ("return;", stmt
);
3401 ASSERT_EQ (GIMPLE_RETURN
, gimple_code (stmt
));
3402 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3403 ASSERT_EQ (NULL
, gimple_return_retval (stmt
));
3404 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3407 /* Run all of the selftests within this file. */
3412 test_assign_single ();
3413 test_assign_binop ();
3415 test_return_stmt ();
3416 test_return_without_value ();
3419 } // namespace selftest
3422 #endif /* CHECKING_P */