1 /* Gimple IR support functions.
3 Copyright (C) 2007-2015 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"
28 #include "hard-reg-set.h"
32 #include "fold-const.h"
35 #include "stor-layout.h"
36 #include "internal-fn.h"
38 #include "gimple-iterator.h"
39 #include "gimple-walk.h"
41 #include "diagnostic.h"
42 #include "value-prof.h"
46 #include "langhooks.h"
50 /* All the tuples have their operand vector (if present) at the very bottom
51 of the structure. Therefore, the offset required to find the
52 operands vector the size of the structure minus the size of the 1
53 element tree array at the end (see gimple_ops). */
54 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
55 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
56 EXPORTED_CONST
size_t gimple_ops_offset_
[] = {
57 #include "gsstruct.def"
61 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
62 static const size_t gsstruct_code_size
[] = {
63 #include "gsstruct.def"
67 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
68 const char *const gimple_code_name
[] = {
73 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
74 EXPORTED_CONST
enum gimple_statement_structure_enum gss_for_code_
[] = {
81 int gimple_alloc_counts
[(int) gimple_alloc_kind_all
];
82 int gimple_alloc_sizes
[(int) gimple_alloc_kind_all
];
84 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
85 static const char * const gimple_alloc_kind_names
[] = {
92 /* Gimple tuple constructors.
93 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
94 be passed a NULL to start with an empty sequence. */
96 /* Set the code for statement G to CODE. */
99 gimple_set_code (gimple g
, enum gimple_code code
)
104 /* Return the number of bytes needed to hold a GIMPLE statement with
108 gimple_size (enum gimple_code code
)
110 return gsstruct_code_size
[gss_for_code (code
)];
113 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
117 gimple_alloc_stat (enum gimple_code code
, unsigned num_ops MEM_STAT_DECL
)
122 size
= gimple_size (code
);
124 size
+= sizeof (tree
) * (num_ops
- 1);
126 if (GATHER_STATISTICS
)
128 enum gimple_alloc_kind kind
= gimple_alloc_kind (code
);
129 gimple_alloc_counts
[(int) kind
]++;
130 gimple_alloc_sizes
[(int) kind
] += size
;
133 stmt
= ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT
);
134 gimple_set_code (stmt
, code
);
135 gimple_set_num_ops (stmt
, num_ops
);
137 /* Do not call gimple_set_modified here as it has other side
138 effects and this tuple is still not completely built. */
140 gimple_init_singleton (stmt
);
145 /* Set SUBCODE to be the code of the expression computed by statement G. */
148 gimple_set_subcode (gimple g
, unsigned subcode
)
150 /* We only have 16 bits for the RHS code. Assert that we are not
152 gcc_assert (subcode
< (1 << 16));
153 g
->subcode
= subcode
;
158 /* Build a tuple with operands. CODE is the statement to build (which
159 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
160 for the new tuple. NUM_OPS is the number of operands to allocate. */
162 #define gimple_build_with_ops(c, s, n) \
163 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
166 gimple_build_with_ops_stat (enum gimple_code code
, unsigned subcode
,
167 unsigned num_ops MEM_STAT_DECL
)
169 gimple s
= gimple_alloc_stat (code
, num_ops PASS_MEM_STAT
);
170 gimple_set_subcode (s
, subcode
);
176 /* Build a GIMPLE_RETURN statement returning RETVAL. */
179 gimple_build_return (tree retval
)
182 = as_a
<greturn
*> (gimple_build_with_ops (GIMPLE_RETURN
, ERROR_MARK
,
185 gimple_return_set_retval (s
, retval
);
189 /* Reset alias information on call S. */
192 gimple_call_reset_alias_info (gcall
*s
)
194 if (gimple_call_flags (s
) & ECF_CONST
)
195 memset (gimple_call_use_set (s
), 0, sizeof (struct pt_solution
));
197 pt_solution_reset (gimple_call_use_set (s
));
198 if (gimple_call_flags (s
) & (ECF_CONST
|ECF_PURE
|ECF_NOVOPS
))
199 memset (gimple_call_clobber_set (s
), 0, sizeof (struct pt_solution
));
201 pt_solution_reset (gimple_call_clobber_set (s
));
204 /* Helper for gimple_build_call, gimple_build_call_valist,
205 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
206 components of a GIMPLE_CALL statement to function FN with NARGS
209 static inline gcall
*
210 gimple_build_call_1 (tree fn
, unsigned nargs
)
213 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
215 if (TREE_CODE (fn
) == FUNCTION_DECL
)
216 fn
= build_fold_addr_expr (fn
);
217 gimple_set_op (s
, 1, fn
);
218 gimple_call_set_fntype (s
, TREE_TYPE (TREE_TYPE (fn
)));
219 gimple_call_reset_alias_info (s
);
224 /* Build a GIMPLE_CALL statement to function FN with the arguments
225 specified in vector ARGS. */
228 gimple_build_call_vec (tree fn
, vec
<tree
> args
)
231 unsigned nargs
= args
.length ();
232 gcall
*call
= gimple_build_call_1 (fn
, nargs
);
234 for (i
= 0; i
< nargs
; i
++)
235 gimple_call_set_arg (call
, i
, args
[i
]);
241 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
242 arguments. The ... are the arguments. */
245 gimple_build_call (tree fn
, unsigned nargs
, ...)
251 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
253 call
= gimple_build_call_1 (fn
, nargs
);
255 va_start (ap
, nargs
);
256 for (i
= 0; i
< nargs
; i
++)
257 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
264 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
265 arguments. AP contains the arguments. */
268 gimple_build_call_valist (tree fn
, unsigned nargs
, va_list ap
)
273 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
275 call
= gimple_build_call_1 (fn
, nargs
);
277 for (i
= 0; i
< nargs
; i
++)
278 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
284 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
285 Build the basic components of a GIMPLE_CALL statement to internal
286 function FN with NARGS arguments. */
288 static inline gcall
*
289 gimple_build_call_internal_1 (enum internal_fn fn
, unsigned nargs
)
292 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
294 s
->subcode
|= GF_CALL_INTERNAL
;
295 gimple_call_set_internal_fn (s
, fn
);
296 gimple_call_reset_alias_info (s
);
301 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
302 the number of arguments. The ... are the arguments. */
305 gimple_build_call_internal (enum internal_fn fn
, unsigned nargs
, ...)
311 call
= gimple_build_call_internal_1 (fn
, nargs
);
312 va_start (ap
, nargs
);
313 for (i
= 0; i
< nargs
; i
++)
314 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
321 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
322 specified in vector ARGS. */
325 gimple_build_call_internal_vec (enum internal_fn fn
, vec
<tree
> args
)
330 nargs
= args
.length ();
331 call
= gimple_build_call_internal_1 (fn
, nargs
);
332 for (i
= 0; i
< nargs
; i
++)
333 gimple_call_set_arg (call
, i
, args
[i
]);
339 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
340 assumed to be in GIMPLE form already. Minimal checking is done of
344 gimple_build_call_from_tree (tree t
)
348 tree fndecl
= get_callee_fndecl (t
);
350 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
352 nargs
= call_expr_nargs (t
);
353 call
= gimple_build_call_1 (fndecl
? fndecl
: CALL_EXPR_FN (t
), nargs
);
355 for (i
= 0; i
< nargs
; i
++)
356 gimple_call_set_arg (call
, i
, CALL_EXPR_ARG (t
, i
));
358 gimple_set_block (call
, TREE_BLOCK (t
));
360 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
361 gimple_call_set_chain (call
, CALL_EXPR_STATIC_CHAIN (t
));
362 gimple_call_set_tail (call
, CALL_EXPR_TAILCALL (t
));
363 gimple_call_set_return_slot_opt (call
, CALL_EXPR_RETURN_SLOT_OPT (t
));
365 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
366 && (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA
367 || DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
368 gimple_call_set_alloca_for_var (call
, CALL_ALLOCA_FOR_VAR_P (t
));
370 gimple_call_set_from_thunk (call
, CALL_FROM_THUNK_P (t
));
371 gimple_call_set_va_arg_pack (call
, CALL_EXPR_VA_ARG_PACK (t
));
372 gimple_call_set_nothrow (call
, TREE_NOTHROW (t
));
373 gimple_set_no_warning (call
, TREE_NO_WARNING (t
));
374 gimple_call_set_with_bounds (call
, CALL_WITH_BOUNDS_P (t
));
380 /* Build a GIMPLE_ASSIGN statement.
382 LHS of the assignment.
383 RHS of the assignment which can be unary or binary. */
386 gimple_build_assign (tree lhs
, tree rhs MEM_STAT_DECL
)
388 enum tree_code subcode
;
391 extract_ops_from_tree_1 (rhs
, &subcode
, &op1
, &op2
, &op3
);
392 return gimple_build_assign (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
396 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
399 static inline gassign
*
400 gimple_build_assign_1 (tree lhs
, enum tree_code subcode
, tree op1
,
401 tree op2
, tree op3 MEM_STAT_DECL
)
406 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
408 num_ops
= get_gimple_rhs_num_ops (subcode
) + 1;
410 p
= as_a
<gassign
*> (
411 gimple_build_with_ops_stat (GIMPLE_ASSIGN
, (unsigned)subcode
, num_ops
413 gimple_assign_set_lhs (p
, lhs
);
414 gimple_assign_set_rhs1 (p
, op1
);
417 gcc_assert (num_ops
> 2);
418 gimple_assign_set_rhs2 (p
, op2
);
423 gcc_assert (num_ops
> 3);
424 gimple_assign_set_rhs3 (p
, op3
);
430 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
434 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
435 tree op2
, tree op3 MEM_STAT_DECL
)
437 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
440 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
444 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
445 tree op2 MEM_STAT_DECL
)
447 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, NULL_TREE
451 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
454 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1 MEM_STAT_DECL
)
456 return gimple_build_assign_1 (lhs
, subcode
, op1
, NULL_TREE
, NULL_TREE
461 /* Build a GIMPLE_COND statement.
463 PRED is the condition used to compare LHS and the RHS.
464 T_LABEL is the label to jump to if the condition is true.
465 F_LABEL is the label to jump to otherwise. */
468 gimple_build_cond (enum tree_code pred_code
, tree lhs
, tree rhs
,
469 tree t_label
, tree f_label
)
473 gcc_assert (TREE_CODE_CLASS (pred_code
) == tcc_comparison
);
474 p
= as_a
<gcond
*> (gimple_build_with_ops (GIMPLE_COND
, pred_code
, 4));
475 gimple_cond_set_lhs (p
, lhs
);
476 gimple_cond_set_rhs (p
, rhs
);
477 gimple_cond_set_true_label (p
, t_label
);
478 gimple_cond_set_false_label (p
, f_label
);
482 /* Build a GIMPLE_COND statement from the conditional expression tree
483 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
486 gimple_build_cond_from_tree (tree cond
, tree t_label
, tree f_label
)
491 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
492 return gimple_build_cond (code
, lhs
, rhs
, t_label
, f_label
);
495 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
496 boolean expression tree COND. */
499 gimple_cond_set_condition_from_tree (gcond
*stmt
, tree cond
)
504 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
505 gimple_cond_set_condition (stmt
, code
, lhs
, rhs
);
508 /* Build a GIMPLE_LABEL statement for LABEL. */
511 gimple_build_label (tree label
)
514 = as_a
<glabel
*> (gimple_build_with_ops (GIMPLE_LABEL
, ERROR_MARK
, 1));
515 gimple_label_set_label (p
, label
);
519 /* Build a GIMPLE_GOTO statement to label DEST. */
522 gimple_build_goto (tree dest
)
525 = as_a
<ggoto
*> (gimple_build_with_ops (GIMPLE_GOTO
, ERROR_MARK
, 1));
526 gimple_goto_set_dest (p
, dest
);
531 /* Build a GIMPLE_NOP statement. */
534 gimple_build_nop (void)
536 return gimple_alloc (GIMPLE_NOP
, 0);
540 /* Build a GIMPLE_BIND statement.
541 VARS are the variables in BODY.
542 BLOCK is the containing block. */
545 gimple_build_bind (tree vars
, gimple_seq body
, tree block
)
547 gbind
*p
= as_a
<gbind
*> (gimple_alloc (GIMPLE_BIND
, 0));
548 gimple_bind_set_vars (p
, vars
);
550 gimple_bind_set_body (p
, body
);
552 gimple_bind_set_block (p
, block
);
556 /* Helper function to set the simple fields of a asm stmt.
558 STRING is a pointer to a string that is the asm blocks assembly code.
559 NINPUT is the number of register inputs.
560 NOUTPUT is the number of register outputs.
561 NCLOBBERS is the number of clobbered registers.
565 gimple_build_asm_1 (const char *string
, unsigned ninputs
, unsigned noutputs
,
566 unsigned nclobbers
, unsigned nlabels
)
569 int size
= strlen (string
);
571 /* ASMs with labels cannot have outputs. This should have been
572 enforced by the front end. */
573 gcc_assert (nlabels
== 0 || noutputs
== 0);
576 gimple_build_with_ops (GIMPLE_ASM
, ERROR_MARK
,
577 ninputs
+ noutputs
+ nclobbers
+ nlabels
));
583 p
->string
= ggc_alloc_string (string
, size
);
585 if (GATHER_STATISTICS
)
586 gimple_alloc_sizes
[(int) gimple_alloc_kind (GIMPLE_ASM
)] += size
;
591 /* Build a GIMPLE_ASM statement.
593 STRING is the assembly code.
594 NINPUT is the number of register inputs.
595 NOUTPUT is the number of register outputs.
596 NCLOBBERS is the number of clobbered registers.
597 INPUTS is a vector of the input register parameters.
598 OUTPUTS is a vector of the output register parameters.
599 CLOBBERS is a vector of the clobbered register parameters.
600 LABELS is a vector of destination labels. */
603 gimple_build_asm_vec (const char *string
, vec
<tree
, va_gc
> *inputs
,
604 vec
<tree
, va_gc
> *outputs
, vec
<tree
, va_gc
> *clobbers
,
605 vec
<tree
, va_gc
> *labels
)
610 p
= gimple_build_asm_1 (string
,
611 vec_safe_length (inputs
),
612 vec_safe_length (outputs
),
613 vec_safe_length (clobbers
),
614 vec_safe_length (labels
));
616 for (i
= 0; i
< vec_safe_length (inputs
); i
++)
617 gimple_asm_set_input_op (p
, i
, (*inputs
)[i
]);
619 for (i
= 0; i
< vec_safe_length (outputs
); i
++)
620 gimple_asm_set_output_op (p
, i
, (*outputs
)[i
]);
622 for (i
= 0; i
< vec_safe_length (clobbers
); i
++)
623 gimple_asm_set_clobber_op (p
, i
, (*clobbers
)[i
]);
625 for (i
= 0; i
< vec_safe_length (labels
); i
++)
626 gimple_asm_set_label_op (p
, i
, (*labels
)[i
]);
631 /* Build a GIMPLE_CATCH statement.
633 TYPES are the catch types.
634 HANDLER is the exception handler. */
637 gimple_build_catch (tree types
, gimple_seq handler
)
639 gcatch
*p
= as_a
<gcatch
*> (gimple_alloc (GIMPLE_CATCH
, 0));
640 gimple_catch_set_types (p
, types
);
642 gimple_catch_set_handler (p
, handler
);
647 /* Build a GIMPLE_EH_FILTER statement.
649 TYPES are the filter's types.
650 FAILURE is the filter's failure action. */
653 gimple_build_eh_filter (tree types
, gimple_seq failure
)
655 geh_filter
*p
= as_a
<geh_filter
*> (gimple_alloc (GIMPLE_EH_FILTER
, 0));
656 gimple_eh_filter_set_types (p
, types
);
658 gimple_eh_filter_set_failure (p
, failure
);
663 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
666 gimple_build_eh_must_not_throw (tree decl
)
668 geh_mnt
*p
= as_a
<geh_mnt
*> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW
, 0));
670 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
671 gcc_assert (flags_from_decl_or_type (decl
) & ECF_NORETURN
);
672 gimple_eh_must_not_throw_set_fndecl (p
, decl
);
677 /* Build a GIMPLE_EH_ELSE statement. */
680 gimple_build_eh_else (gimple_seq n_body
, gimple_seq e_body
)
682 geh_else
*p
= as_a
<geh_else
*> (gimple_alloc (GIMPLE_EH_ELSE
, 0));
683 gimple_eh_else_set_n_body (p
, n_body
);
684 gimple_eh_else_set_e_body (p
, e_body
);
688 /* Build a GIMPLE_TRY statement.
690 EVAL is the expression to evaluate.
691 CLEANUP is the cleanup expression.
692 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
693 whether this is a try/catch or a try/finally respectively. */
696 gimple_build_try (gimple_seq eval
, gimple_seq cleanup
,
697 enum gimple_try_flags kind
)
701 gcc_assert (kind
== GIMPLE_TRY_CATCH
|| kind
== GIMPLE_TRY_FINALLY
);
702 p
= as_a
<gtry
*> (gimple_alloc (GIMPLE_TRY
, 0));
703 gimple_set_subcode (p
, kind
);
705 gimple_try_set_eval (p
, eval
);
707 gimple_try_set_cleanup (p
, cleanup
);
712 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
714 CLEANUP is the cleanup expression. */
717 gimple_build_wce (gimple_seq cleanup
)
719 gimple p
= gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR
, 0);
721 gimple_wce_set_cleanup (p
, cleanup
);
727 /* Build a GIMPLE_RESX statement. */
730 gimple_build_resx (int region
)
733 = as_a
<gresx
*> (gimple_build_with_ops (GIMPLE_RESX
, ERROR_MARK
, 0));
739 /* The helper for constructing a gimple switch statement.
740 INDEX is the switch's index.
741 NLABELS is the number of labels in the switch excluding the default.
742 DEFAULT_LABEL is the default label for the switch statement. */
745 gimple_build_switch_nlabels (unsigned nlabels
, tree index
, tree default_label
)
747 /* nlabels + 1 default label + 1 index. */
748 gcc_checking_assert (default_label
);
749 gswitch
*p
= as_a
<gswitch
*> (gimple_build_with_ops (GIMPLE_SWITCH
,
752 gimple_switch_set_index (p
, index
);
753 gimple_switch_set_default_label (p
, default_label
);
757 /* Build a GIMPLE_SWITCH statement.
759 INDEX is the switch's index.
760 DEFAULT_LABEL is the default label
761 ARGS is a vector of labels excluding the default. */
764 gimple_build_switch (tree index
, tree default_label
, vec
<tree
> args
)
766 unsigned i
, nlabels
= args
.length ();
768 gswitch
*p
= gimple_build_switch_nlabels (nlabels
, index
, default_label
);
770 /* Copy the labels from the vector to the switch statement. */
771 for (i
= 0; i
< nlabels
; i
++)
772 gimple_switch_set_label (p
, i
+ 1, args
[i
]);
777 /* Build a GIMPLE_EH_DISPATCH statement. */
780 gimple_build_eh_dispatch (int region
)
783 = as_a
<geh_dispatch
*> (
784 gimple_build_with_ops (GIMPLE_EH_DISPATCH
, ERROR_MARK
, 0));
789 /* Build a new GIMPLE_DEBUG_BIND statement.
791 VAR is bound to VALUE; block and location are taken from STMT. */
794 gimple_build_debug_bind_stat (tree var
, tree value
, gimple stmt MEM_STAT_DECL
)
797 = as_a
<gdebug
*> (gimple_build_with_ops_stat (GIMPLE_DEBUG
,
798 (unsigned)GIMPLE_DEBUG_BIND
, 2
800 gimple_debug_bind_set_var (p
, var
);
801 gimple_debug_bind_set_value (p
, value
);
803 gimple_set_location (p
, gimple_location (stmt
));
809 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
811 VAR is bound to VALUE; block and location are taken from STMT. */
814 gimple_build_debug_source_bind_stat (tree var
, tree value
,
815 gimple stmt MEM_STAT_DECL
)
819 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
820 (unsigned)GIMPLE_DEBUG_SOURCE_BIND
, 2
823 gimple_debug_source_bind_set_var (p
, var
);
824 gimple_debug_source_bind_set_value (p
, value
);
826 gimple_set_location (p
, gimple_location (stmt
));
832 /* Build a GIMPLE_OMP_CRITICAL statement.
834 BODY is the sequence of statements for which only one thread can execute.
835 NAME is optional identifier for this critical block. */
838 gimple_build_omp_critical (gimple_seq body
, tree name
)
841 = as_a
<gomp_critical
*> (gimple_alloc (GIMPLE_OMP_CRITICAL
, 0));
842 gimple_omp_critical_set_name (p
, name
);
844 gimple_omp_set_body (p
, body
);
849 /* Build a GIMPLE_OMP_FOR statement.
851 BODY is sequence of statements inside the for loop.
852 KIND is the `for' variant.
853 CLAUSES, are any of the construct's clauses.
854 COLLAPSE is the collapse count.
855 PRE_BODY is the sequence of statements that are loop invariant. */
858 gimple_build_omp_for (gimple_seq body
, int kind
, tree clauses
, size_t collapse
,
861 gomp_for
*p
= as_a
<gomp_for
*> (gimple_alloc (GIMPLE_OMP_FOR
, 0));
863 gimple_omp_set_body (p
, body
);
864 gimple_omp_for_set_clauses (p
, clauses
);
865 gimple_omp_for_set_kind (p
, kind
);
866 p
->collapse
= collapse
;
867 p
->iter
= ggc_cleared_vec_alloc
<gimple_omp_for_iter
> (collapse
);
868 p
->orig_first_iter
= ggc_cleared_alloc
<gimple_omp_for_iter
> ();
871 gimple_omp_for_set_pre_body (p
, pre_body
);
877 /* Build a GIMPLE_OMP_PARALLEL statement.
879 BODY is sequence of statements which are executed in parallel.
880 CLAUSES, are the OMP parallel construct's clauses.
881 CHILD_FN is the function created for the parallel threads to execute.
882 DATA_ARG are the shared data argument(s). */
885 gimple_build_omp_parallel (gimple_seq body
, tree clauses
, tree child_fn
,
889 = as_a
<gomp_parallel
*> (gimple_alloc (GIMPLE_OMP_PARALLEL
, 0));
891 gimple_omp_set_body (p
, body
);
892 gimple_omp_parallel_set_clauses (p
, clauses
);
893 gimple_omp_parallel_set_child_fn (p
, child_fn
);
894 gimple_omp_parallel_set_data_arg (p
, data_arg
);
900 /* Build a GIMPLE_OMP_TASK statement.
902 BODY is sequence of statements which are executed by the explicit task.
903 CLAUSES, are the OMP parallel construct's clauses.
904 CHILD_FN is the function created for the parallel threads to execute.
905 DATA_ARG are the shared data argument(s).
906 COPY_FN is the optional function for firstprivate initialization.
907 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
910 gimple_build_omp_task (gimple_seq body
, tree clauses
, tree child_fn
,
911 tree data_arg
, tree copy_fn
, tree arg_size
,
914 gomp_task
*p
= as_a
<gomp_task
*> (gimple_alloc (GIMPLE_OMP_TASK
, 0));
916 gimple_omp_set_body (p
, body
);
917 gimple_omp_task_set_clauses (p
, clauses
);
918 gimple_omp_task_set_child_fn (p
, child_fn
);
919 gimple_omp_task_set_data_arg (p
, data_arg
);
920 gimple_omp_task_set_copy_fn (p
, copy_fn
);
921 gimple_omp_task_set_arg_size (p
, arg_size
);
922 gimple_omp_task_set_arg_align (p
, arg_align
);
928 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
930 BODY is the sequence of statements in the section. */
933 gimple_build_omp_section (gimple_seq body
)
935 gimple p
= gimple_alloc (GIMPLE_OMP_SECTION
, 0);
937 gimple_omp_set_body (p
, body
);
943 /* Build a GIMPLE_OMP_MASTER statement.
945 BODY is the sequence of statements to be executed by just the master. */
948 gimple_build_omp_master (gimple_seq body
)
950 gimple p
= gimple_alloc (GIMPLE_OMP_MASTER
, 0);
952 gimple_omp_set_body (p
, body
);
958 /* Build a GIMPLE_OMP_TASKGROUP statement.
960 BODY is the sequence of statements to be executed by the taskgroup
964 gimple_build_omp_taskgroup (gimple_seq body
)
966 gimple p
= gimple_alloc (GIMPLE_OMP_TASKGROUP
, 0);
968 gimple_omp_set_body (p
, body
);
974 /* Build a GIMPLE_OMP_CONTINUE statement.
976 CONTROL_DEF is the definition of the control variable.
977 CONTROL_USE is the use of the control variable. */
980 gimple_build_omp_continue (tree control_def
, tree control_use
)
983 = as_a
<gomp_continue
*> (gimple_alloc (GIMPLE_OMP_CONTINUE
, 0));
984 gimple_omp_continue_set_control_def (p
, control_def
);
985 gimple_omp_continue_set_control_use (p
, control_use
);
989 /* Build a GIMPLE_OMP_ORDERED statement.
991 BODY is the sequence of statements inside a loop that will executed in
995 gimple_build_omp_ordered (gimple_seq body
)
997 gimple p
= gimple_alloc (GIMPLE_OMP_ORDERED
, 0);
999 gimple_omp_set_body (p
, body
);
1005 /* Build a GIMPLE_OMP_RETURN statement.
1006 WAIT_P is true if this is a non-waiting return. */
1009 gimple_build_omp_return (bool wait_p
)
1011 gimple p
= gimple_alloc (GIMPLE_OMP_RETURN
, 0);
1013 gimple_omp_return_set_nowait (p
);
1019 /* Build a GIMPLE_OMP_SECTIONS statement.
1021 BODY is a sequence of section statements.
1022 CLAUSES are any of the OMP sections contsruct's clauses: private,
1023 firstprivate, lastprivate, reduction, and nowait. */
1026 gimple_build_omp_sections (gimple_seq body
, tree clauses
)
1029 = as_a
<gomp_sections
*> (gimple_alloc (GIMPLE_OMP_SECTIONS
, 0));
1031 gimple_omp_set_body (p
, body
);
1032 gimple_omp_sections_set_clauses (p
, clauses
);
1038 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1041 gimple_build_omp_sections_switch (void)
1043 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH
, 0);
1047 /* Build a GIMPLE_OMP_SINGLE statement.
1049 BODY is the sequence of statements that will be executed once.
1050 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1051 copyprivate, nowait. */
1054 gimple_build_omp_single (gimple_seq body
, tree clauses
)
1057 = as_a
<gomp_single
*> (gimple_alloc (GIMPLE_OMP_SINGLE
, 0));
1059 gimple_omp_set_body (p
, body
);
1060 gimple_omp_single_set_clauses (p
, clauses
);
1066 /* Build a GIMPLE_OMP_TARGET statement.
1068 BODY is the sequence of statements that will be executed.
1069 KIND is the kind of the region.
1070 CLAUSES are any of the construct's clauses. */
1073 gimple_build_omp_target (gimple_seq body
, int kind
, tree clauses
)
1076 = as_a
<gomp_target
*> (gimple_alloc (GIMPLE_OMP_TARGET
, 0));
1078 gimple_omp_set_body (p
, body
);
1079 gimple_omp_target_set_clauses (p
, clauses
);
1080 gimple_omp_target_set_kind (p
, kind
);
1086 /* Build a GIMPLE_OMP_TEAMS statement.
1088 BODY is the sequence of statements that will be executed.
1089 CLAUSES are any of the OMP teams construct's clauses. */
1092 gimple_build_omp_teams (gimple_seq body
, tree clauses
)
1094 gomp_teams
*p
= as_a
<gomp_teams
*> (gimple_alloc (GIMPLE_OMP_TEAMS
, 0));
1096 gimple_omp_set_body (p
, body
);
1097 gimple_omp_teams_set_clauses (p
, clauses
);
1103 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1106 gimple_build_omp_atomic_load (tree lhs
, tree rhs
)
1109 = as_a
<gomp_atomic_load
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD
, 0));
1110 gimple_omp_atomic_load_set_lhs (p
, lhs
);
1111 gimple_omp_atomic_load_set_rhs (p
, rhs
);
1115 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1117 VAL is the value we are storing. */
1120 gimple_build_omp_atomic_store (tree val
)
1122 gomp_atomic_store
*p
1123 = as_a
<gomp_atomic_store
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE
, 0));
1124 gimple_omp_atomic_store_set_val (p
, val
);
1128 /* Build a GIMPLE_TRANSACTION statement. */
1131 gimple_build_transaction (gimple_seq body
, tree label
)
1134 = as_a
<gtransaction
*> (gimple_alloc (GIMPLE_TRANSACTION
, 0));
1135 gimple_transaction_set_body (p
, body
);
1136 gimple_transaction_set_label (p
, label
);
1140 #if defined ENABLE_GIMPLE_CHECKING
1141 /* Complain of a gimple type mismatch and die. */
1144 gimple_check_failed (const_gimple gs
, const char *file
, int line
,
1145 const char *function
, enum gimple_code code
,
1146 enum tree_code subcode
)
1148 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1149 gimple_code_name
[code
],
1150 get_tree_code_name (subcode
),
1151 gimple_code_name
[gimple_code (gs
)],
1153 ? get_tree_code_name ((enum tree_code
) gs
->subcode
)
1155 function
, trim_filename (file
), line
);
1157 #endif /* ENABLE_GIMPLE_CHECKING */
1160 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1161 *SEQ_P is NULL, a new sequence is allocated. */
1164 gimple_seq_add_stmt (gimple_seq
*seq_p
, gimple gs
)
1166 gimple_stmt_iterator si
;
1170 si
= gsi_last (*seq_p
);
1171 gsi_insert_after (&si
, gs
, GSI_NEW_STMT
);
1174 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1175 *SEQ_P is NULL, a new sequence is allocated. This function is
1176 similar to gimple_seq_add_stmt, but does not scan the operands.
1177 During gimplification, we need to manipulate statement sequences
1178 before the def/use vectors have been constructed. */
1181 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple gs
)
1183 gimple_stmt_iterator si
;
1188 si
= gsi_last (*seq_p
);
1189 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
1192 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1193 NULL, a new sequence is allocated. */
1196 gimple_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
1198 gimple_stmt_iterator si
;
1202 si
= gsi_last (*dst_p
);
1203 gsi_insert_seq_after (&si
, src
, GSI_NEW_STMT
);
1206 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1207 NULL, a new sequence is allocated. This function is
1208 similar to gimple_seq_add_seq, but does not scan the operands. */
1211 gimple_seq_add_seq_without_update (gimple_seq
*dst_p
, gimple_seq src
)
1213 gimple_stmt_iterator si
;
1217 si
= gsi_last (*dst_p
);
1218 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
1221 /* Determine whether to assign a location to the statement GS. */
1224 should_carry_location_p (gimple gs
)
1226 /* Don't emit a line note for a label. We particularly don't want to
1227 emit one for the break label, since it doesn't actually correspond
1228 to the beginning of the loop/switch. */
1229 if (gimple_code (gs
) == GIMPLE_LABEL
)
1235 /* Set the location for gimple statement GS to LOCATION. */
1238 annotate_one_with_location (gimple gs
, location_t location
)
1240 if (!gimple_has_location (gs
)
1241 && !gimple_do_not_emit_location_p (gs
)
1242 && should_carry_location_p (gs
))
1243 gimple_set_location (gs
, location
);
1246 /* Set LOCATION for all the statements after iterator GSI in sequence
1247 SEQ. If GSI is pointing to the end of the sequence, start with the
1248 first statement in SEQ. */
1251 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
1252 location_t location
)
1254 if (gsi_end_p (gsi
))
1255 gsi
= gsi_start (seq
);
1259 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
1260 annotate_one_with_location (gsi_stmt (gsi
), location
);
1263 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1266 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
1268 gimple_stmt_iterator i
;
1270 if (gimple_seq_empty_p (stmt_p
))
1273 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
1275 gimple gs
= gsi_stmt (i
);
1276 annotate_one_with_location (gs
, location
);
1280 /* Helper function of empty_body_p. Return true if STMT is an empty
1284 empty_stmt_p (gimple stmt
)
1286 if (gimple_code (stmt
) == GIMPLE_NOP
)
1288 if (gbind
*bind_stmt
= dyn_cast
<gbind
*> (stmt
))
1289 return empty_body_p (gimple_bind_body (bind_stmt
));
1294 /* Return true if BODY contains nothing but empty statements. */
1297 empty_body_p (gimple_seq body
)
1299 gimple_stmt_iterator i
;
1301 if (gimple_seq_empty_p (body
))
1303 for (i
= gsi_start (body
); !gsi_end_p (i
); gsi_next (&i
))
1304 if (!empty_stmt_p (gsi_stmt (i
))
1305 && !is_gimple_debug (gsi_stmt (i
)))
1312 /* Perform a deep copy of sequence SRC and return the result. */
1315 gimple_seq_copy (gimple_seq src
)
1317 gimple_stmt_iterator gsi
;
1318 gimple_seq new_seq
= NULL
;
1321 for (gsi
= gsi_start (src
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1323 stmt
= gimple_copy (gsi_stmt (gsi
));
1324 gimple_seq_add_stmt (&new_seq
, stmt
);
1332 /* Return true if calls C1 and C2 are known to go to the same function. */
1335 gimple_call_same_target_p (const_gimple c1
, const_gimple c2
)
1337 if (gimple_call_internal_p (c1
))
1338 return (gimple_call_internal_p (c2
)
1339 && gimple_call_internal_fn (c1
) == gimple_call_internal_fn (c2
));
1341 return (gimple_call_fn (c1
) == gimple_call_fn (c2
)
1342 || (gimple_call_fndecl (c1
)
1343 && gimple_call_fndecl (c1
) == gimple_call_fndecl (c2
)));
1346 /* Detect flags from a GIMPLE_CALL. This is just like
1347 call_expr_flags, but for gimple tuples. */
1350 gimple_call_flags (const_gimple stmt
)
1353 tree decl
= gimple_call_fndecl (stmt
);
1356 flags
= flags_from_decl_or_type (decl
);
1357 else if (gimple_call_internal_p (stmt
))
1358 flags
= internal_fn_flags (gimple_call_internal_fn (stmt
));
1360 flags
= flags_from_decl_or_type (gimple_call_fntype (stmt
));
1362 if (stmt
->subcode
& GF_CALL_NOTHROW
)
1363 flags
|= ECF_NOTHROW
;
1368 /* Return the "fn spec" string for call STMT. */
1371 gimple_call_fnspec (const gcall
*stmt
)
1375 if (gimple_call_internal_p (stmt
))
1376 return internal_fn_fnspec (gimple_call_internal_fn (stmt
));
1378 type
= gimple_call_fntype (stmt
);
1382 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
1386 return TREE_VALUE (TREE_VALUE (attr
));
1389 /* Detects argument flags for argument number ARG on call STMT. */
1392 gimple_call_arg_flags (const gcall
*stmt
, unsigned arg
)
1394 const_tree attr
= gimple_call_fnspec (stmt
);
1396 if (!attr
|| 1 + arg
>= (unsigned) TREE_STRING_LENGTH (attr
))
1399 switch (TREE_STRING_POINTER (attr
)[1 + arg
])
1406 return EAF_DIRECT
| EAF_NOCLOBBER
| EAF_NOESCAPE
;
1409 return EAF_NOCLOBBER
| EAF_NOESCAPE
;
1412 return EAF_DIRECT
| EAF_NOESCAPE
;
1415 return EAF_NOESCAPE
;
1423 /* Detects return flags for the call STMT. */
1426 gimple_call_return_flags (const gcall
*stmt
)
1430 if (gimple_call_flags (stmt
) & ECF_MALLOC
)
1433 attr
= gimple_call_fnspec (stmt
);
1434 if (!attr
|| TREE_STRING_LENGTH (attr
) < 1)
1437 switch (TREE_STRING_POINTER (attr
)[0])
1443 return ERF_RETURNS_ARG
| (TREE_STRING_POINTER (attr
)[0] - '1');
1455 /* Return true if GS is a copy assignment. */
1458 gimple_assign_copy_p (gimple gs
)
1460 return (gimple_assign_single_p (gs
)
1461 && is_gimple_val (gimple_op (gs
, 1)));
1465 /* Return true if GS is a SSA_NAME copy assignment. */
1468 gimple_assign_ssa_name_copy_p (gimple gs
)
1470 return (gimple_assign_single_p (gs
)
1471 && TREE_CODE (gimple_assign_lhs (gs
)) == SSA_NAME
1472 && TREE_CODE (gimple_assign_rhs1 (gs
)) == SSA_NAME
);
1476 /* Return true if GS is an assignment with a unary RHS, but the
1477 operator has no effect on the assigned value. The logic is adapted
1478 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1479 instances in which STRIP_NOPS was previously applied to the RHS of
1482 NOTE: In the use cases that led to the creation of this function
1483 and of gimple_assign_single_p, it is typical to test for either
1484 condition and to proceed in the same manner. In each case, the
1485 assigned value is represented by the single RHS operand of the
1486 assignment. I suspect there may be cases where gimple_assign_copy_p,
1487 gimple_assign_single_p, or equivalent logic is used where a similar
1488 treatment of unary NOPs is appropriate. */
1491 gimple_assign_unary_nop_p (gimple gs
)
1493 return (is_gimple_assign (gs
)
1494 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs
))
1495 || gimple_assign_rhs_code (gs
) == NON_LVALUE_EXPR
)
1496 && gimple_assign_rhs1 (gs
) != error_mark_node
1497 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs
)))
1498 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs
)))));
1501 /* Set BB to be the basic block holding G. */
1504 gimple_set_bb (gimple stmt
, basic_block bb
)
1508 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1511 /* If the statement is a label, add the label to block-to-labels map
1512 so that we can speed up edge creation for GIMPLE_GOTOs. */
1518 t
= gimple_label_label (as_a
<glabel
*> (stmt
));
1519 uid
= LABEL_DECL_UID (t
);
1523 vec_safe_length (label_to_block_map_for_fn (cfun
));
1524 LABEL_DECL_UID (t
) = uid
= cfun
->cfg
->last_label_uid
++;
1525 if (old_len
<= (unsigned) uid
)
1527 unsigned new_len
= 3 * uid
/ 2 + 1;
1529 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun
),
1534 (*label_to_block_map_for_fn (cfun
))[uid
] = bb
;
1539 /* Modify the RHS of the assignment pointed-to by GSI using the
1540 operands in the expression tree EXPR.
1542 NOTE: The statement pointed-to by GSI may be reallocated if it
1543 did not have enough operand slots.
1545 This function is useful to convert an existing tree expression into
1546 the flat representation used for the RHS of a GIMPLE assignment.
1547 It will reallocate memory as needed to expand or shrink the number
1548 of operand slots needed to represent EXPR.
1550 NOTE: If you find yourself building a tree and then calling this
1551 function, you are most certainly doing it the slow way. It is much
1552 better to build a new assignment or to use the function
1553 gimple_assign_set_rhs_with_ops, which does not require an
1554 expression tree to be built. */
1557 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*gsi
, tree expr
)
1559 enum tree_code subcode
;
1562 extract_ops_from_tree_1 (expr
, &subcode
, &op1
, &op2
, &op3
);
1563 gimple_assign_set_rhs_with_ops (gsi
, subcode
, op1
, op2
, op3
);
1567 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1568 operands OP1, OP2 and OP3.
1570 NOTE: The statement pointed-to by GSI may be reallocated if it
1571 did not have enough operand slots. */
1574 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*gsi
, enum tree_code code
,
1575 tree op1
, tree op2
, tree op3
)
1577 unsigned new_rhs_ops
= get_gimple_rhs_num_ops (code
);
1578 gimple stmt
= gsi_stmt (*gsi
);
1580 /* If the new CODE needs more operands, allocate a new statement. */
1581 if (gimple_num_ops (stmt
) < new_rhs_ops
+ 1)
1583 tree lhs
= gimple_assign_lhs (stmt
);
1584 gimple new_stmt
= gimple_alloc (gimple_code (stmt
), new_rhs_ops
+ 1);
1585 memcpy (new_stmt
, stmt
, gimple_size (gimple_code (stmt
)));
1586 gimple_init_singleton (new_stmt
);
1587 gsi_replace (gsi
, new_stmt
, true);
1590 /* The LHS needs to be reset as this also changes the SSA name
1592 gimple_assign_set_lhs (stmt
, lhs
);
1595 gimple_set_num_ops (stmt
, new_rhs_ops
+ 1);
1596 gimple_set_subcode (stmt
, code
);
1597 gimple_assign_set_rhs1 (stmt
, op1
);
1598 if (new_rhs_ops
> 1)
1599 gimple_assign_set_rhs2 (stmt
, op2
);
1600 if (new_rhs_ops
> 2)
1601 gimple_assign_set_rhs3 (stmt
, op3
);
1605 /* Return the LHS of a statement that performs an assignment,
1606 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1607 for a call to a function that returns no value, or for a
1608 statement other than an assignment or a call. */
1611 gimple_get_lhs (const_gimple stmt
)
1613 enum gimple_code code
= gimple_code (stmt
);
1615 if (code
== GIMPLE_ASSIGN
)
1616 return gimple_assign_lhs (stmt
);
1617 else if (code
== GIMPLE_CALL
)
1618 return gimple_call_lhs (stmt
);
1624 /* Set the LHS of a statement that performs an assignment,
1625 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1628 gimple_set_lhs (gimple stmt
, tree lhs
)
1630 enum gimple_code code
= gimple_code (stmt
);
1632 if (code
== GIMPLE_ASSIGN
)
1633 gimple_assign_set_lhs (stmt
, lhs
);
1634 else if (code
== GIMPLE_CALL
)
1635 gimple_call_set_lhs (stmt
, lhs
);
1641 /* Return a deep copy of statement STMT. All the operands from STMT
1642 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1643 and VUSE operand arrays are set to empty in the new copy. The new
1644 copy isn't part of any sequence. */
1647 gimple_copy (gimple stmt
)
1649 enum gimple_code code
= gimple_code (stmt
);
1650 unsigned num_ops
= gimple_num_ops (stmt
);
1651 gimple copy
= gimple_alloc (code
, num_ops
);
1654 /* Shallow copy all the fields from STMT. */
1655 memcpy (copy
, stmt
, gimple_size (code
));
1656 gimple_init_singleton (copy
);
1658 /* If STMT has sub-statements, deep-copy them as well. */
1659 if (gimple_has_substatements (stmt
))
1664 switch (gimple_code (stmt
))
1668 gbind
*bind_stmt
= as_a
<gbind
*> (stmt
);
1669 gbind
*bind_copy
= as_a
<gbind
*> (copy
);
1670 new_seq
= gimple_seq_copy (gimple_bind_body (bind_stmt
));
1671 gimple_bind_set_body (bind_copy
, new_seq
);
1672 gimple_bind_set_vars (bind_copy
,
1673 unshare_expr (gimple_bind_vars (bind_stmt
)));
1674 gimple_bind_set_block (bind_copy
, gimple_bind_block (bind_stmt
));
1680 gcatch
*catch_stmt
= as_a
<gcatch
*> (stmt
);
1681 gcatch
*catch_copy
= as_a
<gcatch
*> (copy
);
1682 new_seq
= gimple_seq_copy (gimple_catch_handler (catch_stmt
));
1683 gimple_catch_set_handler (catch_copy
, new_seq
);
1684 t
= unshare_expr (gimple_catch_types (catch_stmt
));
1685 gimple_catch_set_types (catch_copy
, t
);
1689 case GIMPLE_EH_FILTER
:
1691 geh_filter
*eh_filter_stmt
= as_a
<geh_filter
*> (stmt
);
1692 geh_filter
*eh_filter_copy
= as_a
<geh_filter
*> (copy
);
1694 = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt
));
1695 gimple_eh_filter_set_failure (eh_filter_copy
, new_seq
);
1696 t
= unshare_expr (gimple_eh_filter_types (eh_filter_stmt
));
1697 gimple_eh_filter_set_types (eh_filter_copy
, t
);
1701 case GIMPLE_EH_ELSE
:
1703 geh_else
*eh_else_stmt
= as_a
<geh_else
*> (stmt
);
1704 geh_else
*eh_else_copy
= as_a
<geh_else
*> (copy
);
1705 new_seq
= gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt
));
1706 gimple_eh_else_set_n_body (eh_else_copy
, new_seq
);
1707 new_seq
= gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt
));
1708 gimple_eh_else_set_e_body (eh_else_copy
, new_seq
);
1714 gtry
*try_stmt
= as_a
<gtry
*> (stmt
);
1715 gtry
*try_copy
= as_a
<gtry
*> (copy
);
1716 new_seq
= gimple_seq_copy (gimple_try_eval (try_stmt
));
1717 gimple_try_set_eval (try_copy
, new_seq
);
1718 new_seq
= gimple_seq_copy (gimple_try_cleanup (try_stmt
));
1719 gimple_try_set_cleanup (try_copy
, new_seq
);
1723 case GIMPLE_OMP_FOR
:
1724 new_seq
= gimple_seq_copy (gimple_omp_for_pre_body (stmt
));
1725 gimple_omp_for_set_pre_body (copy
, new_seq
);
1726 t
= unshare_expr (gimple_omp_for_clauses (stmt
));
1727 gimple_omp_for_set_clauses (copy
, t
);
1729 gomp_for
*omp_for_copy
= as_a
<gomp_for
*> (copy
);
1730 omp_for_copy
->iter
= ggc_vec_alloc
<gimple_omp_for_iter
>
1731 ( gimple_omp_for_collapse (stmt
));
1733 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1735 gimple_omp_for_set_cond (copy
, i
,
1736 gimple_omp_for_cond (stmt
, i
));
1737 gimple_omp_for_set_index (copy
, i
,
1738 gimple_omp_for_index (stmt
, i
));
1739 t
= unshare_expr (gimple_omp_for_initial (stmt
, i
));
1740 gimple_omp_for_set_initial (copy
, i
, t
);
1741 t
= unshare_expr (gimple_omp_for_final (stmt
, i
));
1742 gimple_omp_for_set_final (copy
, i
, t
);
1743 t
= unshare_expr (gimple_omp_for_incr (stmt
, i
));
1744 gimple_omp_for_set_incr (copy
, i
, t
);
1748 case GIMPLE_OMP_PARALLEL
:
1750 gomp_parallel
*omp_par_stmt
= as_a
<gomp_parallel
*> (stmt
);
1751 gomp_parallel
*omp_par_copy
= as_a
<gomp_parallel
*> (copy
);
1752 t
= unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt
));
1753 gimple_omp_parallel_set_clauses (omp_par_copy
, t
);
1754 t
= unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt
));
1755 gimple_omp_parallel_set_child_fn (omp_par_copy
, t
);
1756 t
= unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt
));
1757 gimple_omp_parallel_set_data_arg (omp_par_copy
, t
);
1761 case GIMPLE_OMP_TASK
:
1762 t
= unshare_expr (gimple_omp_task_clauses (stmt
));
1763 gimple_omp_task_set_clauses (copy
, t
);
1764 t
= unshare_expr (gimple_omp_task_child_fn (stmt
));
1765 gimple_omp_task_set_child_fn (copy
, t
);
1766 t
= unshare_expr (gimple_omp_task_data_arg (stmt
));
1767 gimple_omp_task_set_data_arg (copy
, t
);
1768 t
= unshare_expr (gimple_omp_task_copy_fn (stmt
));
1769 gimple_omp_task_set_copy_fn (copy
, t
);
1770 t
= unshare_expr (gimple_omp_task_arg_size (stmt
));
1771 gimple_omp_task_set_arg_size (copy
, t
);
1772 t
= unshare_expr (gimple_omp_task_arg_align (stmt
));
1773 gimple_omp_task_set_arg_align (copy
, t
);
1776 case GIMPLE_OMP_CRITICAL
:
1777 t
= unshare_expr (gimple_omp_critical_name (
1778 as_a
<gomp_critical
*> (stmt
)));
1779 gimple_omp_critical_set_name (as_a
<gomp_critical
*> (copy
), t
);
1782 case GIMPLE_OMP_SECTIONS
:
1783 t
= unshare_expr (gimple_omp_sections_clauses (stmt
));
1784 gimple_omp_sections_set_clauses (copy
, t
);
1785 t
= unshare_expr (gimple_omp_sections_control (stmt
));
1786 gimple_omp_sections_set_control (copy
, t
);
1789 case GIMPLE_OMP_SINGLE
:
1790 case GIMPLE_OMP_TARGET
:
1791 case GIMPLE_OMP_TEAMS
:
1792 case GIMPLE_OMP_SECTION
:
1793 case GIMPLE_OMP_MASTER
:
1794 case GIMPLE_OMP_TASKGROUP
:
1795 case GIMPLE_OMP_ORDERED
:
1797 new_seq
= gimple_seq_copy (gimple_omp_body (stmt
));
1798 gimple_omp_set_body (copy
, new_seq
);
1801 case GIMPLE_TRANSACTION
:
1802 new_seq
= gimple_seq_copy (gimple_transaction_body (
1803 as_a
<gtransaction
*> (stmt
)));
1804 gimple_transaction_set_body (as_a
<gtransaction
*> (copy
),
1808 case GIMPLE_WITH_CLEANUP_EXPR
:
1809 new_seq
= gimple_seq_copy (gimple_wce_cleanup (stmt
));
1810 gimple_wce_set_cleanup (copy
, new_seq
);
1818 /* Make copy of operands. */
1819 for (i
= 0; i
< num_ops
; i
++)
1820 gimple_set_op (copy
, i
, unshare_expr (gimple_op (stmt
, i
)));
1822 if (gimple_has_mem_ops (stmt
))
1824 gimple_set_vdef (copy
, gimple_vdef (stmt
));
1825 gimple_set_vuse (copy
, gimple_vuse (stmt
));
1828 /* Clear out SSA operand vectors on COPY. */
1829 if (gimple_has_ops (stmt
))
1831 gimple_set_use_ops (copy
, NULL
);
1833 /* SSA operands need to be updated. */
1834 gimple_set_modified (copy
, true);
1841 /* Return true if statement S has side-effects. We consider a
1842 statement to have side effects if:
1844 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
1845 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
1848 gimple_has_side_effects (const_gimple s
)
1850 if (is_gimple_debug (s
))
1853 /* We don't have to scan the arguments to check for
1854 volatile arguments, though, at present, we still
1855 do a scan to check for TREE_SIDE_EFFECTS. */
1856 if (gimple_has_volatile_ops (s
))
1859 if (gimple_code (s
) == GIMPLE_ASM
1860 && gimple_asm_volatile_p (as_a
<const gasm
*> (s
)))
1863 if (is_gimple_call (s
))
1865 int flags
= gimple_call_flags (s
);
1867 /* An infinite loop is considered a side effect. */
1868 if (!(flags
& (ECF_CONST
| ECF_PURE
))
1869 || (flags
& ECF_LOOPING_CONST_OR_PURE
))
1878 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
1879 Return true if S can trap. When INCLUDE_MEM is true, check whether
1880 the memory operations could trap. When INCLUDE_STORES is true and
1881 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
1884 gimple_could_trap_p_1 (gimple s
, bool include_mem
, bool include_stores
)
1886 tree t
, div
= NULL_TREE
;
1891 unsigned i
, start
= (is_gimple_assign (s
) && !include_stores
) ? 1 : 0;
1893 for (i
= start
; i
< gimple_num_ops (s
); i
++)
1894 if (tree_could_trap_p (gimple_op (s
, i
)))
1898 switch (gimple_code (s
))
1901 return gimple_asm_volatile_p (as_a
<gasm
*> (s
));
1904 t
= gimple_call_fndecl (s
);
1905 /* Assume that calls to weak functions may trap. */
1906 if (!t
|| !DECL_P (t
) || DECL_WEAK (t
))
1911 t
= gimple_expr_type (s
);
1912 op
= gimple_assign_rhs_code (s
);
1913 if (get_gimple_rhs_class (op
) == GIMPLE_BINARY_RHS
)
1914 div
= gimple_assign_rhs2 (s
);
1915 return (operation_could_trap_p (op
, FLOAT_TYPE_P (t
),
1916 (INTEGRAL_TYPE_P (t
)
1917 && TYPE_OVERFLOW_TRAPS (t
)),
1927 /* Return true if statement S can trap. */
1930 gimple_could_trap_p (gimple s
)
1932 return gimple_could_trap_p_1 (s
, true, true);
1935 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
1938 gimple_assign_rhs_could_trap_p (gimple s
)
1940 gcc_assert (is_gimple_assign (s
));
1941 return gimple_could_trap_p_1 (s
, true, false);
1945 /* Print debugging information for gimple stmts generated. */
1948 dump_gimple_statistics (void)
1950 int i
, total_tuples
= 0, total_bytes
= 0;
1952 if (! GATHER_STATISTICS
)
1954 fprintf (stderr
, "No gimple statistics\n");
1958 fprintf (stderr
, "\nGIMPLE statements\n");
1959 fprintf (stderr
, "Kind Stmts Bytes\n");
1960 fprintf (stderr
, "---------------------------------------\n");
1961 for (i
= 0; i
< (int) gimple_alloc_kind_all
; ++i
)
1963 fprintf (stderr
, "%-20s %7d %10d\n", gimple_alloc_kind_names
[i
],
1964 gimple_alloc_counts
[i
], gimple_alloc_sizes
[i
]);
1965 total_tuples
+= gimple_alloc_counts
[i
];
1966 total_bytes
+= gimple_alloc_sizes
[i
];
1968 fprintf (stderr
, "---------------------------------------\n");
1969 fprintf (stderr
, "%-20s %7d %10d\n", "Total", total_tuples
, total_bytes
);
1970 fprintf (stderr
, "---------------------------------------\n");
1974 /* Return the number of operands needed on the RHS of a GIMPLE
1975 assignment for an expression with tree code CODE. */
1978 get_gimple_rhs_num_ops (enum tree_code code
)
1980 enum gimple_rhs_class rhs_class
= get_gimple_rhs_class (code
);
1982 if (rhs_class
== GIMPLE_UNARY_RHS
|| rhs_class
== GIMPLE_SINGLE_RHS
)
1984 else if (rhs_class
== GIMPLE_BINARY_RHS
)
1986 else if (rhs_class
== GIMPLE_TERNARY_RHS
)
1992 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
1994 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
1995 : ((TYPE) == tcc_binary \
1996 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
1997 : ((TYPE) == tcc_constant \
1998 || (TYPE) == tcc_declaration \
1999 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2000 : ((SYM) == TRUTH_AND_EXPR \
2001 || (SYM) == TRUTH_OR_EXPR \
2002 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2003 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2004 : ((SYM) == COND_EXPR \
2005 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2006 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2007 || (SYM) == DOT_PROD_EXPR \
2008 || (SYM) == SAD_EXPR \
2009 || (SYM) == REALIGN_LOAD_EXPR \
2010 || (SYM) == VEC_COND_EXPR \
2011 || (SYM) == VEC_PERM_EXPR \
2012 || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS \
2013 : ((SYM) == CONSTRUCTOR \
2014 || (SYM) == OBJ_TYPE_REF \
2015 || (SYM) == ASSERT_EXPR \
2016 || (SYM) == ADDR_EXPR \
2017 || (SYM) == WITH_SIZE_EXPR \
2018 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2019 : GIMPLE_INVALID_RHS),
2020 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2022 const unsigned char gimple_rhs_class_table
[] = {
2023 #include "all-tree.def"
2027 #undef END_OF_BASE_TREE_CODES
2029 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2030 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2031 we failed to create one. */
2034 canonicalize_cond_expr_cond (tree t
)
2036 /* Strip conversions around boolean operations. */
2037 if (CONVERT_EXPR_P (t
)
2038 && (truth_value_p (TREE_CODE (TREE_OPERAND (t
, 0)))
2039 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
2041 t
= TREE_OPERAND (t
, 0);
2043 /* For !x use x == 0. */
2044 if (TREE_CODE (t
) == TRUTH_NOT_EXPR
)
2046 tree top0
= TREE_OPERAND (t
, 0);
2047 t
= build2 (EQ_EXPR
, TREE_TYPE (t
),
2048 top0
, build_int_cst (TREE_TYPE (top0
), 0));
2050 /* For cmp ? 1 : 0 use cmp. */
2051 else if (TREE_CODE (t
) == COND_EXPR
2052 && COMPARISON_CLASS_P (TREE_OPERAND (t
, 0))
2053 && integer_onep (TREE_OPERAND (t
, 1))
2054 && integer_zerop (TREE_OPERAND (t
, 2)))
2056 tree top0
= TREE_OPERAND (t
, 0);
2057 t
= build2 (TREE_CODE (top0
), TREE_TYPE (t
),
2058 TREE_OPERAND (top0
, 0), TREE_OPERAND (top0
, 1));
2060 /* For x ^ y use x != y. */
2061 else if (TREE_CODE (t
) == BIT_XOR_EXPR
)
2062 t
= build2 (NE_EXPR
, TREE_TYPE (t
),
2063 TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1));
2065 if (is_gimple_condexpr (t
))
2071 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2072 the positions marked by the set ARGS_TO_SKIP. */
2075 gimple_call_copy_skip_args (gcall
*stmt
, bitmap args_to_skip
)
2078 int nargs
= gimple_call_num_args (stmt
);
2079 auto_vec
<tree
> vargs (nargs
);
2082 for (i
= 0; i
< nargs
; i
++)
2083 if (!bitmap_bit_p (args_to_skip
, i
))
2084 vargs
.quick_push (gimple_call_arg (stmt
, i
));
2086 if (gimple_call_internal_p (stmt
))
2087 new_stmt
= gimple_build_call_internal_vec (gimple_call_internal_fn (stmt
),
2090 new_stmt
= gimple_build_call_vec (gimple_call_fn (stmt
), vargs
);
2092 if (gimple_call_lhs (stmt
))
2093 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2095 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2096 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
2098 if (gimple_has_location (stmt
))
2099 gimple_set_location (new_stmt
, gimple_location (stmt
));
2100 gimple_call_copy_flags (new_stmt
, stmt
);
2101 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2103 gimple_set_modified (new_stmt
, true);
2110 /* Return true if the field decls F1 and F2 are at the same offset.
2112 This is intended to be used on GIMPLE types only. */
2115 gimple_compare_field_offset (tree f1
, tree f2
)
2117 if (DECL_OFFSET_ALIGN (f1
) == DECL_OFFSET_ALIGN (f2
))
2119 tree offset1
= DECL_FIELD_OFFSET (f1
);
2120 tree offset2
= DECL_FIELD_OFFSET (f2
);
2121 return ((offset1
== offset2
2122 /* Once gimplification is done, self-referential offsets are
2123 instantiated as operand #2 of the COMPONENT_REF built for
2124 each access and reset. Therefore, they are not relevant
2125 anymore and fields are interchangeable provided that they
2126 represent the same access. */
2127 || (TREE_CODE (offset1
) == PLACEHOLDER_EXPR
2128 && TREE_CODE (offset2
) == PLACEHOLDER_EXPR
2129 && (DECL_SIZE (f1
) == DECL_SIZE (f2
)
2130 || (TREE_CODE (DECL_SIZE (f1
)) == PLACEHOLDER_EXPR
2131 && TREE_CODE (DECL_SIZE (f2
)) == PLACEHOLDER_EXPR
)
2132 || operand_equal_p (DECL_SIZE (f1
), DECL_SIZE (f2
), 0))
2133 && DECL_ALIGN (f1
) == DECL_ALIGN (f2
))
2134 || operand_equal_p (offset1
, offset2
, 0))
2135 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1
),
2136 DECL_FIELD_BIT_OFFSET (f2
)));
2139 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2140 should be, so handle differing ones specially by decomposing
2141 the offset into a byte and bit offset manually. */
2142 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1
))
2143 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2
)))
2145 unsigned HOST_WIDE_INT byte_offset1
, byte_offset2
;
2146 unsigned HOST_WIDE_INT bit_offset1
, bit_offset2
;
2147 bit_offset1
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1
));
2148 byte_offset1
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1
))
2149 + bit_offset1
/ BITS_PER_UNIT
);
2150 bit_offset2
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2
));
2151 byte_offset2
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2
))
2152 + bit_offset2
/ BITS_PER_UNIT
);
2153 if (byte_offset1
!= byte_offset2
)
2155 return bit_offset1
% BITS_PER_UNIT
== bit_offset2
% BITS_PER_UNIT
;
2162 /* Return a type the same as TYPE except unsigned or
2163 signed according to UNSIGNEDP. */
2166 gimple_signed_or_unsigned_type (bool unsignedp
, tree type
)
2171 type1
= TYPE_MAIN_VARIANT (type
);
2172 if (type1
== signed_char_type_node
2173 || type1
== char_type_node
2174 || type1
== unsigned_char_type_node
)
2175 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2176 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2177 return unsignedp
? unsigned_type_node
: integer_type_node
;
2178 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2179 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2180 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2181 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2182 if (type1
== long_long_integer_type_node
2183 || type1
== long_long_unsigned_type_node
)
2185 ? long_long_unsigned_type_node
2186 : long_long_integer_type_node
;
2188 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2189 if (int_n_enabled_p
[i
]
2190 && (type1
== int_n_trees
[i
].unsigned_type
2191 || type1
== int_n_trees
[i
].signed_type
))
2193 ? int_n_trees
[i
].unsigned_type
2194 : int_n_trees
[i
].signed_type
;
2196 #if HOST_BITS_PER_WIDE_INT >= 64
2197 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2198 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2200 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2201 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2202 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2203 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2204 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2205 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2206 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2207 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2209 #define GIMPLE_FIXED_TYPES(NAME) \
2210 if (type1 == short_ ## NAME ## _type_node \
2211 || type1 == unsigned_short_ ## NAME ## _type_node) \
2212 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2213 : short_ ## NAME ## _type_node; \
2214 if (type1 == NAME ## _type_node \
2215 || type1 == unsigned_ ## NAME ## _type_node) \
2216 return unsignedp ? unsigned_ ## NAME ## _type_node \
2217 : NAME ## _type_node; \
2218 if (type1 == long_ ## NAME ## _type_node \
2219 || type1 == unsigned_long_ ## NAME ## _type_node) \
2220 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2221 : long_ ## NAME ## _type_node; \
2222 if (type1 == long_long_ ## NAME ## _type_node \
2223 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2224 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2225 : long_long_ ## NAME ## _type_node;
2227 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2228 if (type1 == NAME ## _type_node \
2229 || type1 == u ## NAME ## _type_node) \
2230 return unsignedp ? u ## NAME ## _type_node \
2231 : NAME ## _type_node;
2233 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2234 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2235 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2236 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2237 : sat_ ## short_ ## NAME ## _type_node; \
2238 if (type1 == sat_ ## NAME ## _type_node \
2239 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2240 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2241 : sat_ ## NAME ## _type_node; \
2242 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2243 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2244 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2245 : sat_ ## long_ ## NAME ## _type_node; \
2246 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2247 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2248 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2249 : sat_ ## long_long_ ## NAME ## _type_node;
2251 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2252 if (type1 == sat_ ## NAME ## _type_node \
2253 || type1 == sat_ ## u ## NAME ## _type_node) \
2254 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2255 : sat_ ## NAME ## _type_node;
2257 GIMPLE_FIXED_TYPES (fract
);
2258 GIMPLE_FIXED_TYPES_SAT (fract
);
2259 GIMPLE_FIXED_TYPES (accum
);
2260 GIMPLE_FIXED_TYPES_SAT (accum
);
2262 GIMPLE_FIXED_MODE_TYPES (qq
);
2263 GIMPLE_FIXED_MODE_TYPES (hq
);
2264 GIMPLE_FIXED_MODE_TYPES (sq
);
2265 GIMPLE_FIXED_MODE_TYPES (dq
);
2266 GIMPLE_FIXED_MODE_TYPES (tq
);
2267 GIMPLE_FIXED_MODE_TYPES_SAT (qq
);
2268 GIMPLE_FIXED_MODE_TYPES_SAT (hq
);
2269 GIMPLE_FIXED_MODE_TYPES_SAT (sq
);
2270 GIMPLE_FIXED_MODE_TYPES_SAT (dq
);
2271 GIMPLE_FIXED_MODE_TYPES_SAT (tq
);
2272 GIMPLE_FIXED_MODE_TYPES (ha
);
2273 GIMPLE_FIXED_MODE_TYPES (sa
);
2274 GIMPLE_FIXED_MODE_TYPES (da
);
2275 GIMPLE_FIXED_MODE_TYPES (ta
);
2276 GIMPLE_FIXED_MODE_TYPES_SAT (ha
);
2277 GIMPLE_FIXED_MODE_TYPES_SAT (sa
);
2278 GIMPLE_FIXED_MODE_TYPES_SAT (da
);
2279 GIMPLE_FIXED_MODE_TYPES_SAT (ta
);
2281 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2282 the precision; they have precision set to match their range, but
2283 may use a wider mode to match an ABI. If we change modes, we may
2284 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2285 the precision as well, so as to yield correct results for
2286 bit-field types. C++ does not have these separate bit-field
2287 types, and producing a signed or unsigned variant of an
2288 ENUMERAL_TYPE may cause other problems as well. */
2289 if (!INTEGRAL_TYPE_P (type
)
2290 || TYPE_UNSIGNED (type
) == unsignedp
)
2293 #define TYPE_OK(node) \
2294 (TYPE_MODE (type) == TYPE_MODE (node) \
2295 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2296 if (TYPE_OK (signed_char_type_node
))
2297 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2298 if (TYPE_OK (integer_type_node
))
2299 return unsignedp
? unsigned_type_node
: integer_type_node
;
2300 if (TYPE_OK (short_integer_type_node
))
2301 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2302 if (TYPE_OK (long_integer_type_node
))
2303 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2304 if (TYPE_OK (long_long_integer_type_node
))
2306 ? long_long_unsigned_type_node
2307 : long_long_integer_type_node
);
2309 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2310 if (int_n_enabled_p
[i
]
2311 && TYPE_MODE (type
) == int_n_data
[i
].m
2312 && TYPE_PRECISION (type
) == int_n_data
[i
].bitsize
)
2314 ? int_n_trees
[i
].unsigned_type
2315 : int_n_trees
[i
].signed_type
;
2317 #if HOST_BITS_PER_WIDE_INT >= 64
2318 if (TYPE_OK (intTI_type_node
))
2319 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2321 if (TYPE_OK (intDI_type_node
))
2322 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2323 if (TYPE_OK (intSI_type_node
))
2324 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2325 if (TYPE_OK (intHI_type_node
))
2326 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2327 if (TYPE_OK (intQI_type_node
))
2328 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2330 #undef GIMPLE_FIXED_TYPES
2331 #undef GIMPLE_FIXED_MODE_TYPES
2332 #undef GIMPLE_FIXED_TYPES_SAT
2333 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2336 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2340 /* Return an unsigned type the same as TYPE in other respects. */
2343 gimple_unsigned_type (tree type
)
2345 return gimple_signed_or_unsigned_type (true, type
);
2349 /* Return a signed type the same as TYPE in other respects. */
2352 gimple_signed_type (tree type
)
2354 return gimple_signed_or_unsigned_type (false, type
);
2358 /* Return the typed-based alias set for T, which may be an expression
2359 or a type. Return -1 if we don't do anything special. */
2362 gimple_get_alias_set (tree t
)
2366 /* Permit type-punning when accessing a union, provided the access
2367 is directly through the union. For example, this code does not
2368 permit taking the address of a union member and then storing
2369 through it. Even the type-punning allowed here is a GCC
2370 extension, albeit a common and useful one; the C standard says
2371 that such accesses have implementation-defined behavior. */
2373 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2374 u
= TREE_OPERAND (u
, 0))
2375 if (TREE_CODE (u
) == COMPONENT_REF
2376 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2379 /* That's all the expressions we handle specially. */
2383 /* For convenience, follow the C standard when dealing with
2384 character types. Any object may be accessed via an lvalue that
2385 has character type. */
2386 if (t
== char_type_node
2387 || t
== signed_char_type_node
2388 || t
== unsigned_char_type_node
)
2391 /* Allow aliasing between signed and unsigned variants of the same
2392 type. We treat the signed variant as canonical. */
2393 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2395 tree t1
= gimple_signed_type (t
);
2397 /* t1 == t can happen for boolean nodes which are always unsigned. */
2399 return get_alias_set (t1
);
2406 /* Helper for gimple_ior_addresses_taken_1. */
2409 gimple_ior_addresses_taken_1 (gimple
, tree addr
, tree
, void *data
)
2411 bitmap addresses_taken
= (bitmap
)data
;
2412 addr
= get_base_address (addr
);
2416 bitmap_set_bit (addresses_taken
, DECL_UID (addr
));
2422 /* Set the bit for the uid of all decls that have their address taken
2423 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2424 were any in this stmt. */
2427 gimple_ior_addresses_taken (bitmap addresses_taken
, gimple stmt
)
2429 return walk_stmt_load_store_addr_ops (stmt
, addresses_taken
, NULL
, NULL
,
2430 gimple_ior_addresses_taken_1
);
2434 /* Return true if TYPE1 and TYPE2 are compatible enough for builtin
2438 validate_type (tree type1
, tree type2
)
2440 if (INTEGRAL_TYPE_P (type1
)
2441 && INTEGRAL_TYPE_P (type2
))
2443 else if (POINTER_TYPE_P (type1
)
2444 && POINTER_TYPE_P (type2
))
2446 else if (TREE_CODE (type1
)
2447 != TREE_CODE (type2
))
2452 /* Return true when STMTs arguments and return value match those of FNDECL,
2453 a decl of a builtin function. */
2456 gimple_builtin_call_types_compatible_p (const_gimple stmt
, tree fndecl
)
2458 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
);
2460 tree ret
= gimple_call_lhs (stmt
);
2462 && !validate_type (TREE_TYPE (ret
), TREE_TYPE (TREE_TYPE (fndecl
))))
2465 tree targs
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2466 unsigned nargs
= gimple_call_num_args (stmt
);
2467 for (unsigned i
= 0; i
< nargs
; ++i
)
2469 /* Variadic args follow. */
2472 tree arg
= gimple_call_arg (stmt
, i
);
2473 if (!validate_type (TREE_TYPE (arg
), TREE_VALUE (targs
)))
2475 targs
= TREE_CHAIN (targs
);
2477 if (targs
&& !VOID_TYPE_P (TREE_VALUE (targs
)))
2482 /* Return true when STMT is builtins call. */
2485 gimple_call_builtin_p (const_gimple stmt
)
2488 if (is_gimple_call (stmt
)
2489 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2490 && DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
)
2491 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2495 /* Return true when STMT is builtins call to CLASS. */
2498 gimple_call_builtin_p (const_gimple stmt
, enum built_in_class klass
)
2501 if (is_gimple_call (stmt
)
2502 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2503 && DECL_BUILT_IN_CLASS (fndecl
) == klass
)
2504 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2508 /* Return true when STMT is builtins call to CODE of CLASS. */
2511 gimple_call_builtin_p (const_gimple stmt
, enum built_in_function code
)
2514 if (is_gimple_call (stmt
)
2515 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2516 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
2517 && DECL_FUNCTION_CODE (fndecl
) == code
)
2518 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2522 /* Return true if STMT clobbers memory. STMT is required to be a
2526 gimple_asm_clobbers_memory_p (const gasm
*stmt
)
2530 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
2532 tree op
= gimple_asm_clobber_op (stmt
, i
);
2533 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op
)), "memory") == 0)
2540 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2543 dump_decl_set (FILE *file
, bitmap set
)
2550 fprintf (file
, "{ ");
2552 EXECUTE_IF_SET_IN_BITMAP (set
, 0, i
, bi
)
2554 fprintf (file
, "D.%u", i
);
2555 fprintf (file
, " ");
2558 fprintf (file
, "}");
2561 fprintf (file
, "NIL");
2564 /* Return true when CALL is a call stmt that definitely doesn't
2565 free any memory or makes it unavailable otherwise. */
2567 nonfreeing_call_p (gimple call
)
2569 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2570 && gimple_call_flags (call
) & ECF_LEAF
)
2571 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call
)))
2573 /* Just in case these become ECF_LEAF in the future. */
2575 case BUILT_IN_TM_FREE
:
2576 case BUILT_IN_REALLOC
:
2577 case BUILT_IN_STACK_RESTORE
:
2582 else if (gimple_call_internal_p (call
))
2583 switch (gimple_call_internal_fn (call
))
2585 case IFN_ABNORMAL_DISPATCHER
:
2588 if (gimple_call_flags (call
) & ECF_LEAF
)
2593 tree fndecl
= gimple_call_fndecl (call
);
2596 struct cgraph_node
*n
= cgraph_node::get (fndecl
);
2599 enum availability availability
;
2600 n
= n
->function_symbol (&availability
);
2601 if (!n
|| availability
<= AVAIL_INTERPOSABLE
)
2603 return n
->nonfreeing_fn
;
2606 /* Callback for walk_stmt_load_store_ops.
2608 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2611 This routine only makes a superficial check for a dereference. Thus
2612 it must only be used if it is safe to return a false negative. */
2614 check_loadstore (gimple
, tree op
, tree
, void *data
)
2616 if ((TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
2617 && operand_equal_p (TREE_OPERAND (op
, 0), (tree
)data
, 0))
2622 /* If OP can be inferred to be non-NULL after STMT executes, return true.
2624 DEREFERENCE is TRUE if we can use a pointer dereference to infer a
2625 non-NULL range, FALSE otherwise.
2627 ATTRIBUTE is TRUE if we can use attributes to infer a non-NULL range
2628 for function arguments and return values. FALSE otherwise. */
2631 infer_nonnull_range (gimple stmt
, tree op
, bool dereference
, bool attribute
)
2633 /* We can only assume that a pointer dereference will yield
2634 non-NULL if -fdelete-null-pointer-checks is enabled. */
2635 if (!flag_delete_null_pointer_checks
2636 || !POINTER_TYPE_P (TREE_TYPE (op
))
2637 || gimple_code (stmt
) == GIMPLE_ASM
)
2641 && walk_stmt_load_store_ops (stmt
, (void *)op
,
2642 check_loadstore
, check_loadstore
))
2646 && is_gimple_call (stmt
) && !gimple_call_internal_p (stmt
))
2648 tree fntype
= gimple_call_fntype (stmt
);
2649 tree attrs
= TYPE_ATTRIBUTES (fntype
);
2650 for (; attrs
; attrs
= TREE_CHAIN (attrs
))
2652 attrs
= lookup_attribute ("nonnull", attrs
);
2654 /* If "nonnull" wasn't specified, we know nothing about
2656 if (attrs
== NULL_TREE
)
2659 /* If "nonnull" applies to all the arguments, then ARG
2660 is non-null if it's in the argument list. */
2661 if (TREE_VALUE (attrs
) == NULL_TREE
)
2663 for (unsigned int i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2665 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt
, i
)))
2666 && operand_equal_p (op
, gimple_call_arg (stmt
, i
), 0))
2672 /* Now see if op appears in the nonnull list. */
2673 for (tree t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
2675 int idx
= TREE_INT_CST_LOW (TREE_VALUE (t
)) - 1;
2676 tree arg
= gimple_call_arg (stmt
, idx
);
2677 if (operand_equal_p (op
, arg
, 0))
2683 /* If this function is marked as returning non-null, then we can
2684 infer OP is non-null if it is used in the return statement. */
2686 if (greturn
*return_stmt
= dyn_cast
<greturn
*> (stmt
))
2687 if (gimple_return_retval (return_stmt
)
2688 && operand_equal_p (gimple_return_retval (return_stmt
), op
, 0)
2689 && lookup_attribute ("returns_nonnull",
2690 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
))))
2696 /* Compare two case labels. Because the front end should already have
2697 made sure that case ranges do not overlap, it is enough to only compare
2698 the CASE_LOW values of each case label. */
2701 compare_case_labels (const void *p1
, const void *p2
)
2703 const_tree
const case1
= *(const_tree
const*)p1
;
2704 const_tree
const case2
= *(const_tree
const*)p2
;
2706 /* The 'default' case label always goes first. */
2707 if (!CASE_LOW (case1
))
2709 else if (!CASE_LOW (case2
))
2712 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
2715 /* Sort the case labels in LABEL_VEC in place in ascending order. */
2718 sort_case_labels (vec
<tree
> label_vec
)
2720 label_vec
.qsort (compare_case_labels
);
2723 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2725 LABELS is a vector that contains all case labels to look at.
2727 INDEX_TYPE is the type of the switch index expression. Case labels
2728 in LABELS are discarded if their values are not in the value range
2729 covered by INDEX_TYPE. The remaining case label values are folded
2732 If a default case exists in LABELS, it is removed from LABELS and
2733 returned in DEFAULT_CASEP. If no default case exists, but the
2734 case labels already cover the whole range of INDEX_TYPE, a default
2735 case is returned pointing to one of the existing case labels.
2736 Otherwise DEFAULT_CASEP is set to NULL_TREE.
2738 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2739 apply and no action is taken regardless of whether a default case is
2743 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
2745 tree
*default_casep
)
2747 tree min_value
, max_value
;
2748 tree default_case
= NULL_TREE
;
2752 min_value
= TYPE_MIN_VALUE (index_type
);
2753 max_value
= TYPE_MAX_VALUE (index_type
);
2754 while (i
< labels
.length ())
2756 tree elt
= labels
[i
];
2757 tree low
= CASE_LOW (elt
);
2758 tree high
= CASE_HIGH (elt
);
2759 bool remove_element
= FALSE
;
2763 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
2764 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
2766 /* This is a non-default case label, i.e. it has a value.
2768 See if the case label is reachable within the range of
2769 the index type. Remove out-of-range case values. Turn
2770 case ranges into a canonical form (high > low strictly)
2771 and convert the case label values to the index type.
2773 NB: The type of gimple_switch_index() may be the promoted
2774 type, but the case labels retain the original type. */
2778 /* This is a case range. Discard empty ranges.
2779 If the bounds or the range are equal, turn this
2780 into a simple (one-value) case. */
2781 int cmp
= tree_int_cst_compare (high
, low
);
2783 remove_element
= TRUE
;
2790 /* If the simple case value is unreachable, ignore it. */
2791 if ((TREE_CODE (min_value
) == INTEGER_CST
2792 && tree_int_cst_compare (low
, min_value
) < 0)
2793 || (TREE_CODE (max_value
) == INTEGER_CST
2794 && tree_int_cst_compare (low
, max_value
) > 0))
2795 remove_element
= TRUE
;
2797 low
= fold_convert (index_type
, low
);
2801 /* If the entire case range is unreachable, ignore it. */
2802 if ((TREE_CODE (min_value
) == INTEGER_CST
2803 && tree_int_cst_compare (high
, min_value
) < 0)
2804 || (TREE_CODE (max_value
) == INTEGER_CST
2805 && tree_int_cst_compare (low
, max_value
) > 0))
2806 remove_element
= TRUE
;
2809 /* If the lower bound is less than the index type's
2810 minimum value, truncate the range bounds. */
2811 if (TREE_CODE (min_value
) == INTEGER_CST
2812 && tree_int_cst_compare (low
, min_value
) < 0)
2814 low
= fold_convert (index_type
, low
);
2816 /* If the upper bound is greater than the index type's
2817 maximum value, truncate the range bounds. */
2818 if (TREE_CODE (max_value
) == INTEGER_CST
2819 && tree_int_cst_compare (high
, max_value
) > 0)
2821 high
= fold_convert (index_type
, high
);
2823 /* We may have folded a case range to a one-value case. */
2824 if (tree_int_cst_equal (low
, high
))
2829 CASE_LOW (elt
) = low
;
2830 CASE_HIGH (elt
) = high
;
2834 gcc_assert (!default_case
);
2836 /* The default case must be passed separately to the
2837 gimple_build_switch routine. But if DEFAULT_CASEP
2838 is NULL, we do not remove the default case (it would
2839 be completely lost). */
2841 remove_element
= TRUE
;
2845 labels
.ordered_remove (i
);
2851 if (!labels
.is_empty ())
2852 sort_case_labels (labels
);
2854 if (default_casep
&& !default_case
)
2856 /* If the switch has no default label, add one, so that we jump
2857 around the switch body. If the labels already cover the whole
2858 range of the switch index_type, add the default label pointing
2859 to one of the existing labels. */
2861 && TYPE_MIN_VALUE (index_type
)
2862 && TYPE_MAX_VALUE (index_type
)
2863 && tree_int_cst_equal (CASE_LOW (labels
[0]),
2864 TYPE_MIN_VALUE (index_type
)))
2866 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
2868 high
= CASE_LOW (labels
[len
- 1]);
2869 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
2871 for (i
= 1; i
< len
; i
++)
2873 high
= CASE_LOW (labels
[i
]);
2874 low
= CASE_HIGH (labels
[i
- 1]);
2876 low
= CASE_LOW (labels
[i
- 1]);
2877 if (wi::add (low
, 1) != high
)
2882 tree label
= CASE_LABEL (labels
[0]);
2883 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
2891 *default_casep
= default_case
;
2894 /* Set the location of all statements in SEQ to LOC. */
2897 gimple_seq_set_location (gimple_seq seq
, location_t loc
)
2899 for (gimple_stmt_iterator i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
2900 gimple_set_location (gsi_stmt (i
), loc
);
2903 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
2906 gimple_seq_discard (gimple_seq seq
)
2908 gimple_stmt_iterator gsi
;
2910 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); )
2912 gimple stmt
= gsi_stmt (gsi
);
2913 gsi_remove (&gsi
, true);
2914 release_defs (stmt
);
2919 /* See if STMT now calls function that takes no parameters and if so, drop
2920 call arguments. This is used when devirtualization machinery redirects
2921 to __builtiln_unreacahble or __cxa_pure_virutal. */
2924 maybe_remove_unused_call_args (struct function
*fn
, gimple stmt
)
2926 tree decl
= gimple_call_fndecl (stmt
);
2927 if (TYPE_ARG_TYPES (TREE_TYPE (decl
))
2928 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
))) == void_type_node
2929 && gimple_call_num_args (stmt
))
2931 gimple_set_num_ops (stmt
, 3);
2932 update_stmt_fn (fn
, stmt
);