1 /* Gimple IR support functions.
3 Copyright (C) 2007-2013 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"
29 #include "hard-reg-set.h"
30 #include "basic-block.h"
32 #include "gimple-iterator.h"
33 #include "gimple-walk.h"
36 #include "diagnostic.h"
37 #include "value-prof.h"
41 #include "langhooks.h"
45 /* All the tuples have their operand vector (if present) at the very bottom
46 of the structure. Therefore, the offset required to find the
47 operands vector the size of the structure minus the size of the 1
48 element tree array at the end (see gimple_ops). */
49 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
50 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
51 EXPORTED_CONST
size_t gimple_ops_offset_
[] = {
52 #include "gsstruct.def"
56 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
57 static const size_t gsstruct_code_size
[] = {
58 #include "gsstruct.def"
62 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
63 const char *const gimple_code_name
[] = {
68 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
69 EXPORTED_CONST
enum gimple_statement_structure_enum gss_for_code_
[] = {
76 int gimple_alloc_counts
[(int) gimple_alloc_kind_all
];
77 int gimple_alloc_sizes
[(int) gimple_alloc_kind_all
];
79 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
80 static const char * const gimple_alloc_kind_names
[] = {
87 /* Private API manipulation functions shared only with some
89 extern void gimple_set_stored_syms (gimple
, bitmap
, bitmap_obstack
*);
90 extern void gimple_set_loaded_syms (gimple
, bitmap
, bitmap_obstack
*);
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
)
101 g
->gsbase
.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_d_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. */
139 stmt
->gsbase
.modified
= 1;
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
->gsbase
.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
)
181 gimple s
= gimple_build_with_ops (GIMPLE_RETURN
, ERROR_MARK
, 2);
183 gimple_return_set_retval (s
, retval
);
187 /* Reset alias information on call S. */
190 gimple_call_reset_alias_info (gimple s
)
192 if (gimple_call_flags (s
) & ECF_CONST
)
193 memset (gimple_call_use_set (s
), 0, sizeof (struct pt_solution
));
195 pt_solution_reset (gimple_call_use_set (s
));
196 if (gimple_call_flags (s
) & (ECF_CONST
|ECF_PURE
|ECF_NOVOPS
))
197 memset (gimple_call_clobber_set (s
), 0, sizeof (struct pt_solution
));
199 pt_solution_reset (gimple_call_clobber_set (s
));
202 /* Helper for gimple_build_call, gimple_build_call_valist,
203 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
204 components of a GIMPLE_CALL statement to function FN with NARGS
208 gimple_build_call_1 (tree fn
, unsigned nargs
)
210 gimple s
= gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
, nargs
+ 3);
211 if (TREE_CODE (fn
) == FUNCTION_DECL
)
212 fn
= build_fold_addr_expr (fn
);
213 gimple_set_op (s
, 1, fn
);
214 gimple_call_set_fntype (s
, TREE_TYPE (TREE_TYPE (fn
)));
215 gimple_call_reset_alias_info (s
);
220 /* Build a GIMPLE_CALL statement to function FN with the arguments
221 specified in vector ARGS. */
224 gimple_build_call_vec (tree fn
, vec
<tree
> args
)
227 unsigned nargs
= args
.length ();
228 gimple call
= gimple_build_call_1 (fn
, nargs
);
230 for (i
= 0; i
< nargs
; i
++)
231 gimple_call_set_arg (call
, i
, args
[i
]);
237 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
238 arguments. The ... are the arguments. */
241 gimple_build_call (tree fn
, unsigned nargs
, ...)
247 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
249 call
= gimple_build_call_1 (fn
, nargs
);
251 va_start (ap
, nargs
);
252 for (i
= 0; i
< nargs
; i
++)
253 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
260 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
261 arguments. AP contains the arguments. */
264 gimple_build_call_valist (tree fn
, unsigned nargs
, va_list ap
)
269 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
271 call
= gimple_build_call_1 (fn
, nargs
);
273 for (i
= 0; i
< nargs
; i
++)
274 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
280 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
281 Build the basic components of a GIMPLE_CALL statement to internal
282 function FN with NARGS arguments. */
285 gimple_build_call_internal_1 (enum internal_fn fn
, unsigned nargs
)
287 gimple s
= gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
, nargs
+ 3);
288 s
->gsbase
.subcode
|= GF_CALL_INTERNAL
;
289 gimple_call_set_internal_fn (s
, fn
);
290 gimple_call_reset_alias_info (s
);
295 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
296 the number of arguments. The ... are the arguments. */
299 gimple_build_call_internal (enum internal_fn fn
, unsigned nargs
, ...)
305 call
= gimple_build_call_internal_1 (fn
, nargs
);
306 va_start (ap
, nargs
);
307 for (i
= 0; i
< nargs
; i
++)
308 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
315 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
316 specified in vector ARGS. */
319 gimple_build_call_internal_vec (enum internal_fn fn
, vec
<tree
> args
)
324 nargs
= args
.length ();
325 call
= gimple_build_call_internal_1 (fn
, nargs
);
326 for (i
= 0; i
< nargs
; i
++)
327 gimple_call_set_arg (call
, i
, args
[i
]);
333 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
334 assumed to be in GIMPLE form already. Minimal checking is done of
338 gimple_build_call_from_tree (tree t
)
342 tree fndecl
= get_callee_fndecl (t
);
344 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
346 nargs
= call_expr_nargs (t
);
347 call
= gimple_build_call_1 (fndecl
? fndecl
: CALL_EXPR_FN (t
), nargs
);
349 for (i
= 0; i
< nargs
; i
++)
350 gimple_call_set_arg (call
, i
, CALL_EXPR_ARG (t
, i
));
352 gimple_set_block (call
, TREE_BLOCK (t
));
354 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
355 gimple_call_set_chain (call
, CALL_EXPR_STATIC_CHAIN (t
));
356 gimple_call_set_tail (call
, CALL_EXPR_TAILCALL (t
));
357 gimple_call_set_return_slot_opt (call
, CALL_EXPR_RETURN_SLOT_OPT (t
));
359 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
360 && (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA
361 || DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
362 gimple_call_set_alloca_for_var (call
, CALL_ALLOCA_FOR_VAR_P (t
));
364 gimple_call_set_from_thunk (call
, CALL_FROM_THUNK_P (t
));
365 gimple_call_set_va_arg_pack (call
, CALL_EXPR_VA_ARG_PACK (t
));
366 gimple_call_set_nothrow (call
, TREE_NOTHROW (t
));
367 gimple_set_no_warning (call
, TREE_NO_WARNING (t
));
373 /* Return index of INDEX's non bound argument of the call. */
376 gimple_call_get_nobnd_arg_index (const_gimple gs
, unsigned index
)
378 unsigned num_args
= gimple_call_num_args (gs
);
379 for (unsigned n
= 0; n
< num_args
; n
++)
381 if (POINTER_BOUNDS_P (gimple_call_arg (gs
, n
)))
393 /* Build a GIMPLE_ASSIGN statement.
395 LHS of the assignment.
396 RHS of the assignment which can be unary or binary. */
399 gimple_build_assign_stat (tree lhs
, tree rhs MEM_STAT_DECL
)
401 enum tree_code subcode
;
404 extract_ops_from_tree_1 (rhs
, &subcode
, &op1
, &op2
, &op3
);
405 return gimple_build_assign_with_ops (subcode
, lhs
, op1
, op2
, op3
410 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
411 OP1 and OP2. If OP2 is NULL then SUBCODE must be of class
412 GIMPLE_UNARY_RHS or GIMPLE_SINGLE_RHS. */
415 gimple_build_assign_with_ops (enum tree_code subcode
, tree lhs
, tree op1
,
416 tree op2
, tree op3 MEM_STAT_DECL
)
421 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
423 num_ops
= get_gimple_rhs_num_ops (subcode
) + 1;
425 p
= gimple_build_with_ops_stat (GIMPLE_ASSIGN
, (unsigned)subcode
, num_ops
427 gimple_assign_set_lhs (p
, lhs
);
428 gimple_assign_set_rhs1 (p
, op1
);
431 gcc_assert (num_ops
> 2);
432 gimple_assign_set_rhs2 (p
, op2
);
437 gcc_assert (num_ops
> 3);
438 gimple_assign_set_rhs3 (p
, op3
);
445 gimple_build_assign_with_ops (enum tree_code subcode
, tree lhs
, tree op1
,
446 tree op2 MEM_STAT_DECL
)
448 return gimple_build_assign_with_ops (subcode
, lhs
, op1
, op2
, NULL_TREE
453 /* Build a GIMPLE_COND statement.
455 PRED is the condition used to compare LHS and the RHS.
456 T_LABEL is the label to jump to if the condition is true.
457 F_LABEL is the label to jump to otherwise. */
460 gimple_build_cond (enum tree_code pred_code
, tree lhs
, tree rhs
,
461 tree t_label
, tree f_label
)
465 gcc_assert (TREE_CODE_CLASS (pred_code
) == tcc_comparison
);
466 p
= gimple_build_with_ops (GIMPLE_COND
, pred_code
, 4);
467 gimple_cond_set_lhs (p
, lhs
);
468 gimple_cond_set_rhs (p
, rhs
);
469 gimple_cond_set_true_label (p
, t_label
);
470 gimple_cond_set_false_label (p
, f_label
);
474 /* Build a GIMPLE_COND statement from the conditional expression tree
475 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
478 gimple_build_cond_from_tree (tree cond
, tree t_label
, tree f_label
)
483 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
484 return gimple_build_cond (code
, lhs
, rhs
, t_label
, f_label
);
487 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
488 boolean expression tree COND. */
491 gimple_cond_set_condition_from_tree (gimple stmt
, tree cond
)
496 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
497 gimple_cond_set_condition (stmt
, code
, lhs
, rhs
);
500 /* Build a GIMPLE_LABEL statement for LABEL. */
503 gimple_build_label (tree label
)
505 gimple p
= gimple_build_with_ops (GIMPLE_LABEL
, ERROR_MARK
, 1);
506 gimple_label_set_label (p
, label
);
510 /* Build a GIMPLE_GOTO statement to label DEST. */
513 gimple_build_goto (tree dest
)
515 gimple p
= gimple_build_with_ops (GIMPLE_GOTO
, ERROR_MARK
, 1);
516 gimple_goto_set_dest (p
, dest
);
521 /* Build a GIMPLE_NOP statement. */
524 gimple_build_nop (void)
526 return gimple_alloc (GIMPLE_NOP
, 0);
530 /* Build a GIMPLE_BIND statement.
531 VARS are the variables in BODY.
532 BLOCK is the containing block. */
535 gimple_build_bind (tree vars
, gimple_seq body
, tree block
)
537 gimple p
= gimple_alloc (GIMPLE_BIND
, 0);
538 gimple_bind_set_vars (p
, vars
);
540 gimple_bind_set_body (p
, body
);
542 gimple_bind_set_block (p
, block
);
546 /* Helper function to set the simple fields of a asm stmt.
548 STRING is a pointer to a string that is the asm blocks assembly code.
549 NINPUT is the number of register inputs.
550 NOUTPUT is the number of register outputs.
551 NCLOBBERS is the number of clobbered registers.
555 gimple_build_asm_1 (const char *string
, unsigned ninputs
, unsigned noutputs
,
556 unsigned nclobbers
, unsigned nlabels
)
559 int size
= strlen (string
);
561 /* ASMs with labels cannot have outputs. This should have been
562 enforced by the front end. */
563 gcc_assert (nlabels
== 0 || noutputs
== 0);
565 p
= gimple_build_with_ops (GIMPLE_ASM
, ERROR_MARK
,
566 ninputs
+ noutputs
+ nclobbers
+ nlabels
);
568 p
->gimple_asm
.ni
= ninputs
;
569 p
->gimple_asm
.no
= noutputs
;
570 p
->gimple_asm
.nc
= nclobbers
;
571 p
->gimple_asm
.nl
= nlabels
;
572 p
->gimple_asm
.string
= ggc_alloc_string (string
, size
);
574 if (GATHER_STATISTICS
)
575 gimple_alloc_sizes
[(int) gimple_alloc_kind (GIMPLE_ASM
)] += size
;
580 /* Build a GIMPLE_ASM statement.
582 STRING is the assembly code.
583 NINPUT is the number of register inputs.
584 NOUTPUT is the number of register outputs.
585 NCLOBBERS is the number of clobbered registers.
586 INPUTS is a vector of the input register parameters.
587 OUTPUTS is a vector of the output register parameters.
588 CLOBBERS is a vector of the clobbered register parameters.
589 LABELS is a vector of destination labels. */
592 gimple_build_asm_vec (const char *string
, vec
<tree
, va_gc
> *inputs
,
593 vec
<tree
, va_gc
> *outputs
, vec
<tree
, va_gc
> *clobbers
,
594 vec
<tree
, va_gc
> *labels
)
599 p
= gimple_build_asm_1 (string
,
600 vec_safe_length (inputs
),
601 vec_safe_length (outputs
),
602 vec_safe_length (clobbers
),
603 vec_safe_length (labels
));
605 for (i
= 0; i
< vec_safe_length (inputs
); i
++)
606 gimple_asm_set_input_op (p
, i
, (*inputs
)[i
]);
608 for (i
= 0; i
< vec_safe_length (outputs
); i
++)
609 gimple_asm_set_output_op (p
, i
, (*outputs
)[i
]);
611 for (i
= 0; i
< vec_safe_length (clobbers
); i
++)
612 gimple_asm_set_clobber_op (p
, i
, (*clobbers
)[i
]);
614 for (i
= 0; i
< vec_safe_length (labels
); i
++)
615 gimple_asm_set_label_op (p
, i
, (*labels
)[i
]);
620 /* Build a GIMPLE_CATCH statement.
622 TYPES are the catch types.
623 HANDLER is the exception handler. */
626 gimple_build_catch (tree types
, gimple_seq handler
)
628 gimple p
= gimple_alloc (GIMPLE_CATCH
, 0);
629 gimple_catch_set_types (p
, types
);
631 gimple_catch_set_handler (p
, handler
);
636 /* Build a GIMPLE_EH_FILTER statement.
638 TYPES are the filter's types.
639 FAILURE is the filter's failure action. */
642 gimple_build_eh_filter (tree types
, gimple_seq failure
)
644 gimple p
= gimple_alloc (GIMPLE_EH_FILTER
, 0);
645 gimple_eh_filter_set_types (p
, types
);
647 gimple_eh_filter_set_failure (p
, failure
);
652 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
655 gimple_build_eh_must_not_throw (tree decl
)
657 gimple p
= gimple_alloc (GIMPLE_EH_MUST_NOT_THROW
, 0);
659 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
660 gcc_assert (flags_from_decl_or_type (decl
) & ECF_NORETURN
);
661 gimple_eh_must_not_throw_set_fndecl (p
, decl
);
666 /* Build a GIMPLE_EH_ELSE statement. */
669 gimple_build_eh_else (gimple_seq n_body
, gimple_seq e_body
)
671 gimple p
= gimple_alloc (GIMPLE_EH_ELSE
, 0);
672 gimple_eh_else_set_n_body (p
, n_body
);
673 gimple_eh_else_set_e_body (p
, e_body
);
677 /* Build a GIMPLE_TRY statement.
679 EVAL is the expression to evaluate.
680 CLEANUP is the cleanup expression.
681 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
682 whether this is a try/catch or a try/finally respectively. */
685 gimple_build_try (gimple_seq eval
, gimple_seq cleanup
,
686 enum gimple_try_flags kind
)
690 gcc_assert (kind
== GIMPLE_TRY_CATCH
|| kind
== GIMPLE_TRY_FINALLY
);
691 p
= gimple_alloc (GIMPLE_TRY
, 0);
692 gimple_set_subcode (p
, kind
);
694 gimple_try_set_eval (p
, eval
);
696 gimple_try_set_cleanup (p
, cleanup
);
701 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
703 CLEANUP is the cleanup expression. */
706 gimple_build_wce (gimple_seq cleanup
)
708 gimple p
= gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR
, 0);
710 gimple_wce_set_cleanup (p
, cleanup
);
716 /* Build a GIMPLE_RESX statement. */
719 gimple_build_resx (int region
)
721 gimple p
= gimple_build_with_ops (GIMPLE_RESX
, ERROR_MARK
, 0);
722 p
->gimple_eh_ctrl
.region
= region
;
727 /* The helper for constructing a gimple switch statement.
728 INDEX is the switch's index.
729 NLABELS is the number of labels in the switch excluding the default.
730 DEFAULT_LABEL is the default label for the switch statement. */
733 gimple_build_switch_nlabels (unsigned nlabels
, tree index
, tree default_label
)
735 /* nlabels + 1 default label + 1 index. */
736 gcc_checking_assert (default_label
);
737 gimple p
= gimple_build_with_ops (GIMPLE_SWITCH
, ERROR_MARK
,
739 gimple_switch_set_index (p
, index
);
740 gimple_switch_set_default_label (p
, default_label
);
744 /* Build a GIMPLE_SWITCH statement.
746 INDEX is the switch's index.
747 DEFAULT_LABEL is the default label
748 ARGS is a vector of labels excluding the default. */
751 gimple_build_switch (tree index
, tree default_label
, vec
<tree
> args
)
753 unsigned i
, nlabels
= args
.length ();
755 gimple p
= gimple_build_switch_nlabels (nlabels
, index
, default_label
);
757 /* Copy the labels from the vector to the switch statement. */
758 for (i
= 0; i
< nlabels
; i
++)
759 gimple_switch_set_label (p
, i
+ 1, args
[i
]);
764 /* Build a GIMPLE_EH_DISPATCH statement. */
767 gimple_build_eh_dispatch (int region
)
769 gimple p
= gimple_build_with_ops (GIMPLE_EH_DISPATCH
, ERROR_MARK
, 0);
770 p
->gimple_eh_ctrl
.region
= region
;
774 /* Build a new GIMPLE_DEBUG_BIND statement.
776 VAR is bound to VALUE; block and location are taken from STMT. */
779 gimple_build_debug_bind_stat (tree var
, tree value
, gimple stmt MEM_STAT_DECL
)
781 gimple p
= gimple_build_with_ops_stat (GIMPLE_DEBUG
,
782 (unsigned)GIMPLE_DEBUG_BIND
, 2
785 gimple_debug_bind_set_var (p
, var
);
786 gimple_debug_bind_set_value (p
, value
);
788 gimple_set_location (p
, gimple_location (stmt
));
794 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
796 VAR is bound to VALUE; block and location are taken from STMT. */
799 gimple_build_debug_source_bind_stat (tree var
, tree value
,
800 gimple stmt MEM_STAT_DECL
)
802 gimple p
= gimple_build_with_ops_stat (GIMPLE_DEBUG
,
803 (unsigned)GIMPLE_DEBUG_SOURCE_BIND
, 2
806 gimple_debug_source_bind_set_var (p
, var
);
807 gimple_debug_source_bind_set_value (p
, value
);
809 gimple_set_location (p
, gimple_location (stmt
));
815 /* Build a GIMPLE_OMP_CRITICAL statement.
817 BODY is the sequence of statements for which only one thread can execute.
818 NAME is optional identifier for this critical block. */
821 gimple_build_omp_critical (gimple_seq body
, tree name
)
823 gimple p
= gimple_alloc (GIMPLE_OMP_CRITICAL
, 0);
824 gimple_omp_critical_set_name (p
, name
);
826 gimple_omp_set_body (p
, body
);
831 /* Build a GIMPLE_OMP_FOR statement.
833 BODY is sequence of statements inside the for loop.
834 KIND is the `for' variant.
835 CLAUSES, are any of the OMP loop construct's clauses: private, firstprivate,
836 lastprivate, reductions, ordered, schedule, and nowait.
837 COLLAPSE is the collapse count.
838 PRE_BODY is the sequence of statements that are loop invariant. */
841 gimple_build_omp_for (gimple_seq body
, int kind
, tree clauses
, size_t collapse
,
844 gimple p
= gimple_alloc (GIMPLE_OMP_FOR
, 0);
846 gimple_omp_set_body (p
, body
);
847 gimple_omp_for_set_clauses (p
, clauses
);
848 gimple_omp_for_set_kind (p
, kind
);
849 p
->gimple_omp_for
.collapse
= collapse
;
850 p
->gimple_omp_for
.iter
851 = ggc_alloc_cleared_vec_gimple_omp_for_iter (collapse
);
853 gimple_omp_for_set_pre_body (p
, pre_body
);
859 /* Build a GIMPLE_OMP_PARALLEL statement.
861 BODY is sequence of statements which are executed in parallel.
862 CLAUSES, are the OMP parallel construct's clauses.
863 CHILD_FN is the function created for the parallel threads to execute.
864 DATA_ARG are the shared data argument(s). */
867 gimple_build_omp_parallel (gimple_seq body
, tree clauses
, tree child_fn
,
870 gimple p
= gimple_alloc (GIMPLE_OMP_PARALLEL
, 0);
872 gimple_omp_set_body (p
, body
);
873 gimple_omp_parallel_set_clauses (p
, clauses
);
874 gimple_omp_parallel_set_child_fn (p
, child_fn
);
875 gimple_omp_parallel_set_data_arg (p
, data_arg
);
881 /* Build a GIMPLE_OMP_TASK statement.
883 BODY is sequence of statements which are executed by the explicit task.
884 CLAUSES, are the OMP parallel construct's clauses.
885 CHILD_FN is the function created for the parallel threads to execute.
886 DATA_ARG are the shared data argument(s).
887 COPY_FN is the optional function for firstprivate initialization.
888 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
891 gimple_build_omp_task (gimple_seq body
, tree clauses
, tree child_fn
,
892 tree data_arg
, tree copy_fn
, tree arg_size
,
895 gimple p
= gimple_alloc (GIMPLE_OMP_TASK
, 0);
897 gimple_omp_set_body (p
, body
);
898 gimple_omp_task_set_clauses (p
, clauses
);
899 gimple_omp_task_set_child_fn (p
, child_fn
);
900 gimple_omp_task_set_data_arg (p
, data_arg
);
901 gimple_omp_task_set_copy_fn (p
, copy_fn
);
902 gimple_omp_task_set_arg_size (p
, arg_size
);
903 gimple_omp_task_set_arg_align (p
, arg_align
);
909 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
911 BODY is the sequence of statements in the section. */
914 gimple_build_omp_section (gimple_seq body
)
916 gimple p
= gimple_alloc (GIMPLE_OMP_SECTION
, 0);
918 gimple_omp_set_body (p
, body
);
924 /* Build a GIMPLE_OMP_MASTER statement.
926 BODY is the sequence of statements to be executed by just the master. */
929 gimple_build_omp_master (gimple_seq body
)
931 gimple p
= gimple_alloc (GIMPLE_OMP_MASTER
, 0);
933 gimple_omp_set_body (p
, body
);
939 /* Build a GIMPLE_OMP_TASKGROUP statement.
941 BODY is the sequence of statements to be executed by the taskgroup
945 gimple_build_omp_taskgroup (gimple_seq body
)
947 gimple p
= gimple_alloc (GIMPLE_OMP_TASKGROUP
, 0);
949 gimple_omp_set_body (p
, body
);
955 /* Build a GIMPLE_OMP_CONTINUE statement.
957 CONTROL_DEF is the definition of the control variable.
958 CONTROL_USE is the use of the control variable. */
961 gimple_build_omp_continue (tree control_def
, tree control_use
)
963 gimple p
= gimple_alloc (GIMPLE_OMP_CONTINUE
, 0);
964 gimple_omp_continue_set_control_def (p
, control_def
);
965 gimple_omp_continue_set_control_use (p
, control_use
);
969 /* Build a GIMPLE_OMP_ORDERED statement.
971 BODY is the sequence of statements inside a loop that will executed in
975 gimple_build_omp_ordered (gimple_seq body
)
977 gimple p
= gimple_alloc (GIMPLE_OMP_ORDERED
, 0);
979 gimple_omp_set_body (p
, body
);
985 /* Build a GIMPLE_OMP_RETURN statement.
986 WAIT_P is true if this is a non-waiting return. */
989 gimple_build_omp_return (bool wait_p
)
991 gimple p
= gimple_alloc (GIMPLE_OMP_RETURN
, 0);
993 gimple_omp_return_set_nowait (p
);
999 /* Build a GIMPLE_OMP_SECTIONS statement.
1001 BODY is a sequence of section statements.
1002 CLAUSES are any of the OMP sections contsruct's clauses: private,
1003 firstprivate, lastprivate, reduction, and nowait. */
1006 gimple_build_omp_sections (gimple_seq body
, tree clauses
)
1008 gimple p
= gimple_alloc (GIMPLE_OMP_SECTIONS
, 0);
1010 gimple_omp_set_body (p
, body
);
1011 gimple_omp_sections_set_clauses (p
, clauses
);
1017 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1020 gimple_build_omp_sections_switch (void)
1022 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH
, 0);
1026 /* Build a GIMPLE_OMP_SINGLE statement.
1028 BODY is the sequence of statements that will be executed once.
1029 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1030 copyprivate, nowait. */
1033 gimple_build_omp_single (gimple_seq body
, tree clauses
)
1035 gimple p
= gimple_alloc (GIMPLE_OMP_SINGLE
, 0);
1037 gimple_omp_set_body (p
, body
);
1038 gimple_omp_single_set_clauses (p
, clauses
);
1044 /* Build a GIMPLE_OMP_TARGET statement.
1046 BODY is the sequence of statements that will be executed.
1047 CLAUSES are any of the OMP target construct's clauses. */
1050 gimple_build_omp_target (gimple_seq body
, int kind
, tree clauses
)
1052 gimple p
= gimple_alloc (GIMPLE_OMP_TARGET
, 0);
1054 gimple_omp_set_body (p
, body
);
1055 gimple_omp_target_set_clauses (p
, clauses
);
1056 gimple_omp_target_set_kind (p
, kind
);
1062 /* Build a GIMPLE_OMP_TEAMS statement.
1064 BODY is the sequence of statements that will be executed.
1065 CLAUSES are any of the OMP teams construct's clauses. */
1068 gimple_build_omp_teams (gimple_seq body
, tree clauses
)
1070 gimple p
= gimple_alloc (GIMPLE_OMP_TEAMS
, 0);
1072 gimple_omp_set_body (p
, body
);
1073 gimple_omp_teams_set_clauses (p
, clauses
);
1079 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1082 gimple_build_omp_atomic_load (tree lhs
, tree rhs
)
1084 gimple p
= gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD
, 0);
1085 gimple_omp_atomic_load_set_lhs (p
, lhs
);
1086 gimple_omp_atomic_load_set_rhs (p
, rhs
);
1090 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1092 VAL is the value we are storing. */
1095 gimple_build_omp_atomic_store (tree val
)
1097 gimple p
= gimple_alloc (GIMPLE_OMP_ATOMIC_STORE
, 0);
1098 gimple_omp_atomic_store_set_val (p
, val
);
1102 /* Build a GIMPLE_TRANSACTION statement. */
1105 gimple_build_transaction (gimple_seq body
, tree label
)
1107 gimple p
= gimple_alloc (GIMPLE_TRANSACTION
, 0);
1108 gimple_transaction_set_body (p
, body
);
1109 gimple_transaction_set_label (p
, label
);
1113 /* Build a GIMPLE_PREDICT statement. PREDICT is one of the predictors from
1114 predict.def, OUTCOME is NOT_TAKEN or TAKEN. */
1117 gimple_build_predict (enum br_predictor predictor
, enum prediction outcome
)
1119 gimple p
= gimple_alloc (GIMPLE_PREDICT
, 0);
1120 /* Ensure all the predictors fit into the lower bits of the subcode. */
1121 gcc_assert ((int) END_PREDICTORS
<= GF_PREDICT_TAKEN
);
1122 gimple_predict_set_predictor (p
, predictor
);
1123 gimple_predict_set_outcome (p
, outcome
);
1127 #if defined ENABLE_GIMPLE_CHECKING
1128 /* Complain of a gimple type mismatch and die. */
1131 gimple_check_failed (const_gimple gs
, const char *file
, int line
,
1132 const char *function
, enum gimple_code code
,
1133 enum tree_code subcode
)
1135 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1136 gimple_code_name
[code
],
1137 get_tree_code_name (subcode
),
1138 gimple_code_name
[gimple_code (gs
)],
1139 gs
->gsbase
.subcode
> 0
1140 ? get_tree_code_name ((enum tree_code
) gs
->gsbase
.subcode
)
1142 function
, trim_filename (file
), line
);
1144 #endif /* ENABLE_GIMPLE_CHECKING */
1147 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1148 *SEQ_P is NULL, a new sequence is allocated. */
1151 gimple_seq_add_stmt (gimple_seq
*seq_p
, gimple gs
)
1153 gimple_stmt_iterator si
;
1157 si
= gsi_last (*seq_p
);
1158 gsi_insert_after (&si
, gs
, GSI_NEW_STMT
);
1161 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1162 *SEQ_P is NULL, a new sequence is allocated. This function is
1163 similar to gimple_seq_add_stmt, but does not scan the operands.
1164 During gimplification, we need to manipulate statement sequences
1165 before the def/use vectors have been constructed. */
1168 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple gs
)
1170 gimple_stmt_iterator si
;
1175 si
= gsi_last (*seq_p
);
1176 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
1179 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1180 NULL, a new sequence is allocated. */
1183 gimple_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
1185 gimple_stmt_iterator si
;
1189 si
= gsi_last (*dst_p
);
1190 gsi_insert_seq_after (&si
, src
, GSI_NEW_STMT
);
1193 /* Determine whether to assign a location to the statement GS. */
1196 should_carry_location_p (gimple gs
)
1198 /* Don't emit a line note for a label. We particularly don't want to
1199 emit one for the break label, since it doesn't actually correspond
1200 to the beginning of the loop/switch. */
1201 if (gimple_code (gs
) == GIMPLE_LABEL
)
1207 /* Set the location for gimple statement GS to LOCATION. */
1210 annotate_one_with_location (gimple gs
, location_t location
)
1212 if (!gimple_has_location (gs
)
1213 && !gimple_do_not_emit_location_p (gs
)
1214 && should_carry_location_p (gs
))
1215 gimple_set_location (gs
, location
);
1218 /* Set LOCATION for all the statements after iterator GSI in sequence
1219 SEQ. If GSI is pointing to the end of the sequence, start with the
1220 first statement in SEQ. */
1223 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
1224 location_t location
)
1226 if (gsi_end_p (gsi
))
1227 gsi
= gsi_start (seq
);
1231 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
1232 annotate_one_with_location (gsi_stmt (gsi
), location
);
1235 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1238 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
1240 gimple_stmt_iterator i
;
1242 if (gimple_seq_empty_p (stmt_p
))
1245 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
1247 gimple gs
= gsi_stmt (i
);
1248 annotate_one_with_location (gs
, location
);
1252 /* Helper function of empty_body_p. Return true if STMT is an empty
1256 empty_stmt_p (gimple stmt
)
1258 if (gimple_code (stmt
) == GIMPLE_NOP
)
1260 if (gimple_code (stmt
) == GIMPLE_BIND
)
1261 return empty_body_p (gimple_bind_body (stmt
));
1266 /* Return true if BODY contains nothing but empty statements. */
1269 empty_body_p (gimple_seq body
)
1271 gimple_stmt_iterator i
;
1273 if (gimple_seq_empty_p (body
))
1275 for (i
= gsi_start (body
); !gsi_end_p (i
); gsi_next (&i
))
1276 if (!empty_stmt_p (gsi_stmt (i
))
1277 && !is_gimple_debug (gsi_stmt (i
)))
1284 /* Perform a deep copy of sequence SRC and return the result. */
1287 gimple_seq_copy (gimple_seq src
)
1289 gimple_stmt_iterator gsi
;
1290 gimple_seq new_seq
= NULL
;
1293 for (gsi
= gsi_start (src
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1295 stmt
= gimple_copy (gsi_stmt (gsi
));
1296 gimple_seq_add_stmt (&new_seq
, stmt
);
1304 /* Return true if calls C1 and C2 are known to go to the same function. */
1307 gimple_call_same_target_p (const_gimple c1
, const_gimple c2
)
1309 if (gimple_call_internal_p (c1
))
1310 return (gimple_call_internal_p (c2
)
1311 && gimple_call_internal_fn (c1
) == gimple_call_internal_fn (c2
));
1313 return (gimple_call_fn (c1
) == gimple_call_fn (c2
)
1314 || (gimple_call_fndecl (c1
)
1315 && gimple_call_fndecl (c1
) == gimple_call_fndecl (c2
)));
1318 /* Detect flags from a GIMPLE_CALL. This is just like
1319 call_expr_flags, but for gimple tuples. */
1322 gimple_call_flags (const_gimple stmt
)
1325 tree decl
= gimple_call_fndecl (stmt
);
1328 flags
= flags_from_decl_or_type (decl
);
1329 else if (gimple_call_internal_p (stmt
))
1330 flags
= internal_fn_flags (gimple_call_internal_fn (stmt
));
1332 flags
= flags_from_decl_or_type (gimple_call_fntype (stmt
));
1334 if (stmt
->gsbase
.subcode
& GF_CALL_NOTHROW
)
1335 flags
|= ECF_NOTHROW
;
1340 /* Return the "fn spec" string for call STMT. */
1343 gimple_call_fnspec (const_gimple stmt
)
1347 type
= gimple_call_fntype (stmt
);
1351 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
1355 return TREE_VALUE (TREE_VALUE (attr
));
1358 /* Detects argument flags for argument number ARG on call STMT. */
1361 gimple_call_arg_flags (const_gimple stmt
, unsigned arg
)
1363 tree attr
= gimple_call_fnspec (stmt
);
1365 if (!attr
|| 1 + arg
>= (unsigned) TREE_STRING_LENGTH (attr
))
1368 switch (TREE_STRING_POINTER (attr
)[1 + arg
])
1375 return EAF_DIRECT
| EAF_NOCLOBBER
| EAF_NOESCAPE
;
1378 return EAF_NOCLOBBER
| EAF_NOESCAPE
;
1381 return EAF_DIRECT
| EAF_NOESCAPE
;
1384 return EAF_NOESCAPE
;
1392 /* Detects return flags for the call STMT. */
1395 gimple_call_return_flags (const_gimple stmt
)
1399 if (gimple_call_flags (stmt
) & ECF_MALLOC
)
1402 attr
= gimple_call_fnspec (stmt
);
1403 if (!attr
|| TREE_STRING_LENGTH (attr
) < 1)
1406 switch (TREE_STRING_POINTER (attr
)[0])
1412 return ERF_RETURNS_ARG
| (TREE_STRING_POINTER (attr
)[0] - '1');
1424 /* Return true if GS is a copy assignment. */
1427 gimple_assign_copy_p (gimple gs
)
1429 return (gimple_assign_single_p (gs
)
1430 && is_gimple_val (gimple_op (gs
, 1)));
1434 /* Return true if GS is a SSA_NAME copy assignment. */
1437 gimple_assign_ssa_name_copy_p (gimple gs
)
1439 return (gimple_assign_single_p (gs
)
1440 && TREE_CODE (gimple_assign_lhs (gs
)) == SSA_NAME
1441 && TREE_CODE (gimple_assign_rhs1 (gs
)) == SSA_NAME
);
1445 /* Return true if GS is an assignment with a unary RHS, but the
1446 operator has no effect on the assigned value. The logic is adapted
1447 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1448 instances in which STRIP_NOPS was previously applied to the RHS of
1451 NOTE: In the use cases that led to the creation of this function
1452 and of gimple_assign_single_p, it is typical to test for either
1453 condition and to proceed in the same manner. In each case, the
1454 assigned value is represented by the single RHS operand of the
1455 assignment. I suspect there may be cases where gimple_assign_copy_p,
1456 gimple_assign_single_p, or equivalent logic is used where a similar
1457 treatment of unary NOPs is appropriate. */
1460 gimple_assign_unary_nop_p (gimple gs
)
1462 return (is_gimple_assign (gs
)
1463 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs
))
1464 || gimple_assign_rhs_code (gs
) == NON_LVALUE_EXPR
)
1465 && gimple_assign_rhs1 (gs
) != error_mark_node
1466 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs
)))
1467 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs
)))));
1470 /* Set BB to be the basic block holding G. */
1473 gimple_set_bb (gimple stmt
, basic_block bb
)
1475 stmt
->gsbase
.bb
= bb
;
1477 /* If the statement is a label, add the label to block-to-labels map
1478 so that we can speed up edge creation for GIMPLE_GOTOs. */
1479 if (cfun
->cfg
&& gimple_code (stmt
) == GIMPLE_LABEL
)
1484 t
= gimple_label_label (stmt
);
1485 uid
= LABEL_DECL_UID (t
);
1488 unsigned old_len
= vec_safe_length (label_to_block_map
);
1489 LABEL_DECL_UID (t
) = uid
= cfun
->cfg
->last_label_uid
++;
1490 if (old_len
<= (unsigned) uid
)
1492 unsigned new_len
= 3 * uid
/ 2 + 1;
1494 vec_safe_grow_cleared (label_to_block_map
, new_len
);
1498 (*label_to_block_map
)[uid
] = bb
;
1503 /* Modify the RHS of the assignment pointed-to by GSI using the
1504 operands in the expression tree EXPR.
1506 NOTE: The statement pointed-to by GSI may be reallocated if it
1507 did not have enough operand slots.
1509 This function is useful to convert an existing tree expression into
1510 the flat representation used for the RHS of a GIMPLE assignment.
1511 It will reallocate memory as needed to expand or shrink the number
1512 of operand slots needed to represent EXPR.
1514 NOTE: If you find yourself building a tree and then calling this
1515 function, you are most certainly doing it the slow way. It is much
1516 better to build a new assignment or to use the function
1517 gimple_assign_set_rhs_with_ops, which does not require an
1518 expression tree to be built. */
1521 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*gsi
, tree expr
)
1523 enum tree_code subcode
;
1526 extract_ops_from_tree_1 (expr
, &subcode
, &op1
, &op2
, &op3
);
1527 gimple_assign_set_rhs_with_ops_1 (gsi
, subcode
, op1
, op2
, op3
);
1531 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1532 operands OP1, OP2 and OP3.
1534 NOTE: The statement pointed-to by GSI may be reallocated if it
1535 did not have enough operand slots. */
1538 gimple_assign_set_rhs_with_ops_1 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
1539 tree op1
, tree op2
, tree op3
)
1541 unsigned new_rhs_ops
= get_gimple_rhs_num_ops (code
);
1542 gimple stmt
= gsi_stmt (*gsi
);
1544 /* If the new CODE needs more operands, allocate a new statement. */
1545 if (gimple_num_ops (stmt
) < new_rhs_ops
+ 1)
1547 tree lhs
= gimple_assign_lhs (stmt
);
1548 gimple new_stmt
= gimple_alloc (gimple_code (stmt
), new_rhs_ops
+ 1);
1549 memcpy (new_stmt
, stmt
, gimple_size (gimple_code (stmt
)));
1550 gimple_init_singleton (new_stmt
);
1551 gsi_replace (gsi
, new_stmt
, true);
1554 /* The LHS needs to be reset as this also changes the SSA name
1556 gimple_assign_set_lhs (stmt
, lhs
);
1559 gimple_set_num_ops (stmt
, new_rhs_ops
+ 1);
1560 gimple_set_subcode (stmt
, code
);
1561 gimple_assign_set_rhs1 (stmt
, op1
);
1562 if (new_rhs_ops
> 1)
1563 gimple_assign_set_rhs2 (stmt
, op2
);
1564 if (new_rhs_ops
> 2)
1565 gimple_assign_set_rhs3 (stmt
, op3
);
1569 /* Return the LHS of a statement that performs an assignment,
1570 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1571 for a call to a function that returns no value, or for a
1572 statement other than an assignment or a call. */
1575 gimple_get_lhs (const_gimple stmt
)
1577 enum gimple_code code
= gimple_code (stmt
);
1579 if (code
== GIMPLE_ASSIGN
)
1580 return gimple_assign_lhs (stmt
);
1581 else if (code
== GIMPLE_CALL
)
1582 return gimple_call_lhs (stmt
);
1588 /* Set the LHS of a statement that performs an assignment,
1589 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1592 gimple_set_lhs (gimple stmt
, tree lhs
)
1594 enum gimple_code code
= gimple_code (stmt
);
1596 if (code
== GIMPLE_ASSIGN
)
1597 gimple_assign_set_lhs (stmt
, lhs
);
1598 else if (code
== GIMPLE_CALL
)
1599 gimple_call_set_lhs (stmt
, lhs
);
1605 /* Return a deep copy of statement STMT. All the operands from STMT
1606 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1607 and VUSE operand arrays are set to empty in the new copy. The new
1608 copy isn't part of any sequence. */
1611 gimple_copy (gimple stmt
)
1613 enum gimple_code code
= gimple_code (stmt
);
1614 unsigned num_ops
= gimple_num_ops (stmt
);
1615 gimple copy
= gimple_alloc (code
, num_ops
);
1618 /* Shallow copy all the fields from STMT. */
1619 memcpy (copy
, stmt
, gimple_size (code
));
1620 gimple_init_singleton (copy
);
1622 /* If STMT has sub-statements, deep-copy them as well. */
1623 if (gimple_has_substatements (stmt
))
1628 switch (gimple_code (stmt
))
1631 new_seq
= gimple_seq_copy (gimple_bind_body (stmt
));
1632 gimple_bind_set_body (copy
, new_seq
);
1633 gimple_bind_set_vars (copy
, unshare_expr (gimple_bind_vars (stmt
)));
1634 gimple_bind_set_block (copy
, gimple_bind_block (stmt
));
1638 new_seq
= gimple_seq_copy (gimple_catch_handler (stmt
));
1639 gimple_catch_set_handler (copy
, new_seq
);
1640 t
= unshare_expr (gimple_catch_types (stmt
));
1641 gimple_catch_set_types (copy
, t
);
1644 case GIMPLE_EH_FILTER
:
1645 new_seq
= gimple_seq_copy (gimple_eh_filter_failure (stmt
));
1646 gimple_eh_filter_set_failure (copy
, new_seq
);
1647 t
= unshare_expr (gimple_eh_filter_types (stmt
));
1648 gimple_eh_filter_set_types (copy
, t
);
1651 case GIMPLE_EH_ELSE
:
1652 new_seq
= gimple_seq_copy (gimple_eh_else_n_body (stmt
));
1653 gimple_eh_else_set_n_body (copy
, new_seq
);
1654 new_seq
= gimple_seq_copy (gimple_eh_else_e_body (stmt
));
1655 gimple_eh_else_set_e_body (copy
, new_seq
);
1659 new_seq
= gimple_seq_copy (gimple_try_eval (stmt
));
1660 gimple_try_set_eval (copy
, new_seq
);
1661 new_seq
= gimple_seq_copy (gimple_try_cleanup (stmt
));
1662 gimple_try_set_cleanup (copy
, new_seq
);
1665 case GIMPLE_OMP_FOR
:
1666 new_seq
= gimple_seq_copy (gimple_omp_for_pre_body (stmt
));
1667 gimple_omp_for_set_pre_body (copy
, new_seq
);
1668 t
= unshare_expr (gimple_omp_for_clauses (stmt
));
1669 gimple_omp_for_set_clauses (copy
, t
);
1670 copy
->gimple_omp_for
.iter
1671 = ggc_alloc_vec_gimple_omp_for_iter
1672 (gimple_omp_for_collapse (stmt
));
1673 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1675 gimple_omp_for_set_cond (copy
, i
,
1676 gimple_omp_for_cond (stmt
, i
));
1677 gimple_omp_for_set_index (copy
, i
,
1678 gimple_omp_for_index (stmt
, i
));
1679 t
= unshare_expr (gimple_omp_for_initial (stmt
, i
));
1680 gimple_omp_for_set_initial (copy
, i
, t
);
1681 t
= unshare_expr (gimple_omp_for_final (stmt
, i
));
1682 gimple_omp_for_set_final (copy
, i
, t
);
1683 t
= unshare_expr (gimple_omp_for_incr (stmt
, i
));
1684 gimple_omp_for_set_incr (copy
, i
, t
);
1688 case GIMPLE_OMP_PARALLEL
:
1689 t
= unshare_expr (gimple_omp_parallel_clauses (stmt
));
1690 gimple_omp_parallel_set_clauses (copy
, t
);
1691 t
= unshare_expr (gimple_omp_parallel_child_fn (stmt
));
1692 gimple_omp_parallel_set_child_fn (copy
, t
);
1693 t
= unshare_expr (gimple_omp_parallel_data_arg (stmt
));
1694 gimple_omp_parallel_set_data_arg (copy
, t
);
1697 case GIMPLE_OMP_TASK
:
1698 t
= unshare_expr (gimple_omp_task_clauses (stmt
));
1699 gimple_omp_task_set_clauses (copy
, t
);
1700 t
= unshare_expr (gimple_omp_task_child_fn (stmt
));
1701 gimple_omp_task_set_child_fn (copy
, t
);
1702 t
= unshare_expr (gimple_omp_task_data_arg (stmt
));
1703 gimple_omp_task_set_data_arg (copy
, t
);
1704 t
= unshare_expr (gimple_omp_task_copy_fn (stmt
));
1705 gimple_omp_task_set_copy_fn (copy
, t
);
1706 t
= unshare_expr (gimple_omp_task_arg_size (stmt
));
1707 gimple_omp_task_set_arg_size (copy
, t
);
1708 t
= unshare_expr (gimple_omp_task_arg_align (stmt
));
1709 gimple_omp_task_set_arg_align (copy
, t
);
1712 case GIMPLE_OMP_CRITICAL
:
1713 t
= unshare_expr (gimple_omp_critical_name (stmt
));
1714 gimple_omp_critical_set_name (copy
, t
);
1717 case GIMPLE_OMP_SECTIONS
:
1718 t
= unshare_expr (gimple_omp_sections_clauses (stmt
));
1719 gimple_omp_sections_set_clauses (copy
, t
);
1720 t
= unshare_expr (gimple_omp_sections_control (stmt
));
1721 gimple_omp_sections_set_control (copy
, t
);
1724 case GIMPLE_OMP_SINGLE
:
1725 case GIMPLE_OMP_TARGET
:
1726 case GIMPLE_OMP_TEAMS
:
1727 case GIMPLE_OMP_SECTION
:
1728 case GIMPLE_OMP_MASTER
:
1729 case GIMPLE_OMP_TASKGROUP
:
1730 case GIMPLE_OMP_ORDERED
:
1732 new_seq
= gimple_seq_copy (gimple_omp_body (stmt
));
1733 gimple_omp_set_body (copy
, new_seq
);
1736 case GIMPLE_TRANSACTION
:
1737 new_seq
= gimple_seq_copy (gimple_transaction_body (stmt
));
1738 gimple_transaction_set_body (copy
, new_seq
);
1741 case GIMPLE_WITH_CLEANUP_EXPR
:
1742 new_seq
= gimple_seq_copy (gimple_wce_cleanup (stmt
));
1743 gimple_wce_set_cleanup (copy
, new_seq
);
1751 /* Make copy of operands. */
1752 for (i
= 0; i
< num_ops
; i
++)
1753 gimple_set_op (copy
, i
, unshare_expr (gimple_op (stmt
, i
)));
1755 if (gimple_has_mem_ops (stmt
))
1757 gimple_set_vdef (copy
, gimple_vdef (stmt
));
1758 gimple_set_vuse (copy
, gimple_vuse (stmt
));
1761 /* Clear out SSA operand vectors on COPY. */
1762 if (gimple_has_ops (stmt
))
1764 gimple_set_use_ops (copy
, NULL
);
1766 /* SSA operands need to be updated. */
1767 gimple_set_modified (copy
, true);
1774 /* Return true if statement S has side-effects. We consider a
1775 statement to have side effects if:
1777 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
1778 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
1781 gimple_has_side_effects (const_gimple s
)
1783 if (is_gimple_debug (s
))
1786 /* We don't have to scan the arguments to check for
1787 volatile arguments, though, at present, we still
1788 do a scan to check for TREE_SIDE_EFFECTS. */
1789 if (gimple_has_volatile_ops (s
))
1792 if (gimple_code (s
) == GIMPLE_ASM
1793 && gimple_asm_volatile_p (s
))
1796 if (is_gimple_call (s
))
1798 int flags
= gimple_call_flags (s
);
1800 /* An infinite loop is considered a side effect. */
1801 if (!(flags
& (ECF_CONST
| ECF_PURE
))
1802 || (flags
& ECF_LOOPING_CONST_OR_PURE
))
1811 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
1812 Return true if S can trap. When INCLUDE_MEM is true, check whether
1813 the memory operations could trap. When INCLUDE_STORES is true and
1814 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
1817 gimple_could_trap_p_1 (gimple s
, bool include_mem
, bool include_stores
)
1819 tree t
, div
= NULL_TREE
;
1824 unsigned i
, start
= (is_gimple_assign (s
) && !include_stores
) ? 1 : 0;
1826 for (i
= start
; i
< gimple_num_ops (s
); i
++)
1827 if (tree_could_trap_p (gimple_op (s
, i
)))
1831 switch (gimple_code (s
))
1834 return gimple_asm_volatile_p (s
);
1837 t
= gimple_call_fndecl (s
);
1838 /* Assume that calls to weak functions may trap. */
1839 if (!t
|| !DECL_P (t
) || DECL_WEAK (t
))
1844 t
= gimple_expr_type (s
);
1845 op
= gimple_assign_rhs_code (s
);
1846 if (get_gimple_rhs_class (op
) == GIMPLE_BINARY_RHS
)
1847 div
= gimple_assign_rhs2 (s
);
1848 return (operation_could_trap_p (op
, FLOAT_TYPE_P (t
),
1849 (INTEGRAL_TYPE_P (t
)
1850 && TYPE_OVERFLOW_TRAPS (t
)),
1860 /* Return true if statement S can trap. */
1863 gimple_could_trap_p (gimple s
)
1865 return gimple_could_trap_p_1 (s
, true, true);
1868 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
1871 gimple_assign_rhs_could_trap_p (gimple s
)
1873 gcc_assert (is_gimple_assign (s
));
1874 return gimple_could_trap_p_1 (s
, true, false);
1878 /* Print debugging information for gimple stmts generated. */
1881 dump_gimple_statistics (void)
1883 int i
, total_tuples
= 0, total_bytes
= 0;
1885 if (! GATHER_STATISTICS
)
1887 fprintf (stderr
, "No gimple statistics\n");
1891 fprintf (stderr
, "\nGIMPLE statements\n");
1892 fprintf (stderr
, "Kind Stmts Bytes\n");
1893 fprintf (stderr
, "---------------------------------------\n");
1894 for (i
= 0; i
< (int) gimple_alloc_kind_all
; ++i
)
1896 fprintf (stderr
, "%-20s %7d %10d\n", gimple_alloc_kind_names
[i
],
1897 gimple_alloc_counts
[i
], gimple_alloc_sizes
[i
]);
1898 total_tuples
+= gimple_alloc_counts
[i
];
1899 total_bytes
+= gimple_alloc_sizes
[i
];
1901 fprintf (stderr
, "---------------------------------------\n");
1902 fprintf (stderr
, "%-20s %7d %10d\n", "Total", total_tuples
, total_bytes
);
1903 fprintf (stderr
, "---------------------------------------\n");
1907 /* Return the number of operands needed on the RHS of a GIMPLE
1908 assignment for an expression with tree code CODE. */
1911 get_gimple_rhs_num_ops (enum tree_code code
)
1913 enum gimple_rhs_class rhs_class
= get_gimple_rhs_class (code
);
1915 if (rhs_class
== GIMPLE_UNARY_RHS
|| rhs_class
== GIMPLE_SINGLE_RHS
)
1917 else if (rhs_class
== GIMPLE_BINARY_RHS
)
1919 else if (rhs_class
== GIMPLE_TERNARY_RHS
)
1925 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
1927 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
1928 : ((TYPE) == tcc_binary \
1929 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
1930 : ((TYPE) == tcc_constant \
1931 || (TYPE) == tcc_declaration \
1932 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
1933 : ((SYM) == TRUTH_AND_EXPR \
1934 || (SYM) == TRUTH_OR_EXPR \
1935 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
1936 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
1937 : ((SYM) == COND_EXPR \
1938 || (SYM) == WIDEN_MULT_PLUS_EXPR \
1939 || (SYM) == WIDEN_MULT_MINUS_EXPR \
1940 || (SYM) == DOT_PROD_EXPR \
1941 || (SYM) == REALIGN_LOAD_EXPR \
1942 || (SYM) == VEC_COND_EXPR \
1943 || (SYM) == VEC_PERM_EXPR \
1944 || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS \
1945 : ((SYM) == CONSTRUCTOR \
1946 || (SYM) == OBJ_TYPE_REF \
1947 || (SYM) == ASSERT_EXPR \
1948 || (SYM) == ADDR_EXPR \
1949 || (SYM) == WITH_SIZE_EXPR \
1950 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
1951 : GIMPLE_INVALID_RHS),
1952 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
1954 const unsigned char gimple_rhs_class_table
[] = {
1955 #include "all-tree.def"
1959 #undef END_OF_BASE_TREE_CODES
1961 /* Given a memory reference expression T, return its base address.
1962 The base address of a memory reference expression is the main
1963 object being referenced. For instance, the base address for
1964 'array[i].fld[j]' is 'array'. You can think of this as stripping
1965 away the offset part from a memory address.
1967 This function calls handled_component_p to strip away all the inner
1968 parts of the memory reference until it reaches the base object. */
1971 get_base_address (tree t
)
1973 while (handled_component_p (t
))
1974 t
= TREE_OPERAND (t
, 0);
1976 if ((TREE_CODE (t
) == MEM_REF
1977 || TREE_CODE (t
) == TARGET_MEM_REF
)
1978 && TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
)
1979 t
= TREE_OPERAND (TREE_OPERAND (t
, 0), 0);
1981 /* ??? Either the alias oracle or all callers need to properly deal
1982 with WITH_SIZE_EXPRs before we can look through those. */
1983 if (TREE_CODE (t
) == WITH_SIZE_EXPR
)
1990 recalculate_side_effects (tree t
)
1992 enum tree_code code
= TREE_CODE (t
);
1993 int len
= TREE_OPERAND_LENGTH (t
);
1996 switch (TREE_CODE_CLASS (code
))
1998 case tcc_expression
:
2004 case PREDECREMENT_EXPR
:
2005 case PREINCREMENT_EXPR
:
2006 case POSTDECREMENT_EXPR
:
2007 case POSTINCREMENT_EXPR
:
2008 /* All of these have side-effects, no matter what their
2017 case tcc_comparison
: /* a comparison expression */
2018 case tcc_unary
: /* a unary arithmetic expression */
2019 case tcc_binary
: /* a binary arithmetic expression */
2020 case tcc_reference
: /* a reference */
2021 case tcc_vl_exp
: /* a function call */
2022 TREE_SIDE_EFFECTS (t
) = TREE_THIS_VOLATILE (t
);
2023 for (i
= 0; i
< len
; ++i
)
2025 tree op
= TREE_OPERAND (t
, i
);
2026 if (op
&& TREE_SIDE_EFFECTS (op
))
2027 TREE_SIDE_EFFECTS (t
) = 1;
2032 /* No side-effects. */
2040 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2041 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2042 we failed to create one. */
2045 canonicalize_cond_expr_cond (tree t
)
2047 /* Strip conversions around boolean operations. */
2048 if (CONVERT_EXPR_P (t
)
2049 && (truth_value_p (TREE_CODE (TREE_OPERAND (t
, 0)))
2050 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
2052 t
= TREE_OPERAND (t
, 0);
2054 /* For !x use x == 0. */
2055 if (TREE_CODE (t
) == TRUTH_NOT_EXPR
)
2057 tree top0
= TREE_OPERAND (t
, 0);
2058 t
= build2 (EQ_EXPR
, TREE_TYPE (t
),
2059 top0
, build_int_cst (TREE_TYPE (top0
), 0));
2061 /* For cmp ? 1 : 0 use cmp. */
2062 else if (TREE_CODE (t
) == COND_EXPR
2063 && COMPARISON_CLASS_P (TREE_OPERAND (t
, 0))
2064 && integer_onep (TREE_OPERAND (t
, 1))
2065 && integer_zerop (TREE_OPERAND (t
, 2)))
2067 tree top0
= TREE_OPERAND (t
, 0);
2068 t
= build2 (TREE_CODE (top0
), TREE_TYPE (t
),
2069 TREE_OPERAND (top0
, 0), TREE_OPERAND (top0
, 1));
2071 /* For x ^ y use x != y. */
2072 else if (TREE_CODE (t
) == BIT_XOR_EXPR
)
2073 t
= build2 (NE_EXPR
, TREE_TYPE (t
),
2074 TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1));
2076 if (is_gimple_condexpr (t
))
2082 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2083 the positions marked by the set ARGS_TO_SKIP. */
2086 gimple_call_copy_skip_args (gimple stmt
, bitmap args_to_skip
)
2089 int nargs
= gimple_call_num_args (stmt
);
2091 vargs
.create (nargs
);
2094 for (i
= 0; i
< nargs
; i
++)
2095 if (!bitmap_bit_p (args_to_skip
, i
))
2096 vargs
.quick_push (gimple_call_arg (stmt
, i
));
2098 if (gimple_call_internal_p (stmt
))
2099 new_stmt
= gimple_build_call_internal_vec (gimple_call_internal_fn (stmt
),
2102 new_stmt
= gimple_build_call_vec (gimple_call_fn (stmt
), vargs
);
2104 if (gimple_call_lhs (stmt
))
2105 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2107 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2108 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
2110 if (gimple_has_location (stmt
))
2111 gimple_set_location (new_stmt
, gimple_location (stmt
));
2112 gimple_call_copy_flags (new_stmt
, stmt
);
2113 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2115 gimple_set_modified (new_stmt
, true);
2122 /* Return true if the field decls F1 and F2 are at the same offset.
2124 This is intended to be used on GIMPLE types only. */
2127 gimple_compare_field_offset (tree f1
, tree f2
)
2129 if (DECL_OFFSET_ALIGN (f1
) == DECL_OFFSET_ALIGN (f2
))
2131 tree offset1
= DECL_FIELD_OFFSET (f1
);
2132 tree offset2
= DECL_FIELD_OFFSET (f2
);
2133 return ((offset1
== offset2
2134 /* Once gimplification is done, self-referential offsets are
2135 instantiated as operand #2 of the COMPONENT_REF built for
2136 each access and reset. Therefore, they are not relevant
2137 anymore and fields are interchangeable provided that they
2138 represent the same access. */
2139 || (TREE_CODE (offset1
) == PLACEHOLDER_EXPR
2140 && TREE_CODE (offset2
) == PLACEHOLDER_EXPR
2141 && (DECL_SIZE (f1
) == DECL_SIZE (f2
)
2142 || (TREE_CODE (DECL_SIZE (f1
)) == PLACEHOLDER_EXPR
2143 && TREE_CODE (DECL_SIZE (f2
)) == PLACEHOLDER_EXPR
)
2144 || operand_equal_p (DECL_SIZE (f1
), DECL_SIZE (f2
), 0))
2145 && DECL_ALIGN (f1
) == DECL_ALIGN (f2
))
2146 || operand_equal_p (offset1
, offset2
, 0))
2147 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1
),
2148 DECL_FIELD_BIT_OFFSET (f2
)));
2151 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2152 should be, so handle differing ones specially by decomposing
2153 the offset into a byte and bit offset manually. */
2154 if (host_integerp (DECL_FIELD_OFFSET (f1
), 0)
2155 && host_integerp (DECL_FIELD_OFFSET (f2
), 0))
2157 unsigned HOST_WIDE_INT byte_offset1
, byte_offset2
;
2158 unsigned HOST_WIDE_INT bit_offset1
, bit_offset2
;
2159 bit_offset1
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1
));
2160 byte_offset1
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1
))
2161 + bit_offset1
/ BITS_PER_UNIT
);
2162 bit_offset2
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2
));
2163 byte_offset2
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2
))
2164 + bit_offset2
/ BITS_PER_UNIT
);
2165 if (byte_offset1
!= byte_offset2
)
2167 return bit_offset1
% BITS_PER_UNIT
== bit_offset2
% BITS_PER_UNIT
;
2174 /* Return a type the same as TYPE except unsigned or
2175 signed according to UNSIGNEDP. */
2178 gimple_signed_or_unsigned_type (bool unsignedp
, tree type
)
2182 type1
= TYPE_MAIN_VARIANT (type
);
2183 if (type1
== signed_char_type_node
2184 || type1
== char_type_node
2185 || type1
== unsigned_char_type_node
)
2186 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2187 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2188 return unsignedp
? unsigned_type_node
: integer_type_node
;
2189 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2190 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2191 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2192 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2193 if (type1
== long_long_integer_type_node
2194 || type1
== long_long_unsigned_type_node
)
2196 ? long_long_unsigned_type_node
2197 : long_long_integer_type_node
;
2198 if (int128_integer_type_node
&& (type1
== int128_integer_type_node
|| type1
== int128_unsigned_type_node
))
2200 ? int128_unsigned_type_node
2201 : int128_integer_type_node
;
2202 #if HOST_BITS_PER_WIDE_INT >= 64
2203 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2204 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2206 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2207 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2208 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2209 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2210 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2211 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2212 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2213 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2215 #define GIMPLE_FIXED_TYPES(NAME) \
2216 if (type1 == short_ ## NAME ## _type_node \
2217 || type1 == unsigned_short_ ## NAME ## _type_node) \
2218 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2219 : short_ ## NAME ## _type_node; \
2220 if (type1 == NAME ## _type_node \
2221 || type1 == unsigned_ ## NAME ## _type_node) \
2222 return unsignedp ? unsigned_ ## NAME ## _type_node \
2223 : NAME ## _type_node; \
2224 if (type1 == long_ ## NAME ## _type_node \
2225 || type1 == unsigned_long_ ## NAME ## _type_node) \
2226 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2227 : long_ ## NAME ## _type_node; \
2228 if (type1 == long_long_ ## NAME ## _type_node \
2229 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2230 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2231 : long_long_ ## NAME ## _type_node;
2233 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2234 if (type1 == NAME ## _type_node \
2235 || type1 == u ## NAME ## _type_node) \
2236 return unsignedp ? u ## NAME ## _type_node \
2237 : NAME ## _type_node;
2239 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2240 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2241 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2242 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2243 : sat_ ## short_ ## NAME ## _type_node; \
2244 if (type1 == sat_ ## NAME ## _type_node \
2245 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2246 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2247 : sat_ ## NAME ## _type_node; \
2248 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2249 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2250 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2251 : sat_ ## long_ ## NAME ## _type_node; \
2252 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2253 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2254 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2255 : sat_ ## long_long_ ## NAME ## _type_node;
2257 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2258 if (type1 == sat_ ## NAME ## _type_node \
2259 || type1 == sat_ ## u ## NAME ## _type_node) \
2260 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2261 : sat_ ## NAME ## _type_node;
2263 GIMPLE_FIXED_TYPES (fract
);
2264 GIMPLE_FIXED_TYPES_SAT (fract
);
2265 GIMPLE_FIXED_TYPES (accum
);
2266 GIMPLE_FIXED_TYPES_SAT (accum
);
2268 GIMPLE_FIXED_MODE_TYPES (qq
);
2269 GIMPLE_FIXED_MODE_TYPES (hq
);
2270 GIMPLE_FIXED_MODE_TYPES (sq
);
2271 GIMPLE_FIXED_MODE_TYPES (dq
);
2272 GIMPLE_FIXED_MODE_TYPES (tq
);
2273 GIMPLE_FIXED_MODE_TYPES_SAT (qq
);
2274 GIMPLE_FIXED_MODE_TYPES_SAT (hq
);
2275 GIMPLE_FIXED_MODE_TYPES_SAT (sq
);
2276 GIMPLE_FIXED_MODE_TYPES_SAT (dq
);
2277 GIMPLE_FIXED_MODE_TYPES_SAT (tq
);
2278 GIMPLE_FIXED_MODE_TYPES (ha
);
2279 GIMPLE_FIXED_MODE_TYPES (sa
);
2280 GIMPLE_FIXED_MODE_TYPES (da
);
2281 GIMPLE_FIXED_MODE_TYPES (ta
);
2282 GIMPLE_FIXED_MODE_TYPES_SAT (ha
);
2283 GIMPLE_FIXED_MODE_TYPES_SAT (sa
);
2284 GIMPLE_FIXED_MODE_TYPES_SAT (da
);
2285 GIMPLE_FIXED_MODE_TYPES_SAT (ta
);
2287 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2288 the precision; they have precision set to match their range, but
2289 may use a wider mode to match an ABI. If we change modes, we may
2290 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2291 the precision as well, so as to yield correct results for
2292 bit-field types. C++ does not have these separate bit-field
2293 types, and producing a signed or unsigned variant of an
2294 ENUMERAL_TYPE may cause other problems as well. */
2295 if (!INTEGRAL_TYPE_P (type
)
2296 || TYPE_UNSIGNED (type
) == unsignedp
)
2299 #define TYPE_OK(node) \
2300 (TYPE_MODE (type) == TYPE_MODE (node) \
2301 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2302 if (TYPE_OK (signed_char_type_node
))
2303 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2304 if (TYPE_OK (integer_type_node
))
2305 return unsignedp
? unsigned_type_node
: integer_type_node
;
2306 if (TYPE_OK (short_integer_type_node
))
2307 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2308 if (TYPE_OK (long_integer_type_node
))
2309 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2310 if (TYPE_OK (long_long_integer_type_node
))
2312 ? long_long_unsigned_type_node
2313 : long_long_integer_type_node
);
2314 if (int128_integer_type_node
&& TYPE_OK (int128_integer_type_node
))
2316 ? int128_unsigned_type_node
2317 : int128_integer_type_node
);
2319 #if HOST_BITS_PER_WIDE_INT >= 64
2320 if (TYPE_OK (intTI_type_node
))
2321 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2323 if (TYPE_OK (intDI_type_node
))
2324 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2325 if (TYPE_OK (intSI_type_node
))
2326 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2327 if (TYPE_OK (intHI_type_node
))
2328 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2329 if (TYPE_OK (intQI_type_node
))
2330 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2332 #undef GIMPLE_FIXED_TYPES
2333 #undef GIMPLE_FIXED_MODE_TYPES
2334 #undef GIMPLE_FIXED_TYPES_SAT
2335 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2338 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2342 /* Return an unsigned type the same as TYPE in other respects. */
2345 gimple_unsigned_type (tree type
)
2347 return gimple_signed_or_unsigned_type (true, type
);
2351 /* Return a signed type the same as TYPE in other respects. */
2354 gimple_signed_type (tree type
)
2356 return gimple_signed_or_unsigned_type (false, type
);
2360 /* Return the typed-based alias set for T, which may be an expression
2361 or a type. Return -1 if we don't do anything special. */
2364 gimple_get_alias_set (tree t
)
2368 /* Permit type-punning when accessing a union, provided the access
2369 is directly through the union. For example, this code does not
2370 permit taking the address of a union member and then storing
2371 through it. Even the type-punning allowed here is a GCC
2372 extension, albeit a common and useful one; the C standard says
2373 that such accesses have implementation-defined behavior. */
2375 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2376 u
= TREE_OPERAND (u
, 0))
2377 if (TREE_CODE (u
) == COMPONENT_REF
2378 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2381 /* That's all the expressions we handle specially. */
2385 /* For convenience, follow the C standard when dealing with
2386 character types. Any object may be accessed via an lvalue that
2387 has character type. */
2388 if (t
== char_type_node
2389 || t
== signed_char_type_node
2390 || t
== unsigned_char_type_node
)
2393 /* Allow aliasing between signed and unsigned variants of the same
2394 type. We treat the signed variant as canonical. */
2395 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2397 tree t1
= gimple_signed_type (t
);
2399 /* t1 == t can happen for boolean nodes which are always unsigned. */
2401 return get_alias_set (t1
);
2408 /* Helper for gimple_ior_addresses_taken_1. */
2411 gimple_ior_addresses_taken_1 (gimple stmt ATTRIBUTE_UNUSED
,
2412 tree addr
, void *data
)
2414 bitmap addresses_taken
= (bitmap
)data
;
2415 addr
= get_base_address (addr
);
2419 bitmap_set_bit (addresses_taken
, DECL_UID (addr
));
2425 /* Set the bit for the uid of all decls that have their address taken
2426 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2427 were any in this stmt. */
2430 gimple_ior_addresses_taken (bitmap addresses_taken
, gimple stmt
)
2432 return walk_stmt_load_store_addr_ops (stmt
, addresses_taken
, NULL
, NULL
,
2433 gimple_ior_addresses_taken_1
);
2437 /* Return TRUE iff stmt is a call to a built-in function. */
2440 is_gimple_builtin_call (gimple stmt
)
2444 if (is_gimple_call (stmt
)
2445 && (callee
= gimple_call_fndecl (stmt
))
2446 && is_builtin_fn (callee
)
2447 && DECL_BUILT_IN_CLASS (callee
) == BUILT_IN_NORMAL
)
2453 /* Return true when STMTs arguments match those of FNDECL. */
2456 validate_call (gimple stmt
, tree fndecl
)
2458 tree targs
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2459 unsigned nargs
= gimple_call_num_args (stmt
);
2460 for (unsigned i
= 0; i
< nargs
; ++i
)
2462 /* Variadic args follow. */
2465 tree arg
= gimple_call_arg (stmt
, i
);
2466 if (INTEGRAL_TYPE_P (TREE_TYPE (arg
))
2467 && INTEGRAL_TYPE_P (TREE_VALUE (targs
)))
2469 else if (POINTER_TYPE_P (TREE_TYPE (arg
))
2470 && POINTER_TYPE_P (TREE_VALUE (targs
)))
2472 else if (TREE_CODE (TREE_TYPE (arg
))
2473 != TREE_CODE (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 to CLASS. */
2485 gimple_call_builtin_p (gimple stmt
, enum built_in_class klass
)
2488 if (is_gimple_call (stmt
)
2489 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2490 && DECL_BUILT_IN_CLASS (fndecl
) == klass
)
2491 return validate_call (stmt
, fndecl
);
2495 /* Return true when STMT is builtins call to CODE of CLASS. */
2498 gimple_call_builtin_p (gimple stmt
, enum built_in_function code
)
2501 if (is_gimple_call (stmt
)
2502 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2503 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
2504 && DECL_FUNCTION_CODE (fndecl
) == code
)
2505 return validate_call (stmt
, fndecl
);
2509 /* Return true if STMT clobbers memory. STMT is required to be a
2513 gimple_asm_clobbers_memory_p (const_gimple stmt
)
2517 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
2519 tree op
= gimple_asm_clobber_op (stmt
, i
);
2520 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op
)), "memory") == 0)
2527 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2530 dump_decl_set (FILE *file
, bitmap set
)
2537 fprintf (file
, "{ ");
2539 EXECUTE_IF_SET_IN_BITMAP (set
, 0, i
, bi
)
2541 fprintf (file
, "D.%u", i
);
2542 fprintf (file
, " ");
2545 fprintf (file
, "}");
2548 fprintf (file
, "NIL");
2551 /* Return true when CALL is a call stmt that definitely doesn't
2552 free any memory or makes it unavailable otherwise. */
2554 nonfreeing_call_p (gimple call
)
2556 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2557 && gimple_call_flags (call
) & ECF_LEAF
)
2558 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call
)))
2560 /* Just in case these become ECF_LEAF in the future. */
2562 case BUILT_IN_TM_FREE
:
2563 case BUILT_IN_REALLOC
:
2564 case BUILT_IN_STACK_RESTORE
:
2573 /* Callback for walk_stmt_load_store_ops.
2575 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2578 This routine only makes a superficial check for a dereference. Thus
2579 it must only be used if it is safe to return a false negative. */
2581 check_loadstore (gimple stmt ATTRIBUTE_UNUSED
, tree op
, void *data
)
2583 if ((TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
2584 && operand_equal_p (TREE_OPERAND (op
, 0), (tree
)data
, 0))
2589 /* If OP can be inferred to be non-zero after STMT executes, return true. */
2592 infer_nonnull_range (gimple stmt
, tree op
)
2594 /* We can only assume that a pointer dereference will yield
2595 non-NULL if -fdelete-null-pointer-checks is enabled. */
2596 if (!flag_delete_null_pointer_checks
2597 || !POINTER_TYPE_P (TREE_TYPE (op
))
2598 || gimple_code (stmt
) == GIMPLE_ASM
)
2601 if (walk_stmt_load_store_ops (stmt
, (void *)op
,
2602 check_loadstore
, check_loadstore
))
2605 if (is_gimple_call (stmt
) && !gimple_call_internal_p (stmt
))
2607 tree fntype
= gimple_call_fntype (stmt
);
2608 tree attrs
= TYPE_ATTRIBUTES (fntype
);
2609 for (; attrs
; attrs
= TREE_CHAIN (attrs
))
2611 attrs
= lookup_attribute ("nonnull", attrs
);
2613 /* If "nonnull" wasn't specified, we know nothing about
2615 if (attrs
== NULL_TREE
)
2618 /* If "nonnull" applies to all the arguments, then ARG
2619 is non-null if it's in the argument list. */
2620 if (TREE_VALUE (attrs
) == NULL_TREE
)
2622 for (unsigned int i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2624 if (operand_equal_p (op
, gimple_call_arg (stmt
, i
), 0)
2625 && POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt
, i
))))
2631 /* Now see if op appears in the nonnull list. */
2632 for (tree t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
2634 int idx
= TREE_INT_CST_LOW (TREE_VALUE (t
)) - 1;
2635 tree arg
= gimple_call_arg (stmt
, idx
);
2636 if (operand_equal_p (op
, arg
, 0))
2642 /* If this function is marked as returning non-null, then we can
2643 infer OP is non-null if it is used in the return statement. */
2644 if (gimple_code (stmt
) == GIMPLE_RETURN
2645 && gimple_return_retval (stmt
)
2646 && operand_equal_p (gimple_return_retval (stmt
), op
, 0)
2647 && lookup_attribute ("returns_nonnull",
2648 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
))))
2654 /* Compare two case labels. Because the front end should already have
2655 made sure that case ranges do not overlap, it is enough to only compare
2656 the CASE_LOW values of each case label. */
2659 compare_case_labels (const void *p1
, const void *p2
)
2661 const_tree
const case1
= *(const_tree
const*)p1
;
2662 const_tree
const case2
= *(const_tree
const*)p2
;
2664 /* The 'default' case label always goes first. */
2665 if (!CASE_LOW (case1
))
2667 else if (!CASE_LOW (case2
))
2670 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
2673 /* Sort the case labels in LABEL_VEC in place in ascending order. */
2676 sort_case_labels (vec
<tree
> label_vec
)
2678 label_vec
.qsort (compare_case_labels
);
2681 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2683 LABELS is a vector that contains all case labels to look at.
2685 INDEX_TYPE is the type of the switch index expression. Case labels
2686 in LABELS are discarded if their values are not in the value range
2687 covered by INDEX_TYPE. The remaining case label values are folded
2690 If a default case exists in LABELS, it is removed from LABELS and
2691 returned in DEFAULT_CASEP. If no default case exists, but the
2692 case labels already cover the whole range of INDEX_TYPE, a default
2693 case is returned pointing to one of the existing case labels.
2694 Otherwise DEFAULT_CASEP is set to NULL_TREE.
2696 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2697 apply and no action is taken regardless of whether a default case is
2701 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
2703 tree
*default_casep
)
2705 tree min_value
, max_value
;
2706 tree default_case
= NULL_TREE
;
2710 min_value
= TYPE_MIN_VALUE (index_type
);
2711 max_value
= TYPE_MAX_VALUE (index_type
);
2712 while (i
< labels
.length ())
2714 tree elt
= labels
[i
];
2715 tree low
= CASE_LOW (elt
);
2716 tree high
= CASE_HIGH (elt
);
2717 bool remove_element
= FALSE
;
2721 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
2722 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
2724 /* This is a non-default case label, i.e. it has a value.
2726 See if the case label is reachable within the range of
2727 the index type. Remove out-of-range case values. Turn
2728 case ranges into a canonical form (high > low strictly)
2729 and convert the case label values to the index type.
2731 NB: The type of gimple_switch_index() may be the promoted
2732 type, but the case labels retain the original type. */
2736 /* This is a case range. Discard empty ranges.
2737 If the bounds or the range are equal, turn this
2738 into a simple (one-value) case. */
2739 int cmp
= tree_int_cst_compare (high
, low
);
2741 remove_element
= TRUE
;
2748 /* If the simple case value is unreachable, ignore it. */
2749 if ((TREE_CODE (min_value
) == INTEGER_CST
2750 && tree_int_cst_compare (low
, min_value
) < 0)
2751 || (TREE_CODE (max_value
) == INTEGER_CST
2752 && tree_int_cst_compare (low
, max_value
) > 0))
2753 remove_element
= TRUE
;
2755 low
= fold_convert (index_type
, low
);
2759 /* If the entire case range is unreachable, ignore it. */
2760 if ((TREE_CODE (min_value
) == INTEGER_CST
2761 && tree_int_cst_compare (high
, min_value
) < 0)
2762 || (TREE_CODE (max_value
) == INTEGER_CST
2763 && tree_int_cst_compare (low
, max_value
) > 0))
2764 remove_element
= TRUE
;
2767 /* If the lower bound is less than the index type's
2768 minimum value, truncate the range bounds. */
2769 if (TREE_CODE (min_value
) == INTEGER_CST
2770 && tree_int_cst_compare (low
, min_value
) < 0)
2772 low
= fold_convert (index_type
, low
);
2774 /* If the upper bound is greater than the index type's
2775 maximum value, truncate the range bounds. */
2776 if (TREE_CODE (max_value
) == INTEGER_CST
2777 && tree_int_cst_compare (high
, max_value
) > 0)
2779 high
= fold_convert (index_type
, high
);
2781 /* We may have folded a case range to a one-value case. */
2782 if (tree_int_cst_equal (low
, high
))
2787 CASE_LOW (elt
) = low
;
2788 CASE_HIGH (elt
) = high
;
2792 gcc_assert (!default_case
);
2794 /* The default case must be passed separately to the
2795 gimple_build_switch routine. But if DEFAULT_CASEP
2796 is NULL, we do not remove the default case (it would
2797 be completely lost). */
2799 remove_element
= TRUE
;
2803 labels
.ordered_remove (i
);
2809 if (!labels
.is_empty ())
2810 sort_case_labels (labels
);
2812 if (default_casep
&& !default_case
)
2814 /* If the switch has no default label, add one, so that we jump
2815 around the switch body. If the labels already cover the whole
2816 range of the switch index_type, add the default label pointing
2817 to one of the existing labels. */
2819 && TYPE_MIN_VALUE (index_type
)
2820 && TYPE_MAX_VALUE (index_type
)
2821 && tree_int_cst_equal (CASE_LOW (labels
[0]),
2822 TYPE_MIN_VALUE (index_type
)))
2824 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
2826 high
= CASE_LOW (labels
[len
- 1]);
2827 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
2829 for (i
= 1; i
< len
; i
++)
2831 high
= CASE_LOW (labels
[i
]);
2832 low
= CASE_HIGH (labels
[i
- 1]);
2834 low
= CASE_LOW (labels
[i
- 1]);
2835 if ((TREE_INT_CST_LOW (low
) + 1
2836 != TREE_INT_CST_LOW (high
))
2837 || (TREE_INT_CST_HIGH (low
)
2838 + (TREE_INT_CST_LOW (high
) == 0)
2839 != TREE_INT_CST_HIGH (high
)))
2844 tree label
= CASE_LABEL (labels
[0]);
2845 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
2853 *default_casep
= default_case
;
2856 /* Set the location of all statements in SEQ to LOC. */
2859 gimple_seq_set_location (gimple_seq seq
, location_t loc
)
2861 for (gimple_stmt_iterator i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
2862 gimple_set_location (gsi_stmt (i
), loc
);