1 /* Gimple IR support functions.
3 Copyright (C) 2007-2019 Free Software Foundation, Inc.
4 Contributed by Aldy Hernandez <aldyh@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
30 #include "diagnostic.h"
32 #include "fold-const.h"
34 #include "stor-layout.h"
35 #include "internal-fn.h"
37 #include "gimple-iterator.h"
38 #include "gimple-walk.h"
43 #include "gimple-pretty-print.h"
44 #include "stringpool.h"
49 /* All the tuples have their operand vector (if present) at the very bottom
50 of the structure. Therefore, the offset required to find the
51 operands vector the size of the structure minus the size of the 1
52 element tree array at the end (see gimple_ops). */
53 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
54 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
55 EXPORTED_CONST
size_t gimple_ops_offset_
[] = {
56 #include "gsstruct.def"
60 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
61 static const size_t gsstruct_code_size
[] = {
62 #include "gsstruct.def"
66 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
67 const char *const gimple_code_name
[] = {
72 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
73 EXPORTED_CONST
enum gimple_statement_structure_enum gss_for_code_
[] = {
80 uint64_t gimple_alloc_counts
[(int) gimple_alloc_kind_all
];
81 uint64_t gimple_alloc_sizes
[(int) gimple_alloc_kind_all
];
83 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
84 static const char * const gimple_alloc_kind_names
[] = {
91 /* Static gimple tuple members. */
92 const enum gimple_code
gassign::code_
;
93 const enum gimple_code
gcall::code_
;
94 const enum gimple_code
gcond::code_
;
97 /* Gimple tuple constructors.
98 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
99 be passed a NULL to start with an empty sequence. */
101 /* Set the code for statement G to CODE. */
104 gimple_set_code (gimple
*g
, enum gimple_code code
)
109 /* Return the number of bytes needed to hold a GIMPLE statement with
113 gimple_size (enum gimple_code code
)
115 return gsstruct_code_size
[gss_for_code (code
)];
118 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
122 gimple_alloc (enum gimple_code code
, unsigned num_ops MEM_STAT_DECL
)
127 size
= gimple_size (code
);
129 size
+= sizeof (tree
) * (num_ops
- 1);
131 if (GATHER_STATISTICS
)
133 enum gimple_alloc_kind kind
= gimple_alloc_kind (code
);
134 gimple_alloc_counts
[(int) kind
]++;
135 gimple_alloc_sizes
[(int) kind
] += size
;
138 stmt
= ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT
);
139 gimple_set_code (stmt
, code
);
140 gimple_set_num_ops (stmt
, num_ops
);
142 /* Do not call gimple_set_modified here as it has other side
143 effects and this tuple is still not completely built. */
145 gimple_init_singleton (stmt
);
150 /* Set SUBCODE to be the code of the expression computed by statement G. */
153 gimple_set_subcode (gimple
*g
, unsigned subcode
)
155 /* We only have 16 bits for the RHS code. Assert that we are not
157 gcc_assert (subcode
< (1 << 16));
158 g
->subcode
= subcode
;
163 /* Build a tuple with operands. CODE is the statement to build (which
164 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
165 for the new tuple. NUM_OPS is the number of operands to allocate. */
167 #define gimple_build_with_ops(c, s, n) \
168 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
171 gimple_build_with_ops_stat (enum gimple_code code
, unsigned subcode
,
172 unsigned num_ops MEM_STAT_DECL
)
174 gimple
*s
= gimple_alloc (code
, num_ops PASS_MEM_STAT
);
175 gimple_set_subcode (s
, subcode
);
181 /* Build a GIMPLE_RETURN statement returning RETVAL. */
184 gimple_build_return (tree retval
)
187 = as_a
<greturn
*> (gimple_build_with_ops (GIMPLE_RETURN
, ERROR_MARK
,
190 gimple_return_set_retval (s
, retval
);
194 /* Reset alias information on call S. */
197 gimple_call_reset_alias_info (gcall
*s
)
199 if (gimple_call_flags (s
) & ECF_CONST
)
200 memset (gimple_call_use_set (s
), 0, sizeof (struct pt_solution
));
202 pt_solution_reset (gimple_call_use_set (s
));
203 if (gimple_call_flags (s
) & (ECF_CONST
|ECF_PURE
|ECF_NOVOPS
))
204 memset (gimple_call_clobber_set (s
), 0, sizeof (struct pt_solution
));
206 pt_solution_reset (gimple_call_clobber_set (s
));
209 /* Helper for gimple_build_call, gimple_build_call_valist,
210 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
211 components of a GIMPLE_CALL statement to function FN with NARGS
214 static inline gcall
*
215 gimple_build_call_1 (tree fn
, unsigned nargs
)
218 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
220 if (TREE_CODE (fn
) == FUNCTION_DECL
)
221 fn
= build_fold_addr_expr (fn
);
222 gimple_set_op (s
, 1, fn
);
223 gimple_call_set_fntype (s
, TREE_TYPE (TREE_TYPE (fn
)));
224 gimple_call_reset_alias_info (s
);
229 /* Build a GIMPLE_CALL statement to function FN with the arguments
230 specified in vector ARGS. */
233 gimple_build_call_vec (tree fn
, vec
<tree
> args
)
236 unsigned nargs
= args
.length ();
237 gcall
*call
= gimple_build_call_1 (fn
, nargs
);
239 for (i
= 0; i
< nargs
; i
++)
240 gimple_call_set_arg (call
, i
, args
[i
]);
246 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
247 arguments. The ... are the arguments. */
250 gimple_build_call (tree fn
, unsigned nargs
, ...)
256 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
258 call
= gimple_build_call_1 (fn
, nargs
);
260 va_start (ap
, nargs
);
261 for (i
= 0; i
< nargs
; i
++)
262 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
269 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
270 arguments. AP contains the arguments. */
273 gimple_build_call_valist (tree fn
, unsigned nargs
, va_list ap
)
278 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
280 call
= gimple_build_call_1 (fn
, nargs
);
282 for (i
= 0; i
< nargs
; i
++)
283 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
289 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
290 Build the basic components of a GIMPLE_CALL statement to internal
291 function FN with NARGS arguments. */
293 static inline gcall
*
294 gimple_build_call_internal_1 (enum internal_fn fn
, unsigned nargs
)
297 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
299 s
->subcode
|= GF_CALL_INTERNAL
;
300 gimple_call_set_internal_fn (s
, fn
);
301 gimple_call_reset_alias_info (s
);
306 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
307 the number of arguments. The ... are the arguments. */
310 gimple_build_call_internal (enum internal_fn fn
, unsigned nargs
, ...)
316 call
= gimple_build_call_internal_1 (fn
, nargs
);
317 va_start (ap
, nargs
);
318 for (i
= 0; i
< nargs
; i
++)
319 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
326 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
327 specified in vector ARGS. */
330 gimple_build_call_internal_vec (enum internal_fn fn
, vec
<tree
> args
)
335 nargs
= args
.length ();
336 call
= gimple_build_call_internal_1 (fn
, nargs
);
337 for (i
= 0; i
< nargs
; i
++)
338 gimple_call_set_arg (call
, i
, args
[i
]);
344 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
345 assumed to be in GIMPLE form already. Minimal checking is done of
349 gimple_build_call_from_tree (tree t
, tree fnptrtype
)
354 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
356 nargs
= call_expr_nargs (t
);
358 tree fndecl
= NULL_TREE
;
359 if (CALL_EXPR_FN (t
) == NULL_TREE
)
360 call
= gimple_build_call_internal_1 (CALL_EXPR_IFN (t
), nargs
);
363 fndecl
= get_callee_fndecl (t
);
364 call
= gimple_build_call_1 (fndecl
? fndecl
: CALL_EXPR_FN (t
), nargs
);
367 for (i
= 0; i
< nargs
; i
++)
368 gimple_call_set_arg (call
, i
, CALL_EXPR_ARG (t
, i
));
370 gimple_set_block (call
, TREE_BLOCK (t
));
371 gimple_set_location (call
, EXPR_LOCATION (t
));
373 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
374 gimple_call_set_chain (call
, CALL_EXPR_STATIC_CHAIN (t
));
375 gimple_call_set_tail (call
, CALL_EXPR_TAILCALL (t
));
376 gimple_call_set_must_tail (call
, CALL_EXPR_MUST_TAIL_CALL (t
));
377 gimple_call_set_return_slot_opt (call
, CALL_EXPR_RETURN_SLOT_OPT (t
));
379 && fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
)
380 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl
)))
381 gimple_call_set_alloca_for_var (call
, CALL_ALLOCA_FOR_VAR_P (t
));
383 gimple_call_set_from_thunk (call
, CALL_FROM_THUNK_P (t
));
384 gimple_call_set_va_arg_pack (call
, CALL_EXPR_VA_ARG_PACK (t
));
385 gimple_call_set_nothrow (call
, TREE_NOTHROW (t
));
386 gimple_call_set_by_descriptor (call
, CALL_EXPR_BY_DESCRIPTOR (t
));
387 gimple_set_no_warning (call
, TREE_NO_WARNING (t
));
391 gimple_call_set_fntype (call
, TREE_TYPE (fnptrtype
));
393 /* Check if it's an indirect CALL and the type has the
394 nocf_check attribute. In that case propagate the information
395 to the gimple CALL insn. */
398 gcc_assert (POINTER_TYPE_P (fnptrtype
));
399 tree fntype
= TREE_TYPE (fnptrtype
);
401 if (lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (fntype
)))
402 gimple_call_set_nocf_check (call
, TRUE
);
410 /* Build a GIMPLE_ASSIGN statement.
412 LHS of the assignment.
413 RHS of the assignment which can be unary or binary. */
416 gimple_build_assign (tree lhs
, tree rhs MEM_STAT_DECL
)
418 enum tree_code subcode
;
421 extract_ops_from_tree (rhs
, &subcode
, &op1
, &op2
, &op3
);
422 return gimple_build_assign (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
426 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
429 static inline gassign
*
430 gimple_build_assign_1 (tree lhs
, enum tree_code subcode
, tree op1
,
431 tree op2
, tree op3 MEM_STAT_DECL
)
436 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
438 num_ops
= get_gimple_rhs_num_ops (subcode
) + 1;
440 p
= as_a
<gassign
*> (
441 gimple_build_with_ops_stat (GIMPLE_ASSIGN
, (unsigned)subcode
, num_ops
443 gimple_assign_set_lhs (p
, lhs
);
444 gimple_assign_set_rhs1 (p
, op1
);
447 gcc_assert (num_ops
> 2);
448 gimple_assign_set_rhs2 (p
, op2
);
453 gcc_assert (num_ops
> 3);
454 gimple_assign_set_rhs3 (p
, op3
);
460 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
464 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
465 tree op2
, tree op3 MEM_STAT_DECL
)
467 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
470 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
474 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
475 tree op2 MEM_STAT_DECL
)
477 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, NULL_TREE
481 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
484 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1 MEM_STAT_DECL
)
486 return gimple_build_assign_1 (lhs
, subcode
, op1
, NULL_TREE
, NULL_TREE
491 /* Build a GIMPLE_COND statement.
493 PRED is the condition used to compare LHS and the RHS.
494 T_LABEL is the label to jump to if the condition is true.
495 F_LABEL is the label to jump to otherwise. */
498 gimple_build_cond (enum tree_code pred_code
, tree lhs
, tree rhs
,
499 tree t_label
, tree f_label
)
503 gcc_assert (TREE_CODE_CLASS (pred_code
) == tcc_comparison
);
504 p
= as_a
<gcond
*> (gimple_build_with_ops (GIMPLE_COND
, pred_code
, 4));
505 gimple_cond_set_lhs (p
, lhs
);
506 gimple_cond_set_rhs (p
, rhs
);
507 gimple_cond_set_true_label (p
, t_label
);
508 gimple_cond_set_false_label (p
, f_label
);
512 /* Build a GIMPLE_COND statement from the conditional expression tree
513 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
516 gimple_build_cond_from_tree (tree cond
, tree t_label
, tree f_label
)
521 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
522 return gimple_build_cond (code
, lhs
, rhs
, t_label
, f_label
);
525 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
526 boolean expression tree COND. */
529 gimple_cond_set_condition_from_tree (gcond
*stmt
, tree cond
)
534 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
535 gimple_cond_set_condition (stmt
, code
, lhs
, rhs
);
538 /* Build a GIMPLE_LABEL statement for LABEL. */
541 gimple_build_label (tree label
)
544 = as_a
<glabel
*> (gimple_build_with_ops (GIMPLE_LABEL
, ERROR_MARK
, 1));
545 gimple_label_set_label (p
, label
);
549 /* Build a GIMPLE_GOTO statement to label DEST. */
552 gimple_build_goto (tree dest
)
555 = as_a
<ggoto
*> (gimple_build_with_ops (GIMPLE_GOTO
, ERROR_MARK
, 1));
556 gimple_goto_set_dest (p
, dest
);
561 /* Build a GIMPLE_NOP statement. */
564 gimple_build_nop (void)
566 return gimple_alloc (GIMPLE_NOP
, 0);
570 /* Build a GIMPLE_BIND statement.
571 VARS are the variables in BODY.
572 BLOCK is the containing block. */
575 gimple_build_bind (tree vars
, gimple_seq body
, tree block
)
577 gbind
*p
= as_a
<gbind
*> (gimple_alloc (GIMPLE_BIND
, 0));
578 gimple_bind_set_vars (p
, vars
);
580 gimple_bind_set_body (p
, body
);
582 gimple_bind_set_block (p
, block
);
586 /* Helper function to set the simple fields of a asm stmt.
588 STRING is a pointer to a string that is the asm blocks assembly code.
589 NINPUT is the number of register inputs.
590 NOUTPUT is the number of register outputs.
591 NCLOBBERS is the number of clobbered registers.
595 gimple_build_asm_1 (const char *string
, unsigned ninputs
, unsigned noutputs
,
596 unsigned nclobbers
, unsigned nlabels
)
599 int size
= strlen (string
);
601 /* ASMs with labels cannot have outputs. This should have been
602 enforced by the front end. */
603 gcc_assert (nlabels
== 0 || noutputs
== 0);
606 gimple_build_with_ops (GIMPLE_ASM
, ERROR_MARK
,
607 ninputs
+ noutputs
+ nclobbers
+ nlabels
));
613 p
->string
= ggc_alloc_string (string
, size
);
615 if (GATHER_STATISTICS
)
616 gimple_alloc_sizes
[(int) gimple_alloc_kind (GIMPLE_ASM
)] += size
;
621 /* Build a GIMPLE_ASM statement.
623 STRING is the assembly code.
624 NINPUT is the number of register inputs.
625 NOUTPUT is the number of register outputs.
626 NCLOBBERS is the number of clobbered registers.
627 INPUTS is a vector of the input register parameters.
628 OUTPUTS is a vector of the output register parameters.
629 CLOBBERS is a vector of the clobbered register parameters.
630 LABELS is a vector of destination labels. */
633 gimple_build_asm_vec (const char *string
, vec
<tree
, va_gc
> *inputs
,
634 vec
<tree
, va_gc
> *outputs
, vec
<tree
, va_gc
> *clobbers
,
635 vec
<tree
, va_gc
> *labels
)
640 p
= gimple_build_asm_1 (string
,
641 vec_safe_length (inputs
),
642 vec_safe_length (outputs
),
643 vec_safe_length (clobbers
),
644 vec_safe_length (labels
));
646 for (i
= 0; i
< vec_safe_length (inputs
); i
++)
647 gimple_asm_set_input_op (p
, i
, (*inputs
)[i
]);
649 for (i
= 0; i
< vec_safe_length (outputs
); i
++)
650 gimple_asm_set_output_op (p
, i
, (*outputs
)[i
]);
652 for (i
= 0; i
< vec_safe_length (clobbers
); i
++)
653 gimple_asm_set_clobber_op (p
, i
, (*clobbers
)[i
]);
655 for (i
= 0; i
< vec_safe_length (labels
); i
++)
656 gimple_asm_set_label_op (p
, i
, (*labels
)[i
]);
661 /* Build a GIMPLE_CATCH statement.
663 TYPES are the catch types.
664 HANDLER is the exception handler. */
667 gimple_build_catch (tree types
, gimple_seq handler
)
669 gcatch
*p
= as_a
<gcatch
*> (gimple_alloc (GIMPLE_CATCH
, 0));
670 gimple_catch_set_types (p
, types
);
672 gimple_catch_set_handler (p
, handler
);
677 /* Build a GIMPLE_EH_FILTER statement.
679 TYPES are the filter's types.
680 FAILURE is the filter's failure action. */
683 gimple_build_eh_filter (tree types
, gimple_seq failure
)
685 geh_filter
*p
= as_a
<geh_filter
*> (gimple_alloc (GIMPLE_EH_FILTER
, 0));
686 gimple_eh_filter_set_types (p
, types
);
688 gimple_eh_filter_set_failure (p
, failure
);
693 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
696 gimple_build_eh_must_not_throw (tree decl
)
698 geh_mnt
*p
= as_a
<geh_mnt
*> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW
, 0));
700 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
701 gcc_assert (flags_from_decl_or_type (decl
) & ECF_NORETURN
);
702 gimple_eh_must_not_throw_set_fndecl (p
, decl
);
707 /* Build a GIMPLE_EH_ELSE statement. */
710 gimple_build_eh_else (gimple_seq n_body
, gimple_seq e_body
)
712 geh_else
*p
= as_a
<geh_else
*> (gimple_alloc (GIMPLE_EH_ELSE
, 0));
713 gimple_eh_else_set_n_body (p
, n_body
);
714 gimple_eh_else_set_e_body (p
, e_body
);
718 /* Build a GIMPLE_TRY statement.
720 EVAL is the expression to evaluate.
721 CLEANUP is the cleanup expression.
722 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
723 whether this is a try/catch or a try/finally respectively. */
726 gimple_build_try (gimple_seq eval
, gimple_seq cleanup
,
727 enum gimple_try_flags kind
)
731 gcc_assert (kind
== GIMPLE_TRY_CATCH
|| kind
== GIMPLE_TRY_FINALLY
);
732 p
= as_a
<gtry
*> (gimple_alloc (GIMPLE_TRY
, 0));
733 gimple_set_subcode (p
, kind
);
735 gimple_try_set_eval (p
, eval
);
737 gimple_try_set_cleanup (p
, cleanup
);
742 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
744 CLEANUP is the cleanup expression. */
747 gimple_build_wce (gimple_seq cleanup
)
749 gimple
*p
= gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR
, 0);
751 gimple_wce_set_cleanup (p
, cleanup
);
757 /* Build a GIMPLE_RESX statement. */
760 gimple_build_resx (int region
)
763 = as_a
<gresx
*> (gimple_build_with_ops (GIMPLE_RESX
, ERROR_MARK
, 0));
769 /* The helper for constructing a gimple switch statement.
770 INDEX is the switch's index.
771 NLABELS is the number of labels in the switch excluding the default.
772 DEFAULT_LABEL is the default label for the switch statement. */
775 gimple_build_switch_nlabels (unsigned nlabels
, tree index
, tree default_label
)
777 /* nlabels + 1 default label + 1 index. */
778 gcc_checking_assert (default_label
);
779 gswitch
*p
= as_a
<gswitch
*> (gimple_build_with_ops (GIMPLE_SWITCH
,
782 gimple_switch_set_index (p
, index
);
783 gimple_switch_set_default_label (p
, default_label
);
787 /* Build a GIMPLE_SWITCH statement.
789 INDEX is the switch's index.
790 DEFAULT_LABEL is the default label
791 ARGS is a vector of labels excluding the default. */
794 gimple_build_switch (tree index
, tree default_label
, vec
<tree
> args
)
796 unsigned i
, nlabels
= args
.length ();
798 gswitch
*p
= gimple_build_switch_nlabels (nlabels
, index
, default_label
);
800 /* Copy the labels from the vector to the switch statement. */
801 for (i
= 0; i
< nlabels
; i
++)
802 gimple_switch_set_label (p
, i
+ 1, args
[i
]);
807 /* Build a GIMPLE_EH_DISPATCH statement. */
810 gimple_build_eh_dispatch (int region
)
813 = as_a
<geh_dispatch
*> (
814 gimple_build_with_ops (GIMPLE_EH_DISPATCH
, ERROR_MARK
, 0));
819 /* Build a new GIMPLE_DEBUG_BIND statement.
821 VAR is bound to VALUE; block and location are taken from STMT. */
824 gimple_build_debug_bind (tree var
, tree value
, gimple
*stmt MEM_STAT_DECL
)
827 = as_a
<gdebug
*> (gimple_build_with_ops_stat (GIMPLE_DEBUG
,
828 (unsigned)GIMPLE_DEBUG_BIND
, 2
830 gimple_debug_bind_set_var (p
, var
);
831 gimple_debug_bind_set_value (p
, value
);
833 gimple_set_location (p
, gimple_location (stmt
));
839 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
841 VAR is bound to VALUE; block and location are taken from STMT. */
844 gimple_build_debug_source_bind (tree var
, tree value
,
845 gimple
*stmt MEM_STAT_DECL
)
849 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
850 (unsigned)GIMPLE_DEBUG_SOURCE_BIND
, 2
853 gimple_debug_source_bind_set_var (p
, var
);
854 gimple_debug_source_bind_set_value (p
, value
);
856 gimple_set_location (p
, gimple_location (stmt
));
862 /* Build a new GIMPLE_DEBUG_BEGIN_STMT statement in BLOCK at
866 gimple_build_debug_begin_stmt (tree block
, location_t location
871 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
872 (unsigned)GIMPLE_DEBUG_BEGIN_STMT
, 0
875 gimple_set_location (p
, location
);
876 gimple_set_block (p
, block
);
877 cfun
->debug_marker_count
++;
883 /* Build a new GIMPLE_DEBUG_INLINE_ENTRY statement in BLOCK at
884 LOCATION. The BLOCK links to the inlined function. */
887 gimple_build_debug_inline_entry (tree block
, location_t location
892 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
893 (unsigned)GIMPLE_DEBUG_INLINE_ENTRY
, 0
896 gimple_set_location (p
, location
);
897 gimple_set_block (p
, block
);
898 cfun
->debug_marker_count
++;
904 /* Build a GIMPLE_OMP_CRITICAL statement.
906 BODY is the sequence of statements for which only one thread can execute.
907 NAME is optional identifier for this critical block.
908 CLAUSES are clauses for this critical block. */
911 gimple_build_omp_critical (gimple_seq body
, tree name
, tree clauses
)
914 = as_a
<gomp_critical
*> (gimple_alloc (GIMPLE_OMP_CRITICAL
, 0));
915 gimple_omp_critical_set_name (p
, name
);
916 gimple_omp_critical_set_clauses (p
, clauses
);
918 gimple_omp_set_body (p
, body
);
923 /* Build a GIMPLE_OMP_FOR statement.
925 BODY is sequence of statements inside the for loop.
926 KIND is the `for' variant.
927 CLAUSES are any of the construct's clauses.
928 COLLAPSE is the collapse count.
929 PRE_BODY is the sequence of statements that are loop invariant. */
932 gimple_build_omp_for (gimple_seq body
, int kind
, tree clauses
, size_t collapse
,
935 gomp_for
*p
= as_a
<gomp_for
*> (gimple_alloc (GIMPLE_OMP_FOR
, 0));
937 gimple_omp_set_body (p
, body
);
938 gimple_omp_for_set_clauses (p
, clauses
);
939 gimple_omp_for_set_kind (p
, kind
);
940 p
->collapse
= collapse
;
941 p
->iter
= ggc_cleared_vec_alloc
<gimple_omp_for_iter
> (collapse
);
944 gimple_omp_for_set_pre_body (p
, pre_body
);
950 /* Build a GIMPLE_OMP_PARALLEL statement.
952 BODY is sequence of statements which are executed in parallel.
953 CLAUSES are the OMP parallel construct's clauses.
954 CHILD_FN is the function created for the parallel threads to execute.
955 DATA_ARG are the shared data argument(s). */
958 gimple_build_omp_parallel (gimple_seq body
, tree clauses
, tree child_fn
,
962 = as_a
<gomp_parallel
*> (gimple_alloc (GIMPLE_OMP_PARALLEL
, 0));
964 gimple_omp_set_body (p
, body
);
965 gimple_omp_parallel_set_clauses (p
, clauses
);
966 gimple_omp_parallel_set_child_fn (p
, child_fn
);
967 gimple_omp_parallel_set_data_arg (p
, data_arg
);
973 /* Build a GIMPLE_OMP_TASK statement.
975 BODY is sequence of statements which are executed by the explicit task.
976 CLAUSES are the OMP task construct's clauses.
977 CHILD_FN is the function created for the parallel threads to execute.
978 DATA_ARG are the shared data argument(s).
979 COPY_FN is the optional function for firstprivate initialization.
980 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
983 gimple_build_omp_task (gimple_seq body
, tree clauses
, tree child_fn
,
984 tree data_arg
, tree copy_fn
, tree arg_size
,
987 gomp_task
*p
= as_a
<gomp_task
*> (gimple_alloc (GIMPLE_OMP_TASK
, 0));
989 gimple_omp_set_body (p
, body
);
990 gimple_omp_task_set_clauses (p
, clauses
);
991 gimple_omp_task_set_child_fn (p
, child_fn
);
992 gimple_omp_task_set_data_arg (p
, data_arg
);
993 gimple_omp_task_set_copy_fn (p
, copy_fn
);
994 gimple_omp_task_set_arg_size (p
, arg_size
);
995 gimple_omp_task_set_arg_align (p
, arg_align
);
1001 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
1003 BODY is the sequence of statements in the section. */
1006 gimple_build_omp_section (gimple_seq body
)
1008 gimple
*p
= gimple_alloc (GIMPLE_OMP_SECTION
, 0);
1010 gimple_omp_set_body (p
, body
);
1016 /* Build a GIMPLE_OMP_MASTER statement.
1018 BODY is the sequence of statements to be executed by just the master. */
1021 gimple_build_omp_master (gimple_seq body
)
1023 gimple
*p
= gimple_alloc (GIMPLE_OMP_MASTER
, 0);
1025 gimple_omp_set_body (p
, body
);
1030 /* Build a GIMPLE_OMP_GRID_BODY statement.
1032 BODY is the sequence of statements to be executed by the kernel. */
1035 gimple_build_omp_grid_body (gimple_seq body
)
1037 gimple
*p
= gimple_alloc (GIMPLE_OMP_GRID_BODY
, 0);
1039 gimple_omp_set_body (p
, body
);
1044 /* Build a GIMPLE_OMP_TASKGROUP statement.
1046 BODY is the sequence of statements to be executed by the taskgroup
1048 CLAUSES are any of the construct's clauses. */
1051 gimple_build_omp_taskgroup (gimple_seq body
, tree clauses
)
1053 gimple
*p
= gimple_alloc (GIMPLE_OMP_TASKGROUP
, 0);
1054 gimple_omp_taskgroup_set_clauses (p
, clauses
);
1056 gimple_omp_set_body (p
, body
);
1062 /* Build a GIMPLE_OMP_CONTINUE statement.
1064 CONTROL_DEF is the definition of the control variable.
1065 CONTROL_USE is the use of the control variable. */
1068 gimple_build_omp_continue (tree control_def
, tree control_use
)
1071 = as_a
<gomp_continue
*> (gimple_alloc (GIMPLE_OMP_CONTINUE
, 0));
1072 gimple_omp_continue_set_control_def (p
, control_def
);
1073 gimple_omp_continue_set_control_use (p
, control_use
);
1077 /* Build a GIMPLE_OMP_ORDERED statement.
1079 BODY is the sequence of statements inside a loop that will executed in
1081 CLAUSES are clauses for this statement. */
1084 gimple_build_omp_ordered (gimple_seq body
, tree clauses
)
1087 = as_a
<gomp_ordered
*> (gimple_alloc (GIMPLE_OMP_ORDERED
, 0));
1088 gimple_omp_ordered_set_clauses (p
, clauses
);
1090 gimple_omp_set_body (p
, body
);
1096 /* Build a GIMPLE_OMP_RETURN statement.
1097 WAIT_P is true if this is a non-waiting return. */
1100 gimple_build_omp_return (bool wait_p
)
1102 gimple
*p
= gimple_alloc (GIMPLE_OMP_RETURN
, 0);
1104 gimple_omp_return_set_nowait (p
);
1110 /* Build a GIMPLE_OMP_SECTIONS statement.
1112 BODY is a sequence of section statements.
1113 CLAUSES are any of the OMP sections contsruct's clauses: private,
1114 firstprivate, lastprivate, reduction, and nowait. */
1117 gimple_build_omp_sections (gimple_seq body
, tree clauses
)
1120 = as_a
<gomp_sections
*> (gimple_alloc (GIMPLE_OMP_SECTIONS
, 0));
1122 gimple_omp_set_body (p
, body
);
1123 gimple_omp_sections_set_clauses (p
, clauses
);
1129 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1132 gimple_build_omp_sections_switch (void)
1134 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH
, 0);
1138 /* Build a GIMPLE_OMP_SINGLE statement.
1140 BODY is the sequence of statements that will be executed once.
1141 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1142 copyprivate, nowait. */
1145 gimple_build_omp_single (gimple_seq body
, tree clauses
)
1148 = as_a
<gomp_single
*> (gimple_alloc (GIMPLE_OMP_SINGLE
, 0));
1150 gimple_omp_set_body (p
, body
);
1151 gimple_omp_single_set_clauses (p
, clauses
);
1157 /* Build a GIMPLE_OMP_TARGET statement.
1159 BODY is the sequence of statements that will be executed.
1160 KIND is the kind of the region.
1161 CLAUSES are any of the construct's clauses. */
1164 gimple_build_omp_target (gimple_seq body
, int kind
, tree clauses
)
1167 = as_a
<gomp_target
*> (gimple_alloc (GIMPLE_OMP_TARGET
, 0));
1169 gimple_omp_set_body (p
, body
);
1170 gimple_omp_target_set_clauses (p
, clauses
);
1171 gimple_omp_target_set_kind (p
, kind
);
1177 /* Build a GIMPLE_OMP_TEAMS statement.
1179 BODY is the sequence of statements that will be executed.
1180 CLAUSES are any of the OMP teams construct's clauses. */
1183 gimple_build_omp_teams (gimple_seq body
, tree clauses
)
1185 gomp_teams
*p
= as_a
<gomp_teams
*> (gimple_alloc (GIMPLE_OMP_TEAMS
, 0));
1187 gimple_omp_set_body (p
, body
);
1188 gimple_omp_teams_set_clauses (p
, clauses
);
1194 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1197 gimple_build_omp_atomic_load (tree lhs
, tree rhs
, enum omp_memory_order mo
)
1200 = as_a
<gomp_atomic_load
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD
, 0));
1201 gimple_omp_atomic_load_set_lhs (p
, lhs
);
1202 gimple_omp_atomic_load_set_rhs (p
, rhs
);
1203 gimple_omp_atomic_set_memory_order (p
, mo
);
1207 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1209 VAL is the value we are storing. */
1212 gimple_build_omp_atomic_store (tree val
, enum omp_memory_order mo
)
1214 gomp_atomic_store
*p
1215 = as_a
<gomp_atomic_store
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE
, 0));
1216 gimple_omp_atomic_store_set_val (p
, val
);
1217 gimple_omp_atomic_set_memory_order (p
, mo
);
1221 /* Build a GIMPLE_TRANSACTION statement. */
1224 gimple_build_transaction (gimple_seq body
)
1227 = as_a
<gtransaction
*> (gimple_alloc (GIMPLE_TRANSACTION
, 0));
1228 gimple_transaction_set_body (p
, body
);
1229 gimple_transaction_set_label_norm (p
, 0);
1230 gimple_transaction_set_label_uninst (p
, 0);
1231 gimple_transaction_set_label_over (p
, 0);
1235 #if defined ENABLE_GIMPLE_CHECKING
1236 /* Complain of a gimple type mismatch and die. */
1239 gimple_check_failed (const gimple
*gs
, const char *file
, int line
,
1240 const char *function
, enum gimple_code code
,
1241 enum tree_code subcode
)
1243 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1244 gimple_code_name
[code
],
1245 get_tree_code_name (subcode
),
1246 gimple_code_name
[gimple_code (gs
)],
1248 ? get_tree_code_name ((enum tree_code
) gs
->subcode
)
1250 function
, trim_filename (file
), line
);
1252 #endif /* ENABLE_GIMPLE_CHECKING */
1255 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1256 *SEQ_P is NULL, a new sequence is allocated. */
1259 gimple_seq_add_stmt (gimple_seq
*seq_p
, gimple
*gs
)
1261 gimple_stmt_iterator si
;
1265 si
= gsi_last (*seq_p
);
1266 gsi_insert_after (&si
, gs
, GSI_NEW_STMT
);
1269 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1270 *SEQ_P is NULL, a new sequence is allocated. This function is
1271 similar to gimple_seq_add_stmt, but does not scan the operands.
1272 During gimplification, we need to manipulate statement sequences
1273 before the def/use vectors have been constructed. */
1276 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple
*gs
)
1278 gimple_stmt_iterator si
;
1283 si
= gsi_last (*seq_p
);
1284 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
1287 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1288 NULL, a new sequence is allocated. */
1291 gimple_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
1293 gimple_stmt_iterator si
;
1297 si
= gsi_last (*dst_p
);
1298 gsi_insert_seq_after (&si
, src
, GSI_NEW_STMT
);
1301 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1302 NULL, a new sequence is allocated. This function is
1303 similar to gimple_seq_add_seq, but does not scan the operands. */
1306 gimple_seq_add_seq_without_update (gimple_seq
*dst_p
, gimple_seq src
)
1308 gimple_stmt_iterator si
;
1312 si
= gsi_last (*dst_p
);
1313 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
1316 /* Determine whether to assign a location to the statement GS. */
1319 should_carry_location_p (gimple
*gs
)
1321 /* Don't emit a line note for a label. We particularly don't want to
1322 emit one for the break label, since it doesn't actually correspond
1323 to the beginning of the loop/switch. */
1324 if (gimple_code (gs
) == GIMPLE_LABEL
)
1330 /* Set the location for gimple statement GS to LOCATION. */
1333 annotate_one_with_location (gimple
*gs
, location_t location
)
1335 if (!gimple_has_location (gs
)
1336 && !gimple_do_not_emit_location_p (gs
)
1337 && should_carry_location_p (gs
))
1338 gimple_set_location (gs
, location
);
1341 /* Set LOCATION for all the statements after iterator GSI in sequence
1342 SEQ. If GSI is pointing to the end of the sequence, start with the
1343 first statement in SEQ. */
1346 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
1347 location_t location
)
1349 if (gsi_end_p (gsi
))
1350 gsi
= gsi_start (seq
);
1354 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
1355 annotate_one_with_location (gsi_stmt (gsi
), location
);
1358 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1361 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
1363 gimple_stmt_iterator i
;
1365 if (gimple_seq_empty_p (stmt_p
))
1368 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
1370 gimple
*gs
= gsi_stmt (i
);
1371 annotate_one_with_location (gs
, location
);
1375 /* Helper function of empty_body_p. Return true if STMT is an empty
1379 empty_stmt_p (gimple
*stmt
)
1381 if (gimple_code (stmt
) == GIMPLE_NOP
)
1383 if (gbind
*bind_stmt
= dyn_cast
<gbind
*> (stmt
))
1384 return empty_body_p (gimple_bind_body (bind_stmt
));
1389 /* Return true if BODY contains nothing but empty statements. */
1392 empty_body_p (gimple_seq body
)
1394 gimple_stmt_iterator i
;
1396 if (gimple_seq_empty_p (body
))
1398 for (i
= gsi_start (body
); !gsi_end_p (i
); gsi_next (&i
))
1399 if (!empty_stmt_p (gsi_stmt (i
))
1400 && !is_gimple_debug (gsi_stmt (i
)))
1407 /* Perform a deep copy of sequence SRC and return the result. */
1410 gimple_seq_copy (gimple_seq src
)
1412 gimple_stmt_iterator gsi
;
1413 gimple_seq new_seq
= NULL
;
1416 for (gsi
= gsi_start (src
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1418 stmt
= gimple_copy (gsi_stmt (gsi
));
1419 gimple_seq_add_stmt (&new_seq
, stmt
);
1427 /* Return true if calls C1 and C2 are known to go to the same function. */
1430 gimple_call_same_target_p (const gimple
*c1
, const gimple
*c2
)
1432 if (gimple_call_internal_p (c1
))
1433 return (gimple_call_internal_p (c2
)
1434 && gimple_call_internal_fn (c1
) == gimple_call_internal_fn (c2
)
1435 && (!gimple_call_internal_unique_p (as_a
<const gcall
*> (c1
))
1438 return (gimple_call_fn (c1
) == gimple_call_fn (c2
)
1439 || (gimple_call_fndecl (c1
)
1440 && gimple_call_fndecl (c1
) == gimple_call_fndecl (c2
)));
1443 /* Detect flags from a GIMPLE_CALL. This is just like
1444 call_expr_flags, but for gimple tuples. */
1447 gimple_call_flags (const gimple
*stmt
)
1451 if (gimple_call_internal_p (stmt
))
1452 flags
= internal_fn_flags (gimple_call_internal_fn (stmt
));
1455 tree decl
= gimple_call_fndecl (stmt
);
1457 flags
= flags_from_decl_or_type (decl
);
1458 flags
|= flags_from_decl_or_type (gimple_call_fntype (stmt
));
1461 if (stmt
->subcode
& GF_CALL_NOTHROW
)
1462 flags
|= ECF_NOTHROW
;
1464 if (stmt
->subcode
& GF_CALL_BY_DESCRIPTOR
)
1465 flags
|= ECF_BY_DESCRIPTOR
;
1470 /* Return the "fn spec" string for call STMT. */
1473 gimple_call_fnspec (const gcall
*stmt
)
1477 if (gimple_call_internal_p (stmt
))
1478 return internal_fn_fnspec (gimple_call_internal_fn (stmt
));
1480 type
= gimple_call_fntype (stmt
);
1484 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
1488 return TREE_VALUE (TREE_VALUE (attr
));
1491 /* Detects argument flags for argument number ARG on call STMT. */
1494 gimple_call_arg_flags (const gcall
*stmt
, unsigned arg
)
1496 const_tree attr
= gimple_call_fnspec (stmt
);
1498 if (!attr
|| 1 + arg
>= (unsigned) TREE_STRING_LENGTH (attr
))
1501 switch (TREE_STRING_POINTER (attr
)[1 + arg
])
1508 return EAF_DIRECT
| EAF_NOCLOBBER
| EAF_NOESCAPE
;
1511 return EAF_NOCLOBBER
| EAF_NOESCAPE
;
1514 return EAF_DIRECT
| EAF_NOESCAPE
;
1517 return EAF_NOESCAPE
;
1525 /* Detects return flags for the call STMT. */
1528 gimple_call_return_flags (const gcall
*stmt
)
1532 if (gimple_call_flags (stmt
) & ECF_MALLOC
)
1535 attr
= gimple_call_fnspec (stmt
);
1536 if (!attr
|| TREE_STRING_LENGTH (attr
) < 1)
1539 switch (TREE_STRING_POINTER (attr
)[0])
1545 return ERF_RETURNS_ARG
| (TREE_STRING_POINTER (attr
)[0] - '1');
1557 /* Return true if call STMT is known to return a non-zero result. */
1560 gimple_call_nonnull_result_p (gcall
*call
)
1562 tree fndecl
= gimple_call_fndecl (call
);
1565 if (flag_delete_null_pointer_checks
&& !flag_check_new
1566 && DECL_IS_OPERATOR_NEW (fndecl
)
1567 && !TREE_NOTHROW (fndecl
))
1570 /* References are always non-NULL. */
1571 if (flag_delete_null_pointer_checks
1572 && TREE_CODE (TREE_TYPE (fndecl
)) == REFERENCE_TYPE
)
1575 if (flag_delete_null_pointer_checks
1576 && lookup_attribute ("returns_nonnull",
1577 TYPE_ATTRIBUTES (gimple_call_fntype (call
))))
1579 return gimple_alloca_call_p (call
);
1583 /* If CALL returns a non-null result in an argument, return that arg. */
1586 gimple_call_nonnull_arg (gcall
*call
)
1588 tree fndecl
= gimple_call_fndecl (call
);
1592 unsigned rf
= gimple_call_return_flags (call
);
1593 if (rf
& ERF_RETURNS_ARG
)
1595 unsigned argnum
= rf
& ERF_RETURN_ARG_MASK
;
1596 if (argnum
< gimple_call_num_args (call
))
1598 tree arg
= gimple_call_arg (call
, argnum
);
1600 && infer_nonnull_range_by_attribute (call
, arg
))
1608 /* Return true if GS is a copy assignment. */
1611 gimple_assign_copy_p (gimple
*gs
)
1613 return (gimple_assign_single_p (gs
)
1614 && is_gimple_val (gimple_op (gs
, 1)));
1618 /* Return true if GS is a SSA_NAME copy assignment. */
1621 gimple_assign_ssa_name_copy_p (gimple
*gs
)
1623 return (gimple_assign_single_p (gs
)
1624 && TREE_CODE (gimple_assign_lhs (gs
)) == SSA_NAME
1625 && TREE_CODE (gimple_assign_rhs1 (gs
)) == SSA_NAME
);
1629 /* Return true if GS is an assignment with a unary RHS, but the
1630 operator has no effect on the assigned value. The logic is adapted
1631 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1632 instances in which STRIP_NOPS was previously applied to the RHS of
1635 NOTE: In the use cases that led to the creation of this function
1636 and of gimple_assign_single_p, it is typical to test for either
1637 condition and to proceed in the same manner. In each case, the
1638 assigned value is represented by the single RHS operand of the
1639 assignment. I suspect there may be cases where gimple_assign_copy_p,
1640 gimple_assign_single_p, or equivalent logic is used where a similar
1641 treatment of unary NOPs is appropriate. */
1644 gimple_assign_unary_nop_p (gimple
*gs
)
1646 return (is_gimple_assign (gs
)
1647 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs
))
1648 || gimple_assign_rhs_code (gs
) == NON_LVALUE_EXPR
)
1649 && gimple_assign_rhs1 (gs
) != error_mark_node
1650 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs
)))
1651 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs
)))));
1654 /* Set BB to be the basic block holding G. */
1657 gimple_set_bb (gimple
*stmt
, basic_block bb
)
1661 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1664 /* If the statement is a label, add the label to block-to-labels map
1665 so that we can speed up edge creation for GIMPLE_GOTOs. */
1671 t
= gimple_label_label (as_a
<glabel
*> (stmt
));
1672 uid
= LABEL_DECL_UID (t
);
1676 vec_safe_length (label_to_block_map_for_fn (cfun
));
1677 LABEL_DECL_UID (t
) = uid
= cfun
->cfg
->last_label_uid
++;
1678 if (old_len
<= (unsigned) uid
)
1680 unsigned new_len
= 3 * uid
/ 2 + 1;
1682 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun
),
1687 (*label_to_block_map_for_fn (cfun
))[uid
] = bb
;
1692 /* Modify the RHS of the assignment pointed-to by GSI using the
1693 operands in the expression tree EXPR.
1695 NOTE: The statement pointed-to by GSI may be reallocated if it
1696 did not have enough operand slots.
1698 This function is useful to convert an existing tree expression into
1699 the flat representation used for the RHS of a GIMPLE assignment.
1700 It will reallocate memory as needed to expand or shrink the number
1701 of operand slots needed to represent EXPR.
1703 NOTE: If you find yourself building a tree and then calling this
1704 function, you are most certainly doing it the slow way. It is much
1705 better to build a new assignment or to use the function
1706 gimple_assign_set_rhs_with_ops, which does not require an
1707 expression tree to be built. */
1710 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*gsi
, tree expr
)
1712 enum tree_code subcode
;
1715 extract_ops_from_tree (expr
, &subcode
, &op1
, &op2
, &op3
);
1716 gimple_assign_set_rhs_with_ops (gsi
, subcode
, op1
, op2
, op3
);
1720 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1721 operands OP1, OP2 and OP3.
1723 NOTE: The statement pointed-to by GSI may be reallocated if it
1724 did not have enough operand slots. */
1727 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*gsi
, enum tree_code code
,
1728 tree op1
, tree op2
, tree op3
)
1730 unsigned new_rhs_ops
= get_gimple_rhs_num_ops (code
);
1731 gimple
*stmt
= gsi_stmt (*gsi
);
1732 gimple
*old_stmt
= stmt
;
1734 /* If the new CODE needs more operands, allocate a new statement. */
1735 if (gimple_num_ops (stmt
) < new_rhs_ops
+ 1)
1737 tree lhs
= gimple_assign_lhs (old_stmt
);
1738 stmt
= gimple_alloc (gimple_code (old_stmt
), new_rhs_ops
+ 1);
1739 memcpy (stmt
, old_stmt
, gimple_size (gimple_code (old_stmt
)));
1740 gimple_init_singleton (stmt
);
1742 /* The LHS needs to be reset as this also changes the SSA name
1744 gimple_assign_set_lhs (stmt
, lhs
);
1747 gimple_set_num_ops (stmt
, new_rhs_ops
+ 1);
1748 gimple_set_subcode (stmt
, code
);
1749 gimple_assign_set_rhs1 (stmt
, op1
);
1750 if (new_rhs_ops
> 1)
1751 gimple_assign_set_rhs2 (stmt
, op2
);
1752 if (new_rhs_ops
> 2)
1753 gimple_assign_set_rhs3 (stmt
, op3
);
1754 if (stmt
!= old_stmt
)
1755 gsi_replace (gsi
, stmt
, false);
1759 /* Return the LHS of a statement that performs an assignment,
1760 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1761 for a call to a function that returns no value, or for a
1762 statement other than an assignment or a call. */
1765 gimple_get_lhs (const gimple
*stmt
)
1767 enum gimple_code code
= gimple_code (stmt
);
1769 if (code
== GIMPLE_ASSIGN
)
1770 return gimple_assign_lhs (stmt
);
1771 else if (code
== GIMPLE_CALL
)
1772 return gimple_call_lhs (stmt
);
1778 /* Set the LHS of a statement that performs an assignment,
1779 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1782 gimple_set_lhs (gimple
*stmt
, tree lhs
)
1784 enum gimple_code code
= gimple_code (stmt
);
1786 if (code
== GIMPLE_ASSIGN
)
1787 gimple_assign_set_lhs (stmt
, lhs
);
1788 else if (code
== GIMPLE_CALL
)
1789 gimple_call_set_lhs (stmt
, lhs
);
1795 /* Return a deep copy of statement STMT. All the operands from STMT
1796 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1797 and VUSE operand arrays are set to empty in the new copy. The new
1798 copy isn't part of any sequence. */
1801 gimple_copy (gimple
*stmt
)
1803 enum gimple_code code
= gimple_code (stmt
);
1804 unsigned num_ops
= gimple_num_ops (stmt
);
1805 gimple
*copy
= gimple_alloc (code
, num_ops
);
1808 /* Shallow copy all the fields from STMT. */
1809 memcpy (copy
, stmt
, gimple_size (code
));
1810 gimple_init_singleton (copy
);
1812 /* If STMT has sub-statements, deep-copy them as well. */
1813 if (gimple_has_substatements (stmt
))
1818 switch (gimple_code (stmt
))
1822 gbind
*bind_stmt
= as_a
<gbind
*> (stmt
);
1823 gbind
*bind_copy
= as_a
<gbind
*> (copy
);
1824 new_seq
= gimple_seq_copy (gimple_bind_body (bind_stmt
));
1825 gimple_bind_set_body (bind_copy
, new_seq
);
1826 gimple_bind_set_vars (bind_copy
,
1827 unshare_expr (gimple_bind_vars (bind_stmt
)));
1828 gimple_bind_set_block (bind_copy
, gimple_bind_block (bind_stmt
));
1834 gcatch
*catch_stmt
= as_a
<gcatch
*> (stmt
);
1835 gcatch
*catch_copy
= as_a
<gcatch
*> (copy
);
1836 new_seq
= gimple_seq_copy (gimple_catch_handler (catch_stmt
));
1837 gimple_catch_set_handler (catch_copy
, new_seq
);
1838 t
= unshare_expr (gimple_catch_types (catch_stmt
));
1839 gimple_catch_set_types (catch_copy
, t
);
1843 case GIMPLE_EH_FILTER
:
1845 geh_filter
*eh_filter_stmt
= as_a
<geh_filter
*> (stmt
);
1846 geh_filter
*eh_filter_copy
= as_a
<geh_filter
*> (copy
);
1848 = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt
));
1849 gimple_eh_filter_set_failure (eh_filter_copy
, new_seq
);
1850 t
= unshare_expr (gimple_eh_filter_types (eh_filter_stmt
));
1851 gimple_eh_filter_set_types (eh_filter_copy
, t
);
1855 case GIMPLE_EH_ELSE
:
1857 geh_else
*eh_else_stmt
= as_a
<geh_else
*> (stmt
);
1858 geh_else
*eh_else_copy
= as_a
<geh_else
*> (copy
);
1859 new_seq
= gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt
));
1860 gimple_eh_else_set_n_body (eh_else_copy
, new_seq
);
1861 new_seq
= gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt
));
1862 gimple_eh_else_set_e_body (eh_else_copy
, new_seq
);
1868 gtry
*try_stmt
= as_a
<gtry
*> (stmt
);
1869 gtry
*try_copy
= as_a
<gtry
*> (copy
);
1870 new_seq
= gimple_seq_copy (gimple_try_eval (try_stmt
));
1871 gimple_try_set_eval (try_copy
, new_seq
);
1872 new_seq
= gimple_seq_copy (gimple_try_cleanup (try_stmt
));
1873 gimple_try_set_cleanup (try_copy
, new_seq
);
1877 case GIMPLE_OMP_FOR
:
1878 new_seq
= gimple_seq_copy (gimple_omp_for_pre_body (stmt
));
1879 gimple_omp_for_set_pre_body (copy
, new_seq
);
1880 t
= unshare_expr (gimple_omp_for_clauses (stmt
));
1881 gimple_omp_for_set_clauses (copy
, t
);
1883 gomp_for
*omp_for_copy
= as_a
<gomp_for
*> (copy
);
1884 omp_for_copy
->iter
= ggc_vec_alloc
<gimple_omp_for_iter
>
1885 ( gimple_omp_for_collapse (stmt
));
1887 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1889 gimple_omp_for_set_cond (copy
, i
,
1890 gimple_omp_for_cond (stmt
, i
));
1891 gimple_omp_for_set_index (copy
, i
,
1892 gimple_omp_for_index (stmt
, i
));
1893 t
= unshare_expr (gimple_omp_for_initial (stmt
, i
));
1894 gimple_omp_for_set_initial (copy
, i
, t
);
1895 t
= unshare_expr (gimple_omp_for_final (stmt
, i
));
1896 gimple_omp_for_set_final (copy
, i
, t
);
1897 t
= unshare_expr (gimple_omp_for_incr (stmt
, i
));
1898 gimple_omp_for_set_incr (copy
, i
, t
);
1902 case GIMPLE_OMP_PARALLEL
:
1904 gomp_parallel
*omp_par_stmt
= as_a
<gomp_parallel
*> (stmt
);
1905 gomp_parallel
*omp_par_copy
= as_a
<gomp_parallel
*> (copy
);
1906 t
= unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt
));
1907 gimple_omp_parallel_set_clauses (omp_par_copy
, t
);
1908 t
= unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt
));
1909 gimple_omp_parallel_set_child_fn (omp_par_copy
, t
);
1910 t
= unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt
));
1911 gimple_omp_parallel_set_data_arg (omp_par_copy
, t
);
1915 case GIMPLE_OMP_TASK
:
1916 t
= unshare_expr (gimple_omp_task_clauses (stmt
));
1917 gimple_omp_task_set_clauses (copy
, t
);
1918 t
= unshare_expr (gimple_omp_task_child_fn (stmt
));
1919 gimple_omp_task_set_child_fn (copy
, t
);
1920 t
= unshare_expr (gimple_omp_task_data_arg (stmt
));
1921 gimple_omp_task_set_data_arg (copy
, t
);
1922 t
= unshare_expr (gimple_omp_task_copy_fn (stmt
));
1923 gimple_omp_task_set_copy_fn (copy
, t
);
1924 t
= unshare_expr (gimple_omp_task_arg_size (stmt
));
1925 gimple_omp_task_set_arg_size (copy
, t
);
1926 t
= unshare_expr (gimple_omp_task_arg_align (stmt
));
1927 gimple_omp_task_set_arg_align (copy
, t
);
1930 case GIMPLE_OMP_CRITICAL
:
1931 t
= unshare_expr (gimple_omp_critical_name
1932 (as_a
<gomp_critical
*> (stmt
)));
1933 gimple_omp_critical_set_name (as_a
<gomp_critical
*> (copy
), t
);
1934 t
= unshare_expr (gimple_omp_critical_clauses
1935 (as_a
<gomp_critical
*> (stmt
)));
1936 gimple_omp_critical_set_clauses (as_a
<gomp_critical
*> (copy
), t
);
1939 case GIMPLE_OMP_ORDERED
:
1940 t
= unshare_expr (gimple_omp_ordered_clauses
1941 (as_a
<gomp_ordered
*> (stmt
)));
1942 gimple_omp_ordered_set_clauses (as_a
<gomp_ordered
*> (copy
), t
);
1945 case GIMPLE_OMP_TASKGROUP
:
1946 t
= unshare_expr (gimple_omp_taskgroup_clauses (stmt
));
1947 gimple_omp_taskgroup_set_clauses (copy
, t
);
1950 case GIMPLE_OMP_SECTIONS
:
1951 t
= unshare_expr (gimple_omp_sections_clauses (stmt
));
1952 gimple_omp_sections_set_clauses (copy
, t
);
1953 t
= unshare_expr (gimple_omp_sections_control (stmt
));
1954 gimple_omp_sections_set_control (copy
, t
);
1957 case GIMPLE_OMP_SINGLE
:
1959 gomp_single
*omp_single_copy
= as_a
<gomp_single
*> (copy
);
1960 t
= unshare_expr (gimple_omp_single_clauses (stmt
));
1961 gimple_omp_single_set_clauses (omp_single_copy
, t
);
1965 case GIMPLE_OMP_TARGET
:
1967 gomp_target
*omp_target_stmt
= as_a
<gomp_target
*> (stmt
);
1968 gomp_target
*omp_target_copy
= as_a
<gomp_target
*> (copy
);
1969 t
= unshare_expr (gimple_omp_target_clauses (omp_target_stmt
));
1970 gimple_omp_target_set_clauses (omp_target_copy
, t
);
1971 t
= unshare_expr (gimple_omp_target_data_arg (omp_target_stmt
));
1972 gimple_omp_target_set_data_arg (omp_target_copy
, t
);
1976 case GIMPLE_OMP_TEAMS
:
1978 gomp_teams
*omp_teams_copy
= as_a
<gomp_teams
*> (copy
);
1979 t
= unshare_expr (gimple_omp_teams_clauses (stmt
));
1980 gimple_omp_teams_set_clauses (omp_teams_copy
, t
);
1984 case GIMPLE_OMP_SECTION
:
1985 case GIMPLE_OMP_MASTER
:
1986 case GIMPLE_OMP_GRID_BODY
:
1988 new_seq
= gimple_seq_copy (gimple_omp_body (stmt
));
1989 gimple_omp_set_body (copy
, new_seq
);
1992 case GIMPLE_TRANSACTION
:
1993 new_seq
= gimple_seq_copy (gimple_transaction_body (
1994 as_a
<gtransaction
*> (stmt
)));
1995 gimple_transaction_set_body (as_a
<gtransaction
*> (copy
),
1999 case GIMPLE_WITH_CLEANUP_EXPR
:
2000 new_seq
= gimple_seq_copy (gimple_wce_cleanup (stmt
));
2001 gimple_wce_set_cleanup (copy
, new_seq
);
2009 /* Make copy of operands. */
2010 for (i
= 0; i
< num_ops
; i
++)
2011 gimple_set_op (copy
, i
, unshare_expr (gimple_op (stmt
, i
)));
2013 if (gimple_has_mem_ops (stmt
))
2015 gimple_set_vdef (copy
, gimple_vdef (stmt
));
2016 gimple_set_vuse (copy
, gimple_vuse (stmt
));
2019 /* Clear out SSA operand vectors on COPY. */
2020 if (gimple_has_ops (stmt
))
2022 gimple_set_use_ops (copy
, NULL
);
2024 /* SSA operands need to be updated. */
2025 gimple_set_modified (copy
, true);
2028 if (gimple_debug_nonbind_marker_p (stmt
))
2029 cfun
->debug_marker_count
++;
2035 /* Return true if statement S has side-effects. We consider a
2036 statement to have side effects if:
2038 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
2039 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
2042 gimple_has_side_effects (const gimple
*s
)
2044 if (is_gimple_debug (s
))
2047 /* We don't have to scan the arguments to check for
2048 volatile arguments, though, at present, we still
2049 do a scan to check for TREE_SIDE_EFFECTS. */
2050 if (gimple_has_volatile_ops (s
))
2053 if (gimple_code (s
) == GIMPLE_ASM
2054 && gimple_asm_volatile_p (as_a
<const gasm
*> (s
)))
2057 if (is_gimple_call (s
))
2059 int flags
= gimple_call_flags (s
);
2061 /* An infinite loop is considered a side effect. */
2062 if (!(flags
& (ECF_CONST
| ECF_PURE
))
2063 || (flags
& ECF_LOOPING_CONST_OR_PURE
))
2072 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
2073 Return true if S can trap. When INCLUDE_MEM is true, check whether
2074 the memory operations could trap. When INCLUDE_STORES is true and
2075 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
2078 gimple_could_trap_p_1 (gimple
*s
, bool include_mem
, bool include_stores
)
2080 tree t
, div
= NULL_TREE
;
2085 unsigned i
, start
= (is_gimple_assign (s
) && !include_stores
) ? 1 : 0;
2087 for (i
= start
; i
< gimple_num_ops (s
); i
++)
2088 if (tree_could_trap_p (gimple_op (s
, i
)))
2092 switch (gimple_code (s
))
2095 return gimple_asm_volatile_p (as_a
<gasm
*> (s
));
2098 t
= gimple_call_fndecl (s
);
2099 /* Assume that calls to weak functions may trap. */
2100 if (!t
|| !DECL_P (t
) || DECL_WEAK (t
))
2105 t
= gimple_expr_type (s
);
2106 op
= gimple_assign_rhs_code (s
);
2107 if (get_gimple_rhs_class (op
) == GIMPLE_BINARY_RHS
)
2108 div
= gimple_assign_rhs2 (s
);
2109 return (operation_could_trap_p (op
, FLOAT_TYPE_P (t
),
2110 (INTEGRAL_TYPE_P (t
)
2111 && TYPE_OVERFLOW_TRAPS (t
)),
2115 t
= TREE_TYPE (gimple_cond_lhs (s
));
2116 return operation_could_trap_p (gimple_cond_code (s
),
2117 FLOAT_TYPE_P (t
), false, NULL_TREE
);
2126 /* Return true if statement S can trap. */
2129 gimple_could_trap_p (gimple
*s
)
2131 return gimple_could_trap_p_1 (s
, true, true);
2134 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
2137 gimple_assign_rhs_could_trap_p (gimple
*s
)
2139 gcc_assert (is_gimple_assign (s
));
2140 return gimple_could_trap_p_1 (s
, true, false);
2144 /* Print debugging information for gimple stmts generated. */
2147 dump_gimple_statistics (void)
2150 uint64_t total_tuples
= 0, total_bytes
= 0;
2152 if (! GATHER_STATISTICS
)
2154 fprintf (stderr
, "No GIMPLE statistics\n");
2158 fprintf (stderr
, "\nGIMPLE statements\n");
2159 fprintf (stderr
, "Kind Stmts Bytes\n");
2160 fprintf (stderr
, "---------------------------------------\n");
2161 for (i
= 0; i
< (int) gimple_alloc_kind_all
; ++i
)
2163 fprintf (stderr
, "%-20s %7" PRIu64
"%c %10" PRIu64
"%c\n",
2164 gimple_alloc_kind_names
[i
],
2165 SIZE_AMOUNT (gimple_alloc_counts
[i
]),
2166 SIZE_AMOUNT (gimple_alloc_sizes
[i
]));
2167 total_tuples
+= gimple_alloc_counts
[i
];
2168 total_bytes
+= gimple_alloc_sizes
[i
];
2170 fprintf (stderr
, "---------------------------------------\n");
2171 fprintf (stderr
, "%-20s %7" PRIu64
"%c %10" PRIu64
"%c\n", "Total",
2172 SIZE_AMOUNT (total_tuples
), SIZE_AMOUNT (total_bytes
));
2173 fprintf (stderr
, "---------------------------------------\n");
2177 /* Return the number of operands needed on the RHS of a GIMPLE
2178 assignment for an expression with tree code CODE. */
2181 get_gimple_rhs_num_ops (enum tree_code code
)
2183 enum gimple_rhs_class rhs_class
= get_gimple_rhs_class (code
);
2185 if (rhs_class
== GIMPLE_UNARY_RHS
|| rhs_class
== GIMPLE_SINGLE_RHS
)
2187 else if (rhs_class
== GIMPLE_BINARY_RHS
)
2189 else if (rhs_class
== GIMPLE_TERNARY_RHS
)
2195 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2197 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2198 : ((TYPE) == tcc_binary \
2199 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2200 : ((TYPE) == tcc_constant \
2201 || (TYPE) == tcc_declaration \
2202 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2203 : ((SYM) == TRUTH_AND_EXPR \
2204 || (SYM) == TRUTH_OR_EXPR \
2205 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2206 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2207 : ((SYM) == COND_EXPR \
2208 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2209 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2210 || (SYM) == DOT_PROD_EXPR \
2211 || (SYM) == SAD_EXPR \
2212 || (SYM) == REALIGN_LOAD_EXPR \
2213 || (SYM) == VEC_COND_EXPR \
2214 || (SYM) == VEC_PERM_EXPR \
2215 || (SYM) == BIT_INSERT_EXPR) ? GIMPLE_TERNARY_RHS \
2216 : ((SYM) == CONSTRUCTOR \
2217 || (SYM) == OBJ_TYPE_REF \
2218 || (SYM) == ASSERT_EXPR \
2219 || (SYM) == ADDR_EXPR \
2220 || (SYM) == WITH_SIZE_EXPR \
2221 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2222 : GIMPLE_INVALID_RHS),
2223 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2225 const unsigned char gimple_rhs_class_table
[] = {
2226 #include "all-tree.def"
2230 #undef END_OF_BASE_TREE_CODES
2232 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2233 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2234 we failed to create one. */
2237 canonicalize_cond_expr_cond (tree t
)
2239 /* Strip conversions around boolean operations. */
2240 if (CONVERT_EXPR_P (t
)
2241 && (truth_value_p (TREE_CODE (TREE_OPERAND (t
, 0)))
2242 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
2244 t
= TREE_OPERAND (t
, 0);
2246 /* For !x use x == 0. */
2247 if (TREE_CODE (t
) == TRUTH_NOT_EXPR
)
2249 tree top0
= TREE_OPERAND (t
, 0);
2250 t
= build2 (EQ_EXPR
, TREE_TYPE (t
),
2251 top0
, build_int_cst (TREE_TYPE (top0
), 0));
2253 /* For cmp ? 1 : 0 use cmp. */
2254 else if (TREE_CODE (t
) == COND_EXPR
2255 && COMPARISON_CLASS_P (TREE_OPERAND (t
, 0))
2256 && integer_onep (TREE_OPERAND (t
, 1))
2257 && integer_zerop (TREE_OPERAND (t
, 2)))
2259 tree top0
= TREE_OPERAND (t
, 0);
2260 t
= build2 (TREE_CODE (top0
), TREE_TYPE (t
),
2261 TREE_OPERAND (top0
, 0), TREE_OPERAND (top0
, 1));
2263 /* For x ^ y use x != y. */
2264 else if (TREE_CODE (t
) == BIT_XOR_EXPR
)
2265 t
= build2 (NE_EXPR
, TREE_TYPE (t
),
2266 TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1));
2268 if (is_gimple_condexpr (t
))
2274 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2275 the positions marked by the set ARGS_TO_SKIP. */
2278 gimple_call_copy_skip_args (gcall
*stmt
, bitmap args_to_skip
)
2281 int nargs
= gimple_call_num_args (stmt
);
2282 auto_vec
<tree
> vargs (nargs
);
2285 for (i
= 0; i
< nargs
; i
++)
2286 if (!bitmap_bit_p (args_to_skip
, i
))
2287 vargs
.quick_push (gimple_call_arg (stmt
, i
));
2289 if (gimple_call_internal_p (stmt
))
2290 new_stmt
= gimple_build_call_internal_vec (gimple_call_internal_fn (stmt
),
2293 new_stmt
= gimple_build_call_vec (gimple_call_fn (stmt
), vargs
);
2295 if (gimple_call_lhs (stmt
))
2296 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2298 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2299 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
2301 if (gimple_has_location (stmt
))
2302 gimple_set_location (new_stmt
, gimple_location (stmt
));
2303 gimple_call_copy_flags (new_stmt
, stmt
);
2304 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2306 gimple_set_modified (new_stmt
, true);
2313 /* Return true if the field decls F1 and F2 are at the same offset.
2315 This is intended to be used on GIMPLE types only. */
2318 gimple_compare_field_offset (tree f1
, tree f2
)
2320 if (DECL_OFFSET_ALIGN (f1
) == DECL_OFFSET_ALIGN (f2
))
2322 tree offset1
= DECL_FIELD_OFFSET (f1
);
2323 tree offset2
= DECL_FIELD_OFFSET (f2
);
2324 return ((offset1
== offset2
2325 /* Once gimplification is done, self-referential offsets are
2326 instantiated as operand #2 of the COMPONENT_REF built for
2327 each access and reset. Therefore, they are not relevant
2328 anymore and fields are interchangeable provided that they
2329 represent the same access. */
2330 || (TREE_CODE (offset1
) == PLACEHOLDER_EXPR
2331 && TREE_CODE (offset2
) == PLACEHOLDER_EXPR
2332 && (DECL_SIZE (f1
) == DECL_SIZE (f2
)
2333 || (TREE_CODE (DECL_SIZE (f1
)) == PLACEHOLDER_EXPR
2334 && TREE_CODE (DECL_SIZE (f2
)) == PLACEHOLDER_EXPR
)
2335 || operand_equal_p (DECL_SIZE (f1
), DECL_SIZE (f2
), 0))
2336 && DECL_ALIGN (f1
) == DECL_ALIGN (f2
))
2337 || operand_equal_p (offset1
, offset2
, 0))
2338 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1
),
2339 DECL_FIELD_BIT_OFFSET (f2
)));
2342 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2343 should be, so handle differing ones specially by decomposing
2344 the offset into a byte and bit offset manually. */
2345 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1
))
2346 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2
)))
2348 unsigned HOST_WIDE_INT byte_offset1
, byte_offset2
;
2349 unsigned HOST_WIDE_INT bit_offset1
, bit_offset2
;
2350 bit_offset1
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1
));
2351 byte_offset1
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1
))
2352 + bit_offset1
/ BITS_PER_UNIT
);
2353 bit_offset2
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2
));
2354 byte_offset2
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2
))
2355 + bit_offset2
/ BITS_PER_UNIT
);
2356 if (byte_offset1
!= byte_offset2
)
2358 return bit_offset1
% BITS_PER_UNIT
== bit_offset2
% BITS_PER_UNIT
;
2365 /* Return a type the same as TYPE except unsigned or
2366 signed according to UNSIGNEDP. */
2369 gimple_signed_or_unsigned_type (bool unsignedp
, tree type
)
2374 type1
= TYPE_MAIN_VARIANT (type
);
2375 if (type1
== signed_char_type_node
2376 || type1
== char_type_node
2377 || type1
== unsigned_char_type_node
)
2378 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2379 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2380 return unsignedp
? unsigned_type_node
: integer_type_node
;
2381 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2382 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2383 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2384 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2385 if (type1
== long_long_integer_type_node
2386 || type1
== long_long_unsigned_type_node
)
2388 ? long_long_unsigned_type_node
2389 : long_long_integer_type_node
;
2391 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2392 if (int_n_enabled_p
[i
]
2393 && (type1
== int_n_trees
[i
].unsigned_type
2394 || type1
== int_n_trees
[i
].signed_type
))
2396 ? int_n_trees
[i
].unsigned_type
2397 : int_n_trees
[i
].signed_type
;
2399 #if HOST_BITS_PER_WIDE_INT >= 64
2400 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2401 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2403 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2404 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2405 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2406 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2407 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2408 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2409 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2410 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2412 #define GIMPLE_FIXED_TYPES(NAME) \
2413 if (type1 == short_ ## NAME ## _type_node \
2414 || type1 == unsigned_short_ ## NAME ## _type_node) \
2415 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2416 : short_ ## NAME ## _type_node; \
2417 if (type1 == NAME ## _type_node \
2418 || type1 == unsigned_ ## NAME ## _type_node) \
2419 return unsignedp ? unsigned_ ## NAME ## _type_node \
2420 : NAME ## _type_node; \
2421 if (type1 == long_ ## NAME ## _type_node \
2422 || type1 == unsigned_long_ ## NAME ## _type_node) \
2423 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2424 : long_ ## NAME ## _type_node; \
2425 if (type1 == long_long_ ## NAME ## _type_node \
2426 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2427 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2428 : long_long_ ## NAME ## _type_node;
2430 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2431 if (type1 == NAME ## _type_node \
2432 || type1 == u ## NAME ## _type_node) \
2433 return unsignedp ? u ## NAME ## _type_node \
2434 : NAME ## _type_node;
2436 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2437 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2438 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2439 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2440 : sat_ ## short_ ## NAME ## _type_node; \
2441 if (type1 == sat_ ## NAME ## _type_node \
2442 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2443 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2444 : sat_ ## NAME ## _type_node; \
2445 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2446 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2447 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2448 : sat_ ## long_ ## NAME ## _type_node; \
2449 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2450 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2451 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2452 : sat_ ## long_long_ ## NAME ## _type_node;
2454 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2455 if (type1 == sat_ ## NAME ## _type_node \
2456 || type1 == sat_ ## u ## NAME ## _type_node) \
2457 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2458 : sat_ ## NAME ## _type_node;
2460 GIMPLE_FIXED_TYPES (fract
);
2461 GIMPLE_FIXED_TYPES_SAT (fract
);
2462 GIMPLE_FIXED_TYPES (accum
);
2463 GIMPLE_FIXED_TYPES_SAT (accum
);
2465 GIMPLE_FIXED_MODE_TYPES (qq
);
2466 GIMPLE_FIXED_MODE_TYPES (hq
);
2467 GIMPLE_FIXED_MODE_TYPES (sq
);
2468 GIMPLE_FIXED_MODE_TYPES (dq
);
2469 GIMPLE_FIXED_MODE_TYPES (tq
);
2470 GIMPLE_FIXED_MODE_TYPES_SAT (qq
);
2471 GIMPLE_FIXED_MODE_TYPES_SAT (hq
);
2472 GIMPLE_FIXED_MODE_TYPES_SAT (sq
);
2473 GIMPLE_FIXED_MODE_TYPES_SAT (dq
);
2474 GIMPLE_FIXED_MODE_TYPES_SAT (tq
);
2475 GIMPLE_FIXED_MODE_TYPES (ha
);
2476 GIMPLE_FIXED_MODE_TYPES (sa
);
2477 GIMPLE_FIXED_MODE_TYPES (da
);
2478 GIMPLE_FIXED_MODE_TYPES (ta
);
2479 GIMPLE_FIXED_MODE_TYPES_SAT (ha
);
2480 GIMPLE_FIXED_MODE_TYPES_SAT (sa
);
2481 GIMPLE_FIXED_MODE_TYPES_SAT (da
);
2482 GIMPLE_FIXED_MODE_TYPES_SAT (ta
);
2484 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2485 the precision; they have precision set to match their range, but
2486 may use a wider mode to match an ABI. If we change modes, we may
2487 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2488 the precision as well, so as to yield correct results for
2489 bit-field types. C++ does not have these separate bit-field
2490 types, and producing a signed or unsigned variant of an
2491 ENUMERAL_TYPE may cause other problems as well. */
2492 if (!INTEGRAL_TYPE_P (type
)
2493 || TYPE_UNSIGNED (type
) == unsignedp
)
2496 #define TYPE_OK(node) \
2497 (TYPE_MODE (type) == TYPE_MODE (node) \
2498 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2499 if (TYPE_OK (signed_char_type_node
))
2500 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2501 if (TYPE_OK (integer_type_node
))
2502 return unsignedp
? unsigned_type_node
: integer_type_node
;
2503 if (TYPE_OK (short_integer_type_node
))
2504 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2505 if (TYPE_OK (long_integer_type_node
))
2506 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2507 if (TYPE_OK (long_long_integer_type_node
))
2509 ? long_long_unsigned_type_node
2510 : long_long_integer_type_node
);
2512 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2513 if (int_n_enabled_p
[i
]
2514 && TYPE_MODE (type
) == int_n_data
[i
].m
2515 && TYPE_PRECISION (type
) == int_n_data
[i
].bitsize
)
2517 ? int_n_trees
[i
].unsigned_type
2518 : int_n_trees
[i
].signed_type
;
2520 #if HOST_BITS_PER_WIDE_INT >= 64
2521 if (TYPE_OK (intTI_type_node
))
2522 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2524 if (TYPE_OK (intDI_type_node
))
2525 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2526 if (TYPE_OK (intSI_type_node
))
2527 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2528 if (TYPE_OK (intHI_type_node
))
2529 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2530 if (TYPE_OK (intQI_type_node
))
2531 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2533 #undef GIMPLE_FIXED_TYPES
2534 #undef GIMPLE_FIXED_MODE_TYPES
2535 #undef GIMPLE_FIXED_TYPES_SAT
2536 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2539 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2543 /* Return an unsigned type the same as TYPE in other respects. */
2546 gimple_unsigned_type (tree type
)
2548 return gimple_signed_or_unsigned_type (true, type
);
2552 /* Return a signed type the same as TYPE in other respects. */
2555 gimple_signed_type (tree type
)
2557 return gimple_signed_or_unsigned_type (false, type
);
2561 /* Return the typed-based alias set for T, which may be an expression
2562 or a type. Return -1 if we don't do anything special. */
2565 gimple_get_alias_set (tree t
)
2567 /* That's all the expressions we handle specially. */
2571 /* For convenience, follow the C standard when dealing with
2572 character types. Any object may be accessed via an lvalue that
2573 has character type. */
2574 if (t
== char_type_node
2575 || t
== signed_char_type_node
2576 || t
== unsigned_char_type_node
)
2579 /* Allow aliasing between signed and unsigned variants of the same
2580 type. We treat the signed variant as canonical. */
2581 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2583 tree t1
= gimple_signed_type (t
);
2585 /* t1 == t can happen for boolean nodes which are always unsigned. */
2587 return get_alias_set (t1
);
2594 /* Helper for gimple_ior_addresses_taken_1. */
2597 gimple_ior_addresses_taken_1 (gimple
*, tree addr
, tree
, void *data
)
2599 bitmap addresses_taken
= (bitmap
)data
;
2600 addr
= get_base_address (addr
);
2604 bitmap_set_bit (addresses_taken
, DECL_UID (addr
));
2610 /* Set the bit for the uid of all decls that have their address taken
2611 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2612 were any in this stmt. */
2615 gimple_ior_addresses_taken (bitmap addresses_taken
, gimple
*stmt
)
2617 return walk_stmt_load_store_addr_ops (stmt
, addresses_taken
, NULL
, NULL
,
2618 gimple_ior_addresses_taken_1
);
2622 /* Return true when STMTs arguments and return value match those of FNDECL,
2623 a decl of a builtin function. */
2626 gimple_builtin_call_types_compatible_p (const gimple
*stmt
, tree fndecl
)
2628 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
);
2630 tree ret
= gimple_call_lhs (stmt
);
2632 && !useless_type_conversion_p (TREE_TYPE (ret
),
2633 TREE_TYPE (TREE_TYPE (fndecl
))))
2636 tree targs
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2637 unsigned nargs
= gimple_call_num_args (stmt
);
2638 for (unsigned i
= 0; i
< nargs
; ++i
)
2640 /* Variadic args follow. */
2643 tree arg
= gimple_call_arg (stmt
, i
);
2644 tree type
= TREE_VALUE (targs
);
2645 if (!useless_type_conversion_p (type
, TREE_TYPE (arg
))
2646 /* char/short integral arguments are promoted to int
2647 by several frontends if targetm.calls.promote_prototypes
2648 is true. Allow such promotion too. */
2649 && !(INTEGRAL_TYPE_P (type
)
2650 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)
2651 && targetm
.calls
.promote_prototypes (TREE_TYPE (fndecl
))
2652 && useless_type_conversion_p (integer_type_node
,
2655 targs
= TREE_CHAIN (targs
);
2657 if (targs
&& !VOID_TYPE_P (TREE_VALUE (targs
)))
2662 /* Return true when STMT is builtins call. */
2665 gimple_call_builtin_p (const gimple
*stmt
)
2668 if (is_gimple_call (stmt
)
2669 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2670 && DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
)
2671 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2675 /* Return true when STMT is builtins call to CLASS. */
2678 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_class klass
)
2681 if (is_gimple_call (stmt
)
2682 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2683 && DECL_BUILT_IN_CLASS (fndecl
) == klass
)
2684 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2688 /* Return true when STMT is builtins call to CODE of CLASS. */
2691 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_function code
)
2694 if (is_gimple_call (stmt
)
2695 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2696 && fndecl_built_in_p (fndecl
, code
))
2697 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2701 /* If CALL is a call to a combined_fn (i.e. an internal function or
2702 a normal built-in function), return its code, otherwise return
2706 gimple_call_combined_fn (const gimple
*stmt
)
2708 if (const gcall
*call
= dyn_cast
<const gcall
*> (stmt
))
2710 if (gimple_call_internal_p (call
))
2711 return as_combined_fn (gimple_call_internal_fn (call
));
2713 tree fndecl
= gimple_call_fndecl (stmt
);
2715 && fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
)
2716 && gimple_builtin_call_types_compatible_p (stmt
, fndecl
))
2717 return as_combined_fn (DECL_FUNCTION_CODE (fndecl
));
2722 /* Return true if STMT clobbers memory. STMT is required to be a
2726 gimple_asm_clobbers_memory_p (const gasm
*stmt
)
2730 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
2732 tree op
= gimple_asm_clobber_op (stmt
, i
);
2733 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op
)), "memory") == 0)
2737 /* Non-empty basic ASM implicitly clobbers memory. */
2738 if (gimple_asm_input_p (stmt
) && strlen (gimple_asm_string (stmt
)) != 0)
2744 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2747 dump_decl_set (FILE *file
, bitmap set
)
2754 fprintf (file
, "{ ");
2756 EXECUTE_IF_SET_IN_BITMAP (set
, 0, i
, bi
)
2758 fprintf (file
, "D.%u", i
);
2759 fprintf (file
, " ");
2762 fprintf (file
, "}");
2765 fprintf (file
, "NIL");
2768 /* Return true when CALL is a call stmt that definitely doesn't
2769 free any memory or makes it unavailable otherwise. */
2771 nonfreeing_call_p (gimple
*call
)
2773 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2774 && gimple_call_flags (call
) & ECF_LEAF
)
2775 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call
)))
2777 /* Just in case these become ECF_LEAF in the future. */
2779 case BUILT_IN_TM_FREE
:
2780 case BUILT_IN_REALLOC
:
2781 case BUILT_IN_STACK_RESTORE
:
2786 else if (gimple_call_internal_p (call
))
2787 switch (gimple_call_internal_fn (call
))
2789 case IFN_ABNORMAL_DISPATCHER
:
2792 return tree_to_uhwi (gimple_call_arg (call
, 0)) == ASAN_MARK_UNPOISON
;
2794 if (gimple_call_flags (call
) & ECF_LEAF
)
2799 tree fndecl
= gimple_call_fndecl (call
);
2802 struct cgraph_node
*n
= cgraph_node::get (fndecl
);
2805 enum availability availability
;
2806 n
= n
->function_symbol (&availability
);
2807 if (!n
|| availability
<= AVAIL_INTERPOSABLE
)
2809 return n
->nonfreeing_fn
;
2812 /* Return true when CALL is a call stmt that definitely need not
2813 be considered to be a memory barrier. */
2815 nonbarrier_call_p (gimple
*call
)
2817 if (gimple_call_flags (call
) & (ECF_PURE
| ECF_CONST
))
2819 /* Should extend this to have a nonbarrier_fn flag, just as above in
2820 the nonfreeing case. */
2824 /* Callback for walk_stmt_load_store_ops.
2826 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2829 This routine only makes a superficial check for a dereference. Thus
2830 it must only be used if it is safe to return a false negative. */
2832 check_loadstore (gimple
*, tree op
, tree
, void *data
)
2834 if (TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
2836 /* Some address spaces may legitimately dereference zero. */
2837 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (op
));
2838 if (targetm
.addr_space
.zero_address_valid (as
))
2841 return operand_equal_p (TREE_OPERAND (op
, 0), (tree
)data
, 0);
2847 /* Return true if OP can be inferred to be non-NULL after STMT executes,
2848 either by using a pointer dereference or attributes. */
2850 infer_nonnull_range (gimple
*stmt
, tree op
)
2852 return infer_nonnull_range_by_dereference (stmt
, op
)
2853 || infer_nonnull_range_by_attribute (stmt
, op
);
2856 /* Return true if OP can be inferred to be non-NULL after STMT
2857 executes by using a pointer dereference. */
2859 infer_nonnull_range_by_dereference (gimple
*stmt
, tree op
)
2861 /* We can only assume that a pointer dereference will yield
2862 non-NULL if -fdelete-null-pointer-checks is enabled. */
2863 if (!flag_delete_null_pointer_checks
2864 || !POINTER_TYPE_P (TREE_TYPE (op
))
2865 || gimple_code (stmt
) == GIMPLE_ASM
)
2868 if (walk_stmt_load_store_ops (stmt
, (void *)op
,
2869 check_loadstore
, check_loadstore
))
2875 /* Return true if OP can be inferred to be a non-NULL after STMT
2876 executes by using attributes. */
2878 infer_nonnull_range_by_attribute (gimple
*stmt
, tree op
)
2880 /* We can only assume that a pointer dereference will yield
2881 non-NULL if -fdelete-null-pointer-checks is enabled. */
2882 if (!flag_delete_null_pointer_checks
2883 || !POINTER_TYPE_P (TREE_TYPE (op
))
2884 || gimple_code (stmt
) == GIMPLE_ASM
)
2887 if (is_gimple_call (stmt
) && !gimple_call_internal_p (stmt
))
2889 tree fntype
= gimple_call_fntype (stmt
);
2890 tree attrs
= TYPE_ATTRIBUTES (fntype
);
2891 for (; attrs
; attrs
= TREE_CHAIN (attrs
))
2893 attrs
= lookup_attribute ("nonnull", attrs
);
2895 /* If "nonnull" wasn't specified, we know nothing about
2897 if (attrs
== NULL_TREE
)
2900 /* If "nonnull" applies to all the arguments, then ARG
2901 is non-null if it's in the argument list. */
2902 if (TREE_VALUE (attrs
) == NULL_TREE
)
2904 for (unsigned int i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2906 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt
, i
)))
2907 && operand_equal_p (op
, gimple_call_arg (stmt
, i
), 0))
2913 /* Now see if op appears in the nonnull list. */
2914 for (tree t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
2916 unsigned int idx
= TREE_INT_CST_LOW (TREE_VALUE (t
)) - 1;
2917 if (idx
< gimple_call_num_args (stmt
))
2919 tree arg
= gimple_call_arg (stmt
, idx
);
2920 if (operand_equal_p (op
, arg
, 0))
2927 /* If this function is marked as returning non-null, then we can
2928 infer OP is non-null if it is used in the return statement. */
2929 if (greturn
*return_stmt
= dyn_cast
<greturn
*> (stmt
))
2930 if (gimple_return_retval (return_stmt
)
2931 && operand_equal_p (gimple_return_retval (return_stmt
), op
, 0)
2932 && lookup_attribute ("returns_nonnull",
2933 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
))))
2939 /* Compare two case labels. Because the front end should already have
2940 made sure that case ranges do not overlap, it is enough to only compare
2941 the CASE_LOW values of each case label. */
2944 compare_case_labels (const void *p1
, const void *p2
)
2946 const_tree
const case1
= *(const_tree
const*)p1
;
2947 const_tree
const case2
= *(const_tree
const*)p2
;
2949 /* The 'default' case label always goes first. */
2950 if (!CASE_LOW (case1
))
2952 else if (!CASE_LOW (case2
))
2955 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
2958 /* Sort the case labels in LABEL_VEC in place in ascending order. */
2961 sort_case_labels (vec
<tree
> label_vec
)
2963 label_vec
.qsort (compare_case_labels
);
2966 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2968 LABELS is a vector that contains all case labels to look at.
2970 INDEX_TYPE is the type of the switch index expression. Case labels
2971 in LABELS are discarded if their values are not in the value range
2972 covered by INDEX_TYPE. The remaining case label values are folded
2975 If a default case exists in LABELS, it is removed from LABELS and
2976 returned in DEFAULT_CASEP. If no default case exists, but the
2977 case labels already cover the whole range of INDEX_TYPE, a default
2978 case is returned pointing to one of the existing case labels.
2979 Otherwise DEFAULT_CASEP is set to NULL_TREE.
2981 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2982 apply and no action is taken regardless of whether a default case is
2986 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
2988 tree
*default_casep
)
2990 tree min_value
, max_value
;
2991 tree default_case
= NULL_TREE
;
2995 min_value
= TYPE_MIN_VALUE (index_type
);
2996 max_value
= TYPE_MAX_VALUE (index_type
);
2997 while (i
< labels
.length ())
2999 tree elt
= labels
[i
];
3000 tree low
= CASE_LOW (elt
);
3001 tree high
= CASE_HIGH (elt
);
3002 bool remove_element
= FALSE
;
3006 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
3007 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
3009 /* This is a non-default case label, i.e. it has a value.
3011 See if the case label is reachable within the range of
3012 the index type. Remove out-of-range case values. Turn
3013 case ranges into a canonical form (high > low strictly)
3014 and convert the case label values to the index type.
3016 NB: The type of gimple_switch_index() may be the promoted
3017 type, but the case labels retain the original type. */
3021 /* This is a case range. Discard empty ranges.
3022 If the bounds or the range are equal, turn this
3023 into a simple (one-value) case. */
3024 int cmp
= tree_int_cst_compare (high
, low
);
3026 remove_element
= TRUE
;
3033 /* If the simple case value is unreachable, ignore it. */
3034 if ((TREE_CODE (min_value
) == INTEGER_CST
3035 && tree_int_cst_compare (low
, min_value
) < 0)
3036 || (TREE_CODE (max_value
) == INTEGER_CST
3037 && tree_int_cst_compare (low
, max_value
) > 0))
3038 remove_element
= TRUE
;
3040 low
= fold_convert (index_type
, low
);
3044 /* If the entire case range is unreachable, ignore it. */
3045 if ((TREE_CODE (min_value
) == INTEGER_CST
3046 && tree_int_cst_compare (high
, min_value
) < 0)
3047 || (TREE_CODE (max_value
) == INTEGER_CST
3048 && tree_int_cst_compare (low
, max_value
) > 0))
3049 remove_element
= TRUE
;
3052 /* If the lower bound is less than the index type's
3053 minimum value, truncate the range bounds. */
3054 if (TREE_CODE (min_value
) == INTEGER_CST
3055 && tree_int_cst_compare (low
, min_value
) < 0)
3057 low
= fold_convert (index_type
, low
);
3059 /* If the upper bound is greater than the index type's
3060 maximum value, truncate the range bounds. */
3061 if (TREE_CODE (max_value
) == INTEGER_CST
3062 && tree_int_cst_compare (high
, max_value
) > 0)
3064 high
= fold_convert (index_type
, high
);
3066 /* We may have folded a case range to a one-value case. */
3067 if (tree_int_cst_equal (low
, high
))
3072 CASE_LOW (elt
) = low
;
3073 CASE_HIGH (elt
) = high
;
3077 gcc_assert (!default_case
);
3079 /* The default case must be passed separately to the
3080 gimple_build_switch routine. But if DEFAULT_CASEP
3081 is NULL, we do not remove the default case (it would
3082 be completely lost). */
3084 remove_element
= TRUE
;
3088 labels
.ordered_remove (i
);
3094 if (!labels
.is_empty ())
3095 sort_case_labels (labels
);
3097 if (default_casep
&& !default_case
)
3099 /* If the switch has no default label, add one, so that we jump
3100 around the switch body. If the labels already cover the whole
3101 range of the switch index_type, add the default label pointing
3102 to one of the existing labels. */
3104 && TYPE_MIN_VALUE (index_type
)
3105 && TYPE_MAX_VALUE (index_type
)
3106 && tree_int_cst_equal (CASE_LOW (labels
[0]),
3107 TYPE_MIN_VALUE (index_type
)))
3109 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
3111 high
= CASE_LOW (labels
[len
- 1]);
3112 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
3114 tree widest_label
= labels
[0];
3115 for (i
= 1; i
< len
; i
++)
3117 high
= CASE_LOW (labels
[i
]);
3118 low
= CASE_HIGH (labels
[i
- 1]);
3120 low
= CASE_LOW (labels
[i
- 1]);
3122 if (CASE_HIGH (labels
[i
]) != NULL_TREE
3123 && (CASE_HIGH (widest_label
) == NULL_TREE
3125 (wi::to_wide (CASE_HIGH (labels
[i
]))
3126 - wi::to_wide (CASE_LOW (labels
[i
])),
3127 wi::to_wide (CASE_HIGH (widest_label
))
3128 - wi::to_wide (CASE_LOW (widest_label
))))))
3129 widest_label
= labels
[i
];
3131 if (wi::to_wide (low
) + 1 != wi::to_wide (high
))
3136 /* Designate the label with the widest range to be the
3138 tree label
= CASE_LABEL (widest_label
);
3139 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
3147 *default_casep
= default_case
;
3150 /* Set the location of all statements in SEQ to LOC. */
3153 gimple_seq_set_location (gimple_seq seq
, location_t loc
)
3155 for (gimple_stmt_iterator i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
3156 gimple_set_location (gsi_stmt (i
), loc
);
3159 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
3162 gimple_seq_discard (gimple_seq seq
)
3164 gimple_stmt_iterator gsi
;
3166 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); )
3168 gimple
*stmt
= gsi_stmt (gsi
);
3169 gsi_remove (&gsi
, true);
3170 release_defs (stmt
);
3175 /* See if STMT now calls function that takes no parameters and if so, drop
3176 call arguments. This is used when devirtualization machinery redirects
3177 to __builtin_unreachable or __cxa_pure_virtual. */
3180 maybe_remove_unused_call_args (struct function
*fn
, gimple
*stmt
)
3182 tree decl
= gimple_call_fndecl (stmt
);
3183 if (TYPE_ARG_TYPES (TREE_TYPE (decl
))
3184 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
))) == void_type_node
3185 && gimple_call_num_args (stmt
))
3187 gimple_set_num_ops (stmt
, 3);
3188 update_stmt_fn (fn
, stmt
);
3192 /* Return false if STMT will likely expand to real function call. */
3195 gimple_inexpensive_call_p (gcall
*stmt
)
3197 if (gimple_call_internal_p (stmt
))
3199 tree decl
= gimple_call_fndecl (stmt
);
3200 if (decl
&& is_inexpensive_builtin (decl
))
3207 namespace selftest
{
3209 /* Selftests for core gimple structures. */
3211 /* Verify that STMT is pretty-printed as EXPECTED.
3212 Helper function for selftests. */
3215 verify_gimple_pp (const char *expected
, gimple
*stmt
)
3218 pp_gimple_stmt_1 (&pp
, stmt
, 0 /* spc */, TDF_NONE
/* flags */);
3219 ASSERT_STREQ (expected
, pp_formatted_text (&pp
));
3222 /* Build a GIMPLE_ASSIGN equivalent to
3224 and verify various properties of it. */
3227 test_assign_single ()
3229 tree type
= integer_type_node
;
3230 tree lhs
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3231 get_identifier ("tmp"),
3233 tree rhs
= build_int_cst (type
, 5);
3234 gassign
*stmt
= gimple_build_assign (lhs
, rhs
);
3235 verify_gimple_pp ("tmp = 5;", stmt
);
3237 ASSERT_TRUE (is_gimple_assign (stmt
));
3238 ASSERT_EQ (lhs
, gimple_assign_lhs (stmt
));
3239 ASSERT_EQ (lhs
, gimple_get_lhs (stmt
));
3240 ASSERT_EQ (rhs
, gimple_assign_rhs1 (stmt
));
3241 ASSERT_EQ (NULL
, gimple_assign_rhs2 (stmt
));
3242 ASSERT_EQ (NULL
, gimple_assign_rhs3 (stmt
));
3243 ASSERT_TRUE (gimple_assign_single_p (stmt
));
3244 ASSERT_EQ (INTEGER_CST
, gimple_assign_rhs_code (stmt
));
3247 /* Build a GIMPLE_ASSIGN equivalent to
3249 and verify various properties of it. */
3252 test_assign_binop ()
3254 tree type
= integer_type_node
;
3255 tree lhs
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3256 get_identifier ("tmp"),
3258 tree a
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3259 get_identifier ("a"),
3261 tree b
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3262 get_identifier ("b"),
3264 gassign
*stmt
= gimple_build_assign (lhs
, MULT_EXPR
, a
, b
);
3265 verify_gimple_pp ("tmp = a * b;", stmt
);
3267 ASSERT_TRUE (is_gimple_assign (stmt
));
3268 ASSERT_EQ (lhs
, gimple_assign_lhs (stmt
));
3269 ASSERT_EQ (lhs
, gimple_get_lhs (stmt
));
3270 ASSERT_EQ (a
, gimple_assign_rhs1 (stmt
));
3271 ASSERT_EQ (b
, gimple_assign_rhs2 (stmt
));
3272 ASSERT_EQ (NULL
, gimple_assign_rhs3 (stmt
));
3273 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3274 ASSERT_EQ (MULT_EXPR
, gimple_assign_rhs_code (stmt
));
3277 /* Build a GIMPLE_NOP and verify various properties of it. */
3282 gimple
*stmt
= gimple_build_nop ();
3283 verify_gimple_pp ("GIMPLE_NOP", stmt
);
3284 ASSERT_EQ (GIMPLE_NOP
, gimple_code (stmt
));
3285 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3286 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3289 /* Build a GIMPLE_RETURN equivalent to
3291 and verify various properties of it. */
3296 tree type
= integer_type_node
;
3297 tree val
= build_int_cst (type
, 7);
3298 greturn
*stmt
= gimple_build_return (val
);
3299 verify_gimple_pp ("return 7;", stmt
);
3301 ASSERT_EQ (GIMPLE_RETURN
, gimple_code (stmt
));
3302 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3303 ASSERT_EQ (val
, gimple_return_retval (stmt
));
3304 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3307 /* Build a GIMPLE_RETURN equivalent to
3309 and verify various properties of it. */
3312 test_return_without_value ()
3314 greturn
*stmt
= gimple_build_return (NULL
);
3315 verify_gimple_pp ("return;", stmt
);
3317 ASSERT_EQ (GIMPLE_RETURN
, gimple_code (stmt
));
3318 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3319 ASSERT_EQ (NULL
, gimple_return_retval (stmt
));
3320 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3323 /* Run all of the selftests within this file. */
3328 test_assign_single ();
3329 test_assign_binop ();
3331 test_return_stmt ();
3332 test_return_without_value ();
3335 } // namespace selftest
3338 #endif /* CHECKING_P */