1 /* Gimple IR support functions.
3 Copyright (C) 2007-2016 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"
46 /* All the tuples have their operand vector (if present) at the very bottom
47 of the structure. Therefore, the offset required to find the
48 operands vector the size of the structure minus the size of the 1
49 element tree array at the end (see gimple_ops). */
50 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
51 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
52 EXPORTED_CONST
size_t gimple_ops_offset_
[] = {
53 #include "gsstruct.def"
57 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
58 static const size_t gsstruct_code_size
[] = {
59 #include "gsstruct.def"
63 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
64 const char *const gimple_code_name
[] = {
69 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
70 EXPORTED_CONST
enum gimple_statement_structure_enum gss_for_code_
[] = {
77 int gimple_alloc_counts
[(int) gimple_alloc_kind_all
];
78 int gimple_alloc_sizes
[(int) gimple_alloc_kind_all
];
80 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
81 static const char * const gimple_alloc_kind_names
[] = {
88 /* Static gimple tuple members. */
89 const enum gimple_code
gassign::code_
;
90 const enum gimple_code
gcall::code_
;
91 const enum gimple_code
gcond::code_
;
94 /* Gimple tuple constructors.
95 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
96 be passed a NULL to start with an empty sequence. */
98 /* Set the code for statement G to CODE. */
101 gimple_set_code (gimple
*g
, enum gimple_code code
)
106 /* Return the number of bytes needed to hold a GIMPLE statement with
110 gimple_size (enum gimple_code code
)
112 return gsstruct_code_size
[gss_for_code (code
)];
115 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
119 gimple_alloc_stat (enum gimple_code code
, unsigned num_ops MEM_STAT_DECL
)
124 size
= gimple_size (code
);
126 size
+= sizeof (tree
) * (num_ops
- 1);
128 if (GATHER_STATISTICS
)
130 enum gimple_alloc_kind kind
= gimple_alloc_kind (code
);
131 gimple_alloc_counts
[(int) kind
]++;
132 gimple_alloc_sizes
[(int) kind
] += size
;
135 stmt
= ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT
);
136 gimple_set_code (stmt
, code
);
137 gimple_set_num_ops (stmt
, num_ops
);
139 /* Do not call gimple_set_modified here as it has other side
140 effects and this tuple is still not completely built. */
142 gimple_init_singleton (stmt
);
147 /* Set SUBCODE to be the code of the expression computed by statement G. */
150 gimple_set_subcode (gimple
*g
, unsigned subcode
)
152 /* We only have 16 bits for the RHS code. Assert that we are not
154 gcc_assert (subcode
< (1 << 16));
155 g
->subcode
= subcode
;
160 /* Build a tuple with operands. CODE is the statement to build (which
161 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
162 for the new tuple. NUM_OPS is the number of operands to allocate. */
164 #define gimple_build_with_ops(c, s, n) \
165 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
168 gimple_build_with_ops_stat (enum gimple_code code
, unsigned subcode
,
169 unsigned num_ops MEM_STAT_DECL
)
171 gimple
*s
= gimple_alloc_stat (code
, num_ops PASS_MEM_STAT
);
172 gimple_set_subcode (s
, subcode
);
178 /* Build a GIMPLE_RETURN statement returning RETVAL. */
181 gimple_build_return (tree retval
)
184 = as_a
<greturn
*> (gimple_build_with_ops (GIMPLE_RETURN
, ERROR_MARK
,
187 gimple_return_set_retval (s
, retval
);
191 /* Reset alias information on call S. */
194 gimple_call_reset_alias_info (gcall
*s
)
196 if (gimple_call_flags (s
) & ECF_CONST
)
197 memset (gimple_call_use_set (s
), 0, sizeof (struct pt_solution
));
199 pt_solution_reset (gimple_call_use_set (s
));
200 if (gimple_call_flags (s
) & (ECF_CONST
|ECF_PURE
|ECF_NOVOPS
))
201 memset (gimple_call_clobber_set (s
), 0, sizeof (struct pt_solution
));
203 pt_solution_reset (gimple_call_clobber_set (s
));
206 /* Helper for gimple_build_call, gimple_build_call_valist,
207 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
208 components of a GIMPLE_CALL statement to function FN with NARGS
211 static inline gcall
*
212 gimple_build_call_1 (tree fn
, unsigned nargs
)
215 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
217 if (TREE_CODE (fn
) == FUNCTION_DECL
)
218 fn
= build_fold_addr_expr (fn
);
219 gimple_set_op (s
, 1, fn
);
220 gimple_call_set_fntype (s
, TREE_TYPE (TREE_TYPE (fn
)));
221 gimple_call_reset_alias_info (s
);
226 /* Build a GIMPLE_CALL statement to function FN with the arguments
227 specified in vector ARGS. */
230 gimple_build_call_vec (tree fn
, vec
<tree
> args
)
233 unsigned nargs
= args
.length ();
234 gcall
*call
= gimple_build_call_1 (fn
, nargs
);
236 for (i
= 0; i
< nargs
; i
++)
237 gimple_call_set_arg (call
, i
, args
[i
]);
243 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
244 arguments. The ... are the arguments. */
247 gimple_build_call (tree fn
, unsigned nargs
, ...)
253 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
255 call
= gimple_build_call_1 (fn
, nargs
);
257 va_start (ap
, nargs
);
258 for (i
= 0; i
< nargs
; i
++)
259 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
266 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
267 arguments. AP contains the arguments. */
270 gimple_build_call_valist (tree fn
, unsigned nargs
, va_list ap
)
275 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
|| is_gimple_call_addr (fn
));
277 call
= gimple_build_call_1 (fn
, nargs
);
279 for (i
= 0; i
< nargs
; i
++)
280 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
286 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
287 Build the basic components of a GIMPLE_CALL statement to internal
288 function FN with NARGS arguments. */
290 static inline gcall
*
291 gimple_build_call_internal_1 (enum internal_fn fn
, unsigned nargs
)
294 = as_a
<gcall
*> (gimple_build_with_ops (GIMPLE_CALL
, ERROR_MARK
,
296 s
->subcode
|= GF_CALL_INTERNAL
;
297 gimple_call_set_internal_fn (s
, fn
);
298 gimple_call_reset_alias_info (s
);
303 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
304 the number of arguments. The ... are the arguments. */
307 gimple_build_call_internal (enum internal_fn fn
, unsigned nargs
, ...)
313 call
= gimple_build_call_internal_1 (fn
, nargs
);
314 va_start (ap
, nargs
);
315 for (i
= 0; i
< nargs
; i
++)
316 gimple_call_set_arg (call
, i
, va_arg (ap
, tree
));
323 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
324 specified in vector ARGS. */
327 gimple_build_call_internal_vec (enum internal_fn fn
, vec
<tree
> args
)
332 nargs
= args
.length ();
333 call
= gimple_build_call_internal_1 (fn
, nargs
);
334 for (i
= 0; i
< nargs
; i
++)
335 gimple_call_set_arg (call
, i
, args
[i
]);
341 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
342 assumed to be in GIMPLE form already. Minimal checking is done of
346 gimple_build_call_from_tree (tree t
)
350 tree fndecl
= get_callee_fndecl (t
);
352 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
354 nargs
= call_expr_nargs (t
);
355 call
= gimple_build_call_1 (fndecl
? fndecl
: CALL_EXPR_FN (t
), nargs
);
357 for (i
= 0; i
< nargs
; i
++)
358 gimple_call_set_arg (call
, i
, CALL_EXPR_ARG (t
, i
));
360 gimple_set_block (call
, TREE_BLOCK (t
));
362 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
363 gimple_call_set_chain (call
, CALL_EXPR_STATIC_CHAIN (t
));
364 gimple_call_set_tail (call
, CALL_EXPR_TAILCALL (t
));
365 gimple_call_set_must_tail (call
, CALL_EXPR_MUST_TAIL_CALL (t
));
366 gimple_call_set_return_slot_opt (call
, CALL_EXPR_RETURN_SLOT_OPT (t
));
368 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
369 && (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA
370 || DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
371 gimple_call_set_alloca_for_var (call
, CALL_ALLOCA_FOR_VAR_P (t
));
373 gimple_call_set_from_thunk (call
, CALL_FROM_THUNK_P (t
));
374 gimple_call_set_va_arg_pack (call
, CALL_EXPR_VA_ARG_PACK (t
));
375 gimple_call_set_nothrow (call
, TREE_NOTHROW (t
));
376 gimple_set_no_warning (call
, TREE_NO_WARNING (t
));
377 gimple_call_set_with_bounds (call
, CALL_WITH_BOUNDS_P (t
));
383 /* Build a GIMPLE_ASSIGN statement.
385 LHS of the assignment.
386 RHS of the assignment which can be unary or binary. */
389 gimple_build_assign (tree lhs
, tree rhs MEM_STAT_DECL
)
391 enum tree_code subcode
;
394 extract_ops_from_tree (rhs
, &subcode
, &op1
, &op2
, &op3
);
395 return gimple_build_assign (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
399 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
402 static inline gassign
*
403 gimple_build_assign_1 (tree lhs
, enum tree_code subcode
, tree op1
,
404 tree op2
, tree op3 MEM_STAT_DECL
)
409 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
411 num_ops
= get_gimple_rhs_num_ops (subcode
) + 1;
413 p
= as_a
<gassign
*> (
414 gimple_build_with_ops_stat (GIMPLE_ASSIGN
, (unsigned)subcode
, num_ops
416 gimple_assign_set_lhs (p
, lhs
);
417 gimple_assign_set_rhs1 (p
, op1
);
420 gcc_assert (num_ops
> 2);
421 gimple_assign_set_rhs2 (p
, op2
);
426 gcc_assert (num_ops
> 3);
427 gimple_assign_set_rhs3 (p
, op3
);
433 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
437 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
438 tree op2
, tree op3 MEM_STAT_DECL
)
440 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, op3 PASS_MEM_STAT
);
443 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
447 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1
,
448 tree op2 MEM_STAT_DECL
)
450 return gimple_build_assign_1 (lhs
, subcode
, op1
, op2
, NULL_TREE
454 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
457 gimple_build_assign (tree lhs
, enum tree_code subcode
, tree op1 MEM_STAT_DECL
)
459 return gimple_build_assign_1 (lhs
, subcode
, op1
, NULL_TREE
, NULL_TREE
464 /* Build a GIMPLE_COND statement.
466 PRED is the condition used to compare LHS and the RHS.
467 T_LABEL is the label to jump to if the condition is true.
468 F_LABEL is the label to jump to otherwise. */
471 gimple_build_cond (enum tree_code pred_code
, tree lhs
, tree rhs
,
472 tree t_label
, tree f_label
)
476 gcc_assert (TREE_CODE_CLASS (pred_code
) == tcc_comparison
);
477 p
= as_a
<gcond
*> (gimple_build_with_ops (GIMPLE_COND
, pred_code
, 4));
478 gimple_cond_set_lhs (p
, lhs
);
479 gimple_cond_set_rhs (p
, rhs
);
480 gimple_cond_set_true_label (p
, t_label
);
481 gimple_cond_set_false_label (p
, f_label
);
485 /* Build a GIMPLE_COND statement from the conditional expression tree
486 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
489 gimple_build_cond_from_tree (tree cond
, tree t_label
, tree f_label
)
494 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
495 return gimple_build_cond (code
, lhs
, rhs
, t_label
, f_label
);
498 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
499 boolean expression tree COND. */
502 gimple_cond_set_condition_from_tree (gcond
*stmt
, tree cond
)
507 gimple_cond_get_ops_from_tree (cond
, &code
, &lhs
, &rhs
);
508 gimple_cond_set_condition (stmt
, code
, lhs
, rhs
);
511 /* Build a GIMPLE_LABEL statement for LABEL. */
514 gimple_build_label (tree label
)
517 = as_a
<glabel
*> (gimple_build_with_ops (GIMPLE_LABEL
, ERROR_MARK
, 1));
518 gimple_label_set_label (p
, label
);
522 /* Build a GIMPLE_GOTO statement to label DEST. */
525 gimple_build_goto (tree dest
)
528 = as_a
<ggoto
*> (gimple_build_with_ops (GIMPLE_GOTO
, ERROR_MARK
, 1));
529 gimple_goto_set_dest (p
, dest
);
534 /* Build a GIMPLE_NOP statement. */
537 gimple_build_nop (void)
539 return gimple_alloc (GIMPLE_NOP
, 0);
543 /* Build a GIMPLE_BIND statement.
544 VARS are the variables in BODY.
545 BLOCK is the containing block. */
548 gimple_build_bind (tree vars
, gimple_seq body
, tree block
)
550 gbind
*p
= as_a
<gbind
*> (gimple_alloc (GIMPLE_BIND
, 0));
551 gimple_bind_set_vars (p
, vars
);
553 gimple_bind_set_body (p
, body
);
555 gimple_bind_set_block (p
, block
);
559 /* Helper function to set the simple fields of a asm stmt.
561 STRING is a pointer to a string that is the asm blocks assembly code.
562 NINPUT is the number of register inputs.
563 NOUTPUT is the number of register outputs.
564 NCLOBBERS is the number of clobbered registers.
568 gimple_build_asm_1 (const char *string
, unsigned ninputs
, unsigned noutputs
,
569 unsigned nclobbers
, unsigned nlabels
)
572 int size
= strlen (string
);
574 /* ASMs with labels cannot have outputs. This should have been
575 enforced by the front end. */
576 gcc_assert (nlabels
== 0 || noutputs
== 0);
579 gimple_build_with_ops (GIMPLE_ASM
, ERROR_MARK
,
580 ninputs
+ noutputs
+ nclobbers
+ nlabels
));
586 p
->string
= ggc_alloc_string (string
, size
);
588 if (GATHER_STATISTICS
)
589 gimple_alloc_sizes
[(int) gimple_alloc_kind (GIMPLE_ASM
)] += size
;
594 /* Build a GIMPLE_ASM statement.
596 STRING is the assembly code.
597 NINPUT is the number of register inputs.
598 NOUTPUT is the number of register outputs.
599 NCLOBBERS is the number of clobbered registers.
600 INPUTS is a vector of the input register parameters.
601 OUTPUTS is a vector of the output register parameters.
602 CLOBBERS is a vector of the clobbered register parameters.
603 LABELS is a vector of destination labels. */
606 gimple_build_asm_vec (const char *string
, vec
<tree
, va_gc
> *inputs
,
607 vec
<tree
, va_gc
> *outputs
, vec
<tree
, va_gc
> *clobbers
,
608 vec
<tree
, va_gc
> *labels
)
613 p
= gimple_build_asm_1 (string
,
614 vec_safe_length (inputs
),
615 vec_safe_length (outputs
),
616 vec_safe_length (clobbers
),
617 vec_safe_length (labels
));
619 for (i
= 0; i
< vec_safe_length (inputs
); i
++)
620 gimple_asm_set_input_op (p
, i
, (*inputs
)[i
]);
622 for (i
= 0; i
< vec_safe_length (outputs
); i
++)
623 gimple_asm_set_output_op (p
, i
, (*outputs
)[i
]);
625 for (i
= 0; i
< vec_safe_length (clobbers
); i
++)
626 gimple_asm_set_clobber_op (p
, i
, (*clobbers
)[i
]);
628 for (i
= 0; i
< vec_safe_length (labels
); i
++)
629 gimple_asm_set_label_op (p
, i
, (*labels
)[i
]);
634 /* Build a GIMPLE_CATCH statement.
636 TYPES are the catch types.
637 HANDLER is the exception handler. */
640 gimple_build_catch (tree types
, gimple_seq handler
)
642 gcatch
*p
= as_a
<gcatch
*> (gimple_alloc (GIMPLE_CATCH
, 0));
643 gimple_catch_set_types (p
, types
);
645 gimple_catch_set_handler (p
, handler
);
650 /* Build a GIMPLE_EH_FILTER statement.
652 TYPES are the filter's types.
653 FAILURE is the filter's failure action. */
656 gimple_build_eh_filter (tree types
, gimple_seq failure
)
658 geh_filter
*p
= as_a
<geh_filter
*> (gimple_alloc (GIMPLE_EH_FILTER
, 0));
659 gimple_eh_filter_set_types (p
, types
);
661 gimple_eh_filter_set_failure (p
, failure
);
666 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
669 gimple_build_eh_must_not_throw (tree decl
)
671 geh_mnt
*p
= as_a
<geh_mnt
*> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW
, 0));
673 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
674 gcc_assert (flags_from_decl_or_type (decl
) & ECF_NORETURN
);
675 gimple_eh_must_not_throw_set_fndecl (p
, decl
);
680 /* Build a GIMPLE_EH_ELSE statement. */
683 gimple_build_eh_else (gimple_seq n_body
, gimple_seq e_body
)
685 geh_else
*p
= as_a
<geh_else
*> (gimple_alloc (GIMPLE_EH_ELSE
, 0));
686 gimple_eh_else_set_n_body (p
, n_body
);
687 gimple_eh_else_set_e_body (p
, e_body
);
691 /* Build a GIMPLE_TRY statement.
693 EVAL is the expression to evaluate.
694 CLEANUP is the cleanup expression.
695 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
696 whether this is a try/catch or a try/finally respectively. */
699 gimple_build_try (gimple_seq eval
, gimple_seq cleanup
,
700 enum gimple_try_flags kind
)
704 gcc_assert (kind
== GIMPLE_TRY_CATCH
|| kind
== GIMPLE_TRY_FINALLY
);
705 p
= as_a
<gtry
*> (gimple_alloc (GIMPLE_TRY
, 0));
706 gimple_set_subcode (p
, kind
);
708 gimple_try_set_eval (p
, eval
);
710 gimple_try_set_cleanup (p
, cleanup
);
715 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
717 CLEANUP is the cleanup expression. */
720 gimple_build_wce (gimple_seq cleanup
)
722 gimple
*p
= gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR
, 0);
724 gimple_wce_set_cleanup (p
, cleanup
);
730 /* Build a GIMPLE_RESX statement. */
733 gimple_build_resx (int region
)
736 = as_a
<gresx
*> (gimple_build_with_ops (GIMPLE_RESX
, ERROR_MARK
, 0));
742 /* The helper for constructing a gimple switch statement.
743 INDEX is the switch's index.
744 NLABELS is the number of labels in the switch excluding the default.
745 DEFAULT_LABEL is the default label for the switch statement. */
748 gimple_build_switch_nlabels (unsigned nlabels
, tree index
, tree default_label
)
750 /* nlabels + 1 default label + 1 index. */
751 gcc_checking_assert (default_label
);
752 gswitch
*p
= as_a
<gswitch
*> (gimple_build_with_ops (GIMPLE_SWITCH
,
755 gimple_switch_set_index (p
, index
);
756 gimple_switch_set_default_label (p
, default_label
);
760 /* Build a GIMPLE_SWITCH statement.
762 INDEX is the switch's index.
763 DEFAULT_LABEL is the default label
764 ARGS is a vector of labels excluding the default. */
767 gimple_build_switch (tree index
, tree default_label
, vec
<tree
> args
)
769 unsigned i
, nlabels
= args
.length ();
771 gswitch
*p
= gimple_build_switch_nlabels (nlabels
, index
, default_label
);
773 /* Copy the labels from the vector to the switch statement. */
774 for (i
= 0; i
< nlabels
; i
++)
775 gimple_switch_set_label (p
, i
+ 1, args
[i
]);
780 /* Build a GIMPLE_EH_DISPATCH statement. */
783 gimple_build_eh_dispatch (int region
)
786 = as_a
<geh_dispatch
*> (
787 gimple_build_with_ops (GIMPLE_EH_DISPATCH
, ERROR_MARK
, 0));
792 /* Build a new GIMPLE_DEBUG_BIND statement.
794 VAR is bound to VALUE; block and location are taken from STMT. */
797 gimple_build_debug_bind_stat (tree var
, tree value
, gimple
*stmt MEM_STAT_DECL
)
800 = as_a
<gdebug
*> (gimple_build_with_ops_stat (GIMPLE_DEBUG
,
801 (unsigned)GIMPLE_DEBUG_BIND
, 2
803 gimple_debug_bind_set_var (p
, var
);
804 gimple_debug_bind_set_value (p
, value
);
806 gimple_set_location (p
, gimple_location (stmt
));
812 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
814 VAR is bound to VALUE; block and location are taken from STMT. */
817 gimple_build_debug_source_bind_stat (tree var
, tree value
,
818 gimple
*stmt MEM_STAT_DECL
)
822 gimple_build_with_ops_stat (GIMPLE_DEBUG
,
823 (unsigned)GIMPLE_DEBUG_SOURCE_BIND
, 2
826 gimple_debug_source_bind_set_var (p
, var
);
827 gimple_debug_source_bind_set_value (p
, value
);
829 gimple_set_location (p
, gimple_location (stmt
));
835 /* Build a GIMPLE_OMP_CRITICAL statement.
837 BODY is the sequence of statements for which only one thread can execute.
838 NAME is optional identifier for this critical block.
839 CLAUSES are clauses for this critical block. */
842 gimple_build_omp_critical (gimple_seq body
, tree name
, tree clauses
)
845 = as_a
<gomp_critical
*> (gimple_alloc (GIMPLE_OMP_CRITICAL
, 0));
846 gimple_omp_critical_set_name (p
, name
);
847 gimple_omp_critical_set_clauses (p
, clauses
);
849 gimple_omp_set_body (p
, body
);
854 /* Build a GIMPLE_OMP_FOR statement.
856 BODY is sequence of statements inside the for loop.
857 KIND is the `for' variant.
858 CLAUSES, are any of the construct's clauses.
859 COLLAPSE is the collapse count.
860 PRE_BODY is the sequence of statements that are loop invariant. */
863 gimple_build_omp_for (gimple_seq body
, int kind
, tree clauses
, size_t collapse
,
866 gomp_for
*p
= as_a
<gomp_for
*> (gimple_alloc (GIMPLE_OMP_FOR
, 0));
868 gimple_omp_set_body (p
, body
);
869 gimple_omp_for_set_clauses (p
, clauses
);
870 gimple_omp_for_set_kind (p
, kind
);
871 p
->collapse
= collapse
;
872 p
->iter
= ggc_cleared_vec_alloc
<gimple_omp_for_iter
> (collapse
);
875 gimple_omp_for_set_pre_body (p
, pre_body
);
881 /* Build a GIMPLE_OMP_PARALLEL statement.
883 BODY is sequence of statements which are executed in parallel.
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). */
889 gimple_build_omp_parallel (gimple_seq body
, tree clauses
, tree child_fn
,
893 = as_a
<gomp_parallel
*> (gimple_alloc (GIMPLE_OMP_PARALLEL
, 0));
895 gimple_omp_set_body (p
, body
);
896 gimple_omp_parallel_set_clauses (p
, clauses
);
897 gimple_omp_parallel_set_child_fn (p
, child_fn
);
898 gimple_omp_parallel_set_data_arg (p
, data_arg
);
904 /* Build a GIMPLE_OMP_TASK statement.
906 BODY is sequence of statements which are executed by the explicit task.
907 CLAUSES, are the OMP parallel construct's clauses.
908 CHILD_FN is the function created for the parallel threads to execute.
909 DATA_ARG are the shared data argument(s).
910 COPY_FN is the optional function for firstprivate initialization.
911 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
914 gimple_build_omp_task (gimple_seq body
, tree clauses
, tree child_fn
,
915 tree data_arg
, tree copy_fn
, tree arg_size
,
918 gomp_task
*p
= as_a
<gomp_task
*> (gimple_alloc (GIMPLE_OMP_TASK
, 0));
920 gimple_omp_set_body (p
, body
);
921 gimple_omp_task_set_clauses (p
, clauses
);
922 gimple_omp_task_set_child_fn (p
, child_fn
);
923 gimple_omp_task_set_data_arg (p
, data_arg
);
924 gimple_omp_task_set_copy_fn (p
, copy_fn
);
925 gimple_omp_task_set_arg_size (p
, arg_size
);
926 gimple_omp_task_set_arg_align (p
, arg_align
);
932 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
934 BODY is the sequence of statements in the section. */
937 gimple_build_omp_section (gimple_seq body
)
939 gimple
*p
= gimple_alloc (GIMPLE_OMP_SECTION
, 0);
941 gimple_omp_set_body (p
, body
);
947 /* Build a GIMPLE_OMP_MASTER statement.
949 BODY is the sequence of statements to be executed by just the master. */
952 gimple_build_omp_master (gimple_seq body
)
954 gimple
*p
= gimple_alloc (GIMPLE_OMP_MASTER
, 0);
956 gimple_omp_set_body (p
, body
);
961 /* Build a GIMPLE_OMP_GRID_BODY statement.
963 BODY is the sequence of statements to be executed by the kernel. */
966 gimple_build_omp_grid_body (gimple_seq body
)
968 gimple
*p
= gimple_alloc (GIMPLE_OMP_GRID_BODY
, 0);
970 gimple_omp_set_body (p
, body
);
975 /* Build a GIMPLE_OMP_TASKGROUP statement.
977 BODY is the sequence of statements to be executed by the taskgroup
981 gimple_build_omp_taskgroup (gimple_seq body
)
983 gimple
*p
= gimple_alloc (GIMPLE_OMP_TASKGROUP
, 0);
985 gimple_omp_set_body (p
, body
);
991 /* Build a GIMPLE_OMP_CONTINUE statement.
993 CONTROL_DEF is the definition of the control variable.
994 CONTROL_USE is the use of the control variable. */
997 gimple_build_omp_continue (tree control_def
, tree control_use
)
1000 = as_a
<gomp_continue
*> (gimple_alloc (GIMPLE_OMP_CONTINUE
, 0));
1001 gimple_omp_continue_set_control_def (p
, control_def
);
1002 gimple_omp_continue_set_control_use (p
, control_use
);
1006 /* Build a GIMPLE_OMP_ORDERED statement.
1008 BODY is the sequence of statements inside a loop that will executed in
1010 CLAUSES are clauses for this statement. */
1013 gimple_build_omp_ordered (gimple_seq body
, tree clauses
)
1016 = as_a
<gomp_ordered
*> (gimple_alloc (GIMPLE_OMP_ORDERED
, 0));
1017 gimple_omp_ordered_set_clauses (p
, clauses
);
1019 gimple_omp_set_body (p
, body
);
1025 /* Build a GIMPLE_OMP_RETURN statement.
1026 WAIT_P is true if this is a non-waiting return. */
1029 gimple_build_omp_return (bool wait_p
)
1031 gimple
*p
= gimple_alloc (GIMPLE_OMP_RETURN
, 0);
1033 gimple_omp_return_set_nowait (p
);
1039 /* Build a GIMPLE_OMP_SECTIONS statement.
1041 BODY is a sequence of section statements.
1042 CLAUSES are any of the OMP sections contsruct's clauses: private,
1043 firstprivate, lastprivate, reduction, and nowait. */
1046 gimple_build_omp_sections (gimple_seq body
, tree clauses
)
1049 = as_a
<gomp_sections
*> (gimple_alloc (GIMPLE_OMP_SECTIONS
, 0));
1051 gimple_omp_set_body (p
, body
);
1052 gimple_omp_sections_set_clauses (p
, clauses
);
1058 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1061 gimple_build_omp_sections_switch (void)
1063 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH
, 0);
1067 /* Build a GIMPLE_OMP_SINGLE statement.
1069 BODY is the sequence of statements that will be executed once.
1070 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1071 copyprivate, nowait. */
1074 gimple_build_omp_single (gimple_seq body
, tree clauses
)
1077 = as_a
<gomp_single
*> (gimple_alloc (GIMPLE_OMP_SINGLE
, 0));
1079 gimple_omp_set_body (p
, body
);
1080 gimple_omp_single_set_clauses (p
, clauses
);
1086 /* Build a GIMPLE_OMP_TARGET statement.
1088 BODY is the sequence of statements that will be executed.
1089 KIND is the kind of the region.
1090 CLAUSES are any of the construct's clauses. */
1093 gimple_build_omp_target (gimple_seq body
, int kind
, tree clauses
)
1096 = as_a
<gomp_target
*> (gimple_alloc (GIMPLE_OMP_TARGET
, 0));
1098 gimple_omp_set_body (p
, body
);
1099 gimple_omp_target_set_clauses (p
, clauses
);
1100 gimple_omp_target_set_kind (p
, kind
);
1106 /* Build a GIMPLE_OMP_TEAMS statement.
1108 BODY is the sequence of statements that will be executed.
1109 CLAUSES are any of the OMP teams construct's clauses. */
1112 gimple_build_omp_teams (gimple_seq body
, tree clauses
)
1114 gomp_teams
*p
= as_a
<gomp_teams
*> (gimple_alloc (GIMPLE_OMP_TEAMS
, 0));
1116 gimple_omp_set_body (p
, body
);
1117 gimple_omp_teams_set_clauses (p
, clauses
);
1123 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1126 gimple_build_omp_atomic_load (tree lhs
, tree rhs
)
1129 = as_a
<gomp_atomic_load
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD
, 0));
1130 gimple_omp_atomic_load_set_lhs (p
, lhs
);
1131 gimple_omp_atomic_load_set_rhs (p
, rhs
);
1135 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1137 VAL is the value we are storing. */
1140 gimple_build_omp_atomic_store (tree val
)
1142 gomp_atomic_store
*p
1143 = as_a
<gomp_atomic_store
*> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE
, 0));
1144 gimple_omp_atomic_store_set_val (p
, val
);
1148 /* Build a GIMPLE_TRANSACTION statement. */
1151 gimple_build_transaction (gimple_seq body
)
1154 = as_a
<gtransaction
*> (gimple_alloc (GIMPLE_TRANSACTION
, 0));
1155 gimple_transaction_set_body (p
, body
);
1156 gimple_transaction_set_label_norm (p
, 0);
1157 gimple_transaction_set_label_uninst (p
, 0);
1158 gimple_transaction_set_label_over (p
, 0);
1162 #if defined ENABLE_GIMPLE_CHECKING
1163 /* Complain of a gimple type mismatch and die. */
1166 gimple_check_failed (const gimple
*gs
, const char *file
, int line
,
1167 const char *function
, enum gimple_code code
,
1168 enum tree_code subcode
)
1170 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1171 gimple_code_name
[code
],
1172 get_tree_code_name (subcode
),
1173 gimple_code_name
[gimple_code (gs
)],
1175 ? get_tree_code_name ((enum tree_code
) gs
->subcode
)
1177 function
, trim_filename (file
), line
);
1179 #endif /* ENABLE_GIMPLE_CHECKING */
1182 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1183 *SEQ_P is NULL, a new sequence is allocated. */
1186 gimple_seq_add_stmt (gimple_seq
*seq_p
, gimple
*gs
)
1188 gimple_stmt_iterator si
;
1192 si
= gsi_last (*seq_p
);
1193 gsi_insert_after (&si
, gs
, GSI_NEW_STMT
);
1196 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1197 *SEQ_P is NULL, a new sequence is allocated. This function is
1198 similar to gimple_seq_add_stmt, but does not scan the operands.
1199 During gimplification, we need to manipulate statement sequences
1200 before the def/use vectors have been constructed. */
1203 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple
*gs
)
1205 gimple_stmt_iterator si
;
1210 si
= gsi_last (*seq_p
);
1211 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
1214 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1215 NULL, a new sequence is allocated. */
1218 gimple_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
1220 gimple_stmt_iterator si
;
1224 si
= gsi_last (*dst_p
);
1225 gsi_insert_seq_after (&si
, src
, GSI_NEW_STMT
);
1228 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1229 NULL, a new sequence is allocated. This function is
1230 similar to gimple_seq_add_seq, but does not scan the operands. */
1233 gimple_seq_add_seq_without_update (gimple_seq
*dst_p
, gimple_seq src
)
1235 gimple_stmt_iterator si
;
1239 si
= gsi_last (*dst_p
);
1240 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
1243 /* Determine whether to assign a location to the statement GS. */
1246 should_carry_location_p (gimple
*gs
)
1248 /* Don't emit a line note for a label. We particularly don't want to
1249 emit one for the break label, since it doesn't actually correspond
1250 to the beginning of the loop/switch. */
1251 if (gimple_code (gs
) == GIMPLE_LABEL
)
1257 /* Set the location for gimple statement GS to LOCATION. */
1260 annotate_one_with_location (gimple
*gs
, location_t location
)
1262 if (!gimple_has_location (gs
)
1263 && !gimple_do_not_emit_location_p (gs
)
1264 && should_carry_location_p (gs
))
1265 gimple_set_location (gs
, location
);
1268 /* Set LOCATION for all the statements after iterator GSI in sequence
1269 SEQ. If GSI is pointing to the end of the sequence, start with the
1270 first statement in SEQ. */
1273 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
1274 location_t location
)
1276 if (gsi_end_p (gsi
))
1277 gsi
= gsi_start (seq
);
1281 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
1282 annotate_one_with_location (gsi_stmt (gsi
), location
);
1285 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1288 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
1290 gimple_stmt_iterator i
;
1292 if (gimple_seq_empty_p (stmt_p
))
1295 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
1297 gimple
*gs
= gsi_stmt (i
);
1298 annotate_one_with_location (gs
, location
);
1302 /* Helper function of empty_body_p. Return true if STMT is an empty
1306 empty_stmt_p (gimple
*stmt
)
1308 if (gimple_code (stmt
) == GIMPLE_NOP
)
1310 if (gbind
*bind_stmt
= dyn_cast
<gbind
*> (stmt
))
1311 return empty_body_p (gimple_bind_body (bind_stmt
));
1316 /* Return true if BODY contains nothing but empty statements. */
1319 empty_body_p (gimple_seq body
)
1321 gimple_stmt_iterator i
;
1323 if (gimple_seq_empty_p (body
))
1325 for (i
= gsi_start (body
); !gsi_end_p (i
); gsi_next (&i
))
1326 if (!empty_stmt_p (gsi_stmt (i
))
1327 && !is_gimple_debug (gsi_stmt (i
)))
1334 /* Perform a deep copy of sequence SRC and return the result. */
1337 gimple_seq_copy (gimple_seq src
)
1339 gimple_stmt_iterator gsi
;
1340 gimple_seq new_seq
= NULL
;
1343 for (gsi
= gsi_start (src
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1345 stmt
= gimple_copy (gsi_stmt (gsi
));
1346 gimple_seq_add_stmt (&new_seq
, stmt
);
1354 /* Return true if calls C1 and C2 are known to go to the same function. */
1357 gimple_call_same_target_p (const gimple
*c1
, const gimple
*c2
)
1359 if (gimple_call_internal_p (c1
))
1360 return (gimple_call_internal_p (c2
)
1361 && gimple_call_internal_fn (c1
) == gimple_call_internal_fn (c2
)
1362 && (!gimple_call_internal_unique_p (as_a
<const gcall
*> (c1
))
1365 return (gimple_call_fn (c1
) == gimple_call_fn (c2
)
1366 || (gimple_call_fndecl (c1
)
1367 && gimple_call_fndecl (c1
) == gimple_call_fndecl (c2
)));
1370 /* Detect flags from a GIMPLE_CALL. This is just like
1371 call_expr_flags, but for gimple tuples. */
1374 gimple_call_flags (const gimple
*stmt
)
1377 tree decl
= gimple_call_fndecl (stmt
);
1380 flags
= flags_from_decl_or_type (decl
);
1381 else if (gimple_call_internal_p (stmt
))
1382 flags
= internal_fn_flags (gimple_call_internal_fn (stmt
));
1384 flags
= flags_from_decl_or_type (gimple_call_fntype (stmt
));
1386 if (stmt
->subcode
& GF_CALL_NOTHROW
)
1387 flags
|= ECF_NOTHROW
;
1392 /* Return the "fn spec" string for call STMT. */
1395 gimple_call_fnspec (const gcall
*stmt
)
1399 if (gimple_call_internal_p (stmt
))
1400 return internal_fn_fnspec (gimple_call_internal_fn (stmt
));
1402 type
= gimple_call_fntype (stmt
);
1406 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
1410 return TREE_VALUE (TREE_VALUE (attr
));
1413 /* Detects argument flags for argument number ARG on call STMT. */
1416 gimple_call_arg_flags (const gcall
*stmt
, unsigned arg
)
1418 const_tree attr
= gimple_call_fnspec (stmt
);
1420 if (!attr
|| 1 + arg
>= (unsigned) TREE_STRING_LENGTH (attr
))
1423 switch (TREE_STRING_POINTER (attr
)[1 + arg
])
1430 return EAF_DIRECT
| EAF_NOCLOBBER
| EAF_NOESCAPE
;
1433 return EAF_NOCLOBBER
| EAF_NOESCAPE
;
1436 return EAF_DIRECT
| EAF_NOESCAPE
;
1439 return EAF_NOESCAPE
;
1447 /* Detects return flags for the call STMT. */
1450 gimple_call_return_flags (const gcall
*stmt
)
1454 if (gimple_call_flags (stmt
) & ECF_MALLOC
)
1457 attr
= gimple_call_fnspec (stmt
);
1458 if (!attr
|| TREE_STRING_LENGTH (attr
) < 1)
1461 switch (TREE_STRING_POINTER (attr
)[0])
1467 return ERF_RETURNS_ARG
| (TREE_STRING_POINTER (attr
)[0] - '1');
1479 /* Return true if GS is a copy assignment. */
1482 gimple_assign_copy_p (gimple
*gs
)
1484 return (gimple_assign_single_p (gs
)
1485 && is_gimple_val (gimple_op (gs
, 1)));
1489 /* Return true if GS is a SSA_NAME copy assignment. */
1492 gimple_assign_ssa_name_copy_p (gimple
*gs
)
1494 return (gimple_assign_single_p (gs
)
1495 && TREE_CODE (gimple_assign_lhs (gs
)) == SSA_NAME
1496 && TREE_CODE (gimple_assign_rhs1 (gs
)) == SSA_NAME
);
1500 /* Return true if GS is an assignment with a unary RHS, but the
1501 operator has no effect on the assigned value. The logic is adapted
1502 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1503 instances in which STRIP_NOPS was previously applied to the RHS of
1506 NOTE: In the use cases that led to the creation of this function
1507 and of gimple_assign_single_p, it is typical to test for either
1508 condition and to proceed in the same manner. In each case, the
1509 assigned value is represented by the single RHS operand of the
1510 assignment. I suspect there may be cases where gimple_assign_copy_p,
1511 gimple_assign_single_p, or equivalent logic is used where a similar
1512 treatment of unary NOPs is appropriate. */
1515 gimple_assign_unary_nop_p (gimple
*gs
)
1517 return (is_gimple_assign (gs
)
1518 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs
))
1519 || gimple_assign_rhs_code (gs
) == NON_LVALUE_EXPR
)
1520 && gimple_assign_rhs1 (gs
) != error_mark_node
1521 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs
)))
1522 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs
)))));
1525 /* Set BB to be the basic block holding G. */
1528 gimple_set_bb (gimple
*stmt
, basic_block bb
)
1532 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1535 /* If the statement is a label, add the label to block-to-labels map
1536 so that we can speed up edge creation for GIMPLE_GOTOs. */
1542 t
= gimple_label_label (as_a
<glabel
*> (stmt
));
1543 uid
= LABEL_DECL_UID (t
);
1547 vec_safe_length (label_to_block_map_for_fn (cfun
));
1548 LABEL_DECL_UID (t
) = uid
= cfun
->cfg
->last_label_uid
++;
1549 if (old_len
<= (unsigned) uid
)
1551 unsigned new_len
= 3 * uid
/ 2 + 1;
1553 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun
),
1558 (*label_to_block_map_for_fn (cfun
))[uid
] = bb
;
1563 /* Modify the RHS of the assignment pointed-to by GSI using the
1564 operands in the expression tree EXPR.
1566 NOTE: The statement pointed-to by GSI may be reallocated if it
1567 did not have enough operand slots.
1569 This function is useful to convert an existing tree expression into
1570 the flat representation used for the RHS of a GIMPLE assignment.
1571 It will reallocate memory as needed to expand or shrink the number
1572 of operand slots needed to represent EXPR.
1574 NOTE: If you find yourself building a tree and then calling this
1575 function, you are most certainly doing it the slow way. It is much
1576 better to build a new assignment or to use the function
1577 gimple_assign_set_rhs_with_ops, which does not require an
1578 expression tree to be built. */
1581 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*gsi
, tree expr
)
1583 enum tree_code subcode
;
1586 extract_ops_from_tree (expr
, &subcode
, &op1
, &op2
, &op3
);
1587 gimple_assign_set_rhs_with_ops (gsi
, subcode
, op1
, op2
, op3
);
1591 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1592 operands OP1, OP2 and OP3.
1594 NOTE: The statement pointed-to by GSI may be reallocated if it
1595 did not have enough operand slots. */
1598 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*gsi
, enum tree_code code
,
1599 tree op1
, tree op2
, tree op3
)
1601 unsigned new_rhs_ops
= get_gimple_rhs_num_ops (code
);
1602 gimple
*stmt
= gsi_stmt (*gsi
);
1604 /* If the new CODE needs more operands, allocate a new statement. */
1605 if (gimple_num_ops (stmt
) < new_rhs_ops
+ 1)
1607 tree lhs
= gimple_assign_lhs (stmt
);
1608 gimple
*new_stmt
= gimple_alloc (gimple_code (stmt
), new_rhs_ops
+ 1);
1609 memcpy (new_stmt
, stmt
, gimple_size (gimple_code (stmt
)));
1610 gimple_init_singleton (new_stmt
);
1611 gsi_replace (gsi
, new_stmt
, true);
1614 /* The LHS needs to be reset as this also changes the SSA name
1616 gimple_assign_set_lhs (stmt
, lhs
);
1619 gimple_set_num_ops (stmt
, new_rhs_ops
+ 1);
1620 gimple_set_subcode (stmt
, code
);
1621 gimple_assign_set_rhs1 (stmt
, op1
);
1622 if (new_rhs_ops
> 1)
1623 gimple_assign_set_rhs2 (stmt
, op2
);
1624 if (new_rhs_ops
> 2)
1625 gimple_assign_set_rhs3 (stmt
, op3
);
1629 /* Return the LHS of a statement that performs an assignment,
1630 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1631 for a call to a function that returns no value, or for a
1632 statement other than an assignment or a call. */
1635 gimple_get_lhs (const gimple
*stmt
)
1637 enum gimple_code code
= gimple_code (stmt
);
1639 if (code
== GIMPLE_ASSIGN
)
1640 return gimple_assign_lhs (stmt
);
1641 else if (code
== GIMPLE_CALL
)
1642 return gimple_call_lhs (stmt
);
1648 /* Set the LHS of a statement that performs an assignment,
1649 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1652 gimple_set_lhs (gimple
*stmt
, tree lhs
)
1654 enum gimple_code code
= gimple_code (stmt
);
1656 if (code
== GIMPLE_ASSIGN
)
1657 gimple_assign_set_lhs (stmt
, lhs
);
1658 else if (code
== GIMPLE_CALL
)
1659 gimple_call_set_lhs (stmt
, lhs
);
1665 /* Return a deep copy of statement STMT. All the operands from STMT
1666 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1667 and VUSE operand arrays are set to empty in the new copy. The new
1668 copy isn't part of any sequence. */
1671 gimple_copy (gimple
*stmt
)
1673 enum gimple_code code
= gimple_code (stmt
);
1674 unsigned num_ops
= gimple_num_ops (stmt
);
1675 gimple
*copy
= gimple_alloc (code
, num_ops
);
1678 /* Shallow copy all the fields from STMT. */
1679 memcpy (copy
, stmt
, gimple_size (code
));
1680 gimple_init_singleton (copy
);
1682 /* If STMT has sub-statements, deep-copy them as well. */
1683 if (gimple_has_substatements (stmt
))
1688 switch (gimple_code (stmt
))
1692 gbind
*bind_stmt
= as_a
<gbind
*> (stmt
);
1693 gbind
*bind_copy
= as_a
<gbind
*> (copy
);
1694 new_seq
= gimple_seq_copy (gimple_bind_body (bind_stmt
));
1695 gimple_bind_set_body (bind_copy
, new_seq
);
1696 gimple_bind_set_vars (bind_copy
,
1697 unshare_expr (gimple_bind_vars (bind_stmt
)));
1698 gimple_bind_set_block (bind_copy
, gimple_bind_block (bind_stmt
));
1704 gcatch
*catch_stmt
= as_a
<gcatch
*> (stmt
);
1705 gcatch
*catch_copy
= as_a
<gcatch
*> (copy
);
1706 new_seq
= gimple_seq_copy (gimple_catch_handler (catch_stmt
));
1707 gimple_catch_set_handler (catch_copy
, new_seq
);
1708 t
= unshare_expr (gimple_catch_types (catch_stmt
));
1709 gimple_catch_set_types (catch_copy
, t
);
1713 case GIMPLE_EH_FILTER
:
1715 geh_filter
*eh_filter_stmt
= as_a
<geh_filter
*> (stmt
);
1716 geh_filter
*eh_filter_copy
= as_a
<geh_filter
*> (copy
);
1718 = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt
));
1719 gimple_eh_filter_set_failure (eh_filter_copy
, new_seq
);
1720 t
= unshare_expr (gimple_eh_filter_types (eh_filter_stmt
));
1721 gimple_eh_filter_set_types (eh_filter_copy
, t
);
1725 case GIMPLE_EH_ELSE
:
1727 geh_else
*eh_else_stmt
= as_a
<geh_else
*> (stmt
);
1728 geh_else
*eh_else_copy
= as_a
<geh_else
*> (copy
);
1729 new_seq
= gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt
));
1730 gimple_eh_else_set_n_body (eh_else_copy
, new_seq
);
1731 new_seq
= gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt
));
1732 gimple_eh_else_set_e_body (eh_else_copy
, new_seq
);
1738 gtry
*try_stmt
= as_a
<gtry
*> (stmt
);
1739 gtry
*try_copy
= as_a
<gtry
*> (copy
);
1740 new_seq
= gimple_seq_copy (gimple_try_eval (try_stmt
));
1741 gimple_try_set_eval (try_copy
, new_seq
);
1742 new_seq
= gimple_seq_copy (gimple_try_cleanup (try_stmt
));
1743 gimple_try_set_cleanup (try_copy
, new_seq
);
1747 case GIMPLE_OMP_FOR
:
1748 new_seq
= gimple_seq_copy (gimple_omp_for_pre_body (stmt
));
1749 gimple_omp_for_set_pre_body (copy
, new_seq
);
1750 t
= unshare_expr (gimple_omp_for_clauses (stmt
));
1751 gimple_omp_for_set_clauses (copy
, t
);
1753 gomp_for
*omp_for_copy
= as_a
<gomp_for
*> (copy
);
1754 omp_for_copy
->iter
= ggc_vec_alloc
<gimple_omp_for_iter
>
1755 ( gimple_omp_for_collapse (stmt
));
1757 for (i
= 0; i
< gimple_omp_for_collapse (stmt
); i
++)
1759 gimple_omp_for_set_cond (copy
, i
,
1760 gimple_omp_for_cond (stmt
, i
));
1761 gimple_omp_for_set_index (copy
, i
,
1762 gimple_omp_for_index (stmt
, i
));
1763 t
= unshare_expr (gimple_omp_for_initial (stmt
, i
));
1764 gimple_omp_for_set_initial (copy
, i
, t
);
1765 t
= unshare_expr (gimple_omp_for_final (stmt
, i
));
1766 gimple_omp_for_set_final (copy
, i
, t
);
1767 t
= unshare_expr (gimple_omp_for_incr (stmt
, i
));
1768 gimple_omp_for_set_incr (copy
, i
, t
);
1772 case GIMPLE_OMP_PARALLEL
:
1774 gomp_parallel
*omp_par_stmt
= as_a
<gomp_parallel
*> (stmt
);
1775 gomp_parallel
*omp_par_copy
= as_a
<gomp_parallel
*> (copy
);
1776 t
= unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt
));
1777 gimple_omp_parallel_set_clauses (omp_par_copy
, t
);
1778 t
= unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt
));
1779 gimple_omp_parallel_set_child_fn (omp_par_copy
, t
);
1780 t
= unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt
));
1781 gimple_omp_parallel_set_data_arg (omp_par_copy
, t
);
1785 case GIMPLE_OMP_TASK
:
1786 t
= unshare_expr (gimple_omp_task_clauses (stmt
));
1787 gimple_omp_task_set_clauses (copy
, t
);
1788 t
= unshare_expr (gimple_omp_task_child_fn (stmt
));
1789 gimple_omp_task_set_child_fn (copy
, t
);
1790 t
= unshare_expr (gimple_omp_task_data_arg (stmt
));
1791 gimple_omp_task_set_data_arg (copy
, t
);
1792 t
= unshare_expr (gimple_omp_task_copy_fn (stmt
));
1793 gimple_omp_task_set_copy_fn (copy
, t
);
1794 t
= unshare_expr (gimple_omp_task_arg_size (stmt
));
1795 gimple_omp_task_set_arg_size (copy
, t
);
1796 t
= unshare_expr (gimple_omp_task_arg_align (stmt
));
1797 gimple_omp_task_set_arg_align (copy
, t
);
1800 case GIMPLE_OMP_CRITICAL
:
1801 t
= unshare_expr (gimple_omp_critical_name
1802 (as_a
<gomp_critical
*> (stmt
)));
1803 gimple_omp_critical_set_name (as_a
<gomp_critical
*> (copy
), t
);
1804 t
= unshare_expr (gimple_omp_critical_clauses
1805 (as_a
<gomp_critical
*> (stmt
)));
1806 gimple_omp_critical_set_clauses (as_a
<gomp_critical
*> (copy
), t
);
1809 case GIMPLE_OMP_ORDERED
:
1810 t
= unshare_expr (gimple_omp_ordered_clauses
1811 (as_a
<gomp_ordered
*> (stmt
)));
1812 gimple_omp_ordered_set_clauses (as_a
<gomp_ordered
*> (copy
), t
);
1815 case GIMPLE_OMP_SECTIONS
:
1816 t
= unshare_expr (gimple_omp_sections_clauses (stmt
));
1817 gimple_omp_sections_set_clauses (copy
, t
);
1818 t
= unshare_expr (gimple_omp_sections_control (stmt
));
1819 gimple_omp_sections_set_control (copy
, t
);
1822 case GIMPLE_OMP_SINGLE
:
1823 case GIMPLE_OMP_TARGET
:
1824 case GIMPLE_OMP_TEAMS
:
1825 case GIMPLE_OMP_SECTION
:
1826 case GIMPLE_OMP_MASTER
:
1827 case GIMPLE_OMP_TASKGROUP
:
1828 case GIMPLE_OMP_GRID_BODY
:
1830 new_seq
= gimple_seq_copy (gimple_omp_body (stmt
));
1831 gimple_omp_set_body (copy
, new_seq
);
1834 case GIMPLE_TRANSACTION
:
1835 new_seq
= gimple_seq_copy (gimple_transaction_body (
1836 as_a
<gtransaction
*> (stmt
)));
1837 gimple_transaction_set_body (as_a
<gtransaction
*> (copy
),
1841 case GIMPLE_WITH_CLEANUP_EXPR
:
1842 new_seq
= gimple_seq_copy (gimple_wce_cleanup (stmt
));
1843 gimple_wce_set_cleanup (copy
, new_seq
);
1851 /* Make copy of operands. */
1852 for (i
= 0; i
< num_ops
; i
++)
1853 gimple_set_op (copy
, i
, unshare_expr (gimple_op (stmt
, i
)));
1855 if (gimple_has_mem_ops (stmt
))
1857 gimple_set_vdef (copy
, gimple_vdef (stmt
));
1858 gimple_set_vuse (copy
, gimple_vuse (stmt
));
1861 /* Clear out SSA operand vectors on COPY. */
1862 if (gimple_has_ops (stmt
))
1864 gimple_set_use_ops (copy
, NULL
);
1866 /* SSA operands need to be updated. */
1867 gimple_set_modified (copy
, true);
1874 /* Return true if statement S has side-effects. We consider a
1875 statement to have side effects if:
1877 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
1878 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
1881 gimple_has_side_effects (const gimple
*s
)
1883 if (is_gimple_debug (s
))
1886 /* We don't have to scan the arguments to check for
1887 volatile arguments, though, at present, we still
1888 do a scan to check for TREE_SIDE_EFFECTS. */
1889 if (gimple_has_volatile_ops (s
))
1892 if (gimple_code (s
) == GIMPLE_ASM
1893 && gimple_asm_volatile_p (as_a
<const gasm
*> (s
)))
1896 if (is_gimple_call (s
))
1898 int flags
= gimple_call_flags (s
);
1900 /* An infinite loop is considered a side effect. */
1901 if (!(flags
& (ECF_CONST
| ECF_PURE
))
1902 || (flags
& ECF_LOOPING_CONST_OR_PURE
))
1911 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
1912 Return true if S can trap. When INCLUDE_MEM is true, check whether
1913 the memory operations could trap. When INCLUDE_STORES is true and
1914 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
1917 gimple_could_trap_p_1 (gimple
*s
, bool include_mem
, bool include_stores
)
1919 tree t
, div
= NULL_TREE
;
1924 unsigned i
, start
= (is_gimple_assign (s
) && !include_stores
) ? 1 : 0;
1926 for (i
= start
; i
< gimple_num_ops (s
); i
++)
1927 if (tree_could_trap_p (gimple_op (s
, i
)))
1931 switch (gimple_code (s
))
1934 return gimple_asm_volatile_p (as_a
<gasm
*> (s
));
1937 t
= gimple_call_fndecl (s
);
1938 /* Assume that calls to weak functions may trap. */
1939 if (!t
|| !DECL_P (t
) || DECL_WEAK (t
))
1944 t
= gimple_expr_type (s
);
1945 op
= gimple_assign_rhs_code (s
);
1946 if (get_gimple_rhs_class (op
) == GIMPLE_BINARY_RHS
)
1947 div
= gimple_assign_rhs2 (s
);
1948 return (operation_could_trap_p (op
, FLOAT_TYPE_P (t
),
1949 (INTEGRAL_TYPE_P (t
)
1950 && TYPE_OVERFLOW_TRAPS (t
)),
1954 t
= TREE_TYPE (gimple_cond_lhs (s
));
1955 return operation_could_trap_p (gimple_cond_code (s
),
1956 FLOAT_TYPE_P (t
), false, NULL_TREE
);
1965 /* Return true if statement S can trap. */
1968 gimple_could_trap_p (gimple
*s
)
1970 return gimple_could_trap_p_1 (s
, true, true);
1973 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
1976 gimple_assign_rhs_could_trap_p (gimple
*s
)
1978 gcc_assert (is_gimple_assign (s
));
1979 return gimple_could_trap_p_1 (s
, true, false);
1983 /* Print debugging information for gimple stmts generated. */
1986 dump_gimple_statistics (void)
1988 int i
, total_tuples
= 0, total_bytes
= 0;
1990 if (! GATHER_STATISTICS
)
1992 fprintf (stderr
, "No gimple statistics\n");
1996 fprintf (stderr
, "\nGIMPLE statements\n");
1997 fprintf (stderr
, "Kind Stmts Bytes\n");
1998 fprintf (stderr
, "---------------------------------------\n");
1999 for (i
= 0; i
< (int) gimple_alloc_kind_all
; ++i
)
2001 fprintf (stderr
, "%-20s %7d %10d\n", gimple_alloc_kind_names
[i
],
2002 gimple_alloc_counts
[i
], gimple_alloc_sizes
[i
]);
2003 total_tuples
+= gimple_alloc_counts
[i
];
2004 total_bytes
+= gimple_alloc_sizes
[i
];
2006 fprintf (stderr
, "---------------------------------------\n");
2007 fprintf (stderr
, "%-20s %7d %10d\n", "Total", total_tuples
, total_bytes
);
2008 fprintf (stderr
, "---------------------------------------\n");
2012 /* Return the number of operands needed on the RHS of a GIMPLE
2013 assignment for an expression with tree code CODE. */
2016 get_gimple_rhs_num_ops (enum tree_code code
)
2018 enum gimple_rhs_class rhs_class
= get_gimple_rhs_class (code
);
2020 if (rhs_class
== GIMPLE_UNARY_RHS
|| rhs_class
== GIMPLE_SINGLE_RHS
)
2022 else if (rhs_class
== GIMPLE_BINARY_RHS
)
2024 else if (rhs_class
== GIMPLE_TERNARY_RHS
)
2030 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2032 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2033 : ((TYPE) == tcc_binary \
2034 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2035 : ((TYPE) == tcc_constant \
2036 || (TYPE) == tcc_declaration \
2037 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2038 : ((SYM) == TRUTH_AND_EXPR \
2039 || (SYM) == TRUTH_OR_EXPR \
2040 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2041 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2042 : ((SYM) == COND_EXPR \
2043 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2044 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2045 || (SYM) == DOT_PROD_EXPR \
2046 || (SYM) == SAD_EXPR \
2047 || (SYM) == REALIGN_LOAD_EXPR \
2048 || (SYM) == VEC_COND_EXPR \
2049 || (SYM) == VEC_PERM_EXPR \
2050 || (SYM) == BIT_INSERT_EXPR \
2051 || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS \
2052 : ((SYM) == CONSTRUCTOR \
2053 || (SYM) == OBJ_TYPE_REF \
2054 || (SYM) == ASSERT_EXPR \
2055 || (SYM) == ADDR_EXPR \
2056 || (SYM) == WITH_SIZE_EXPR \
2057 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2058 : GIMPLE_INVALID_RHS),
2059 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2061 const unsigned char gimple_rhs_class_table
[] = {
2062 #include "all-tree.def"
2066 #undef END_OF_BASE_TREE_CODES
2068 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2069 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2070 we failed to create one. */
2073 canonicalize_cond_expr_cond (tree t
)
2075 /* Strip conversions around boolean operations. */
2076 if (CONVERT_EXPR_P (t
)
2077 && (truth_value_p (TREE_CODE (TREE_OPERAND (t
, 0)))
2078 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
2080 t
= TREE_OPERAND (t
, 0);
2082 /* For !x use x == 0. */
2083 if (TREE_CODE (t
) == TRUTH_NOT_EXPR
)
2085 tree top0
= TREE_OPERAND (t
, 0);
2086 t
= build2 (EQ_EXPR
, TREE_TYPE (t
),
2087 top0
, build_int_cst (TREE_TYPE (top0
), 0));
2089 /* For cmp ? 1 : 0 use cmp. */
2090 else if (TREE_CODE (t
) == COND_EXPR
2091 && COMPARISON_CLASS_P (TREE_OPERAND (t
, 0))
2092 && integer_onep (TREE_OPERAND (t
, 1))
2093 && integer_zerop (TREE_OPERAND (t
, 2)))
2095 tree top0
= TREE_OPERAND (t
, 0);
2096 t
= build2 (TREE_CODE (top0
), TREE_TYPE (t
),
2097 TREE_OPERAND (top0
, 0), TREE_OPERAND (top0
, 1));
2099 /* For x ^ y use x != y. */
2100 else if (TREE_CODE (t
) == BIT_XOR_EXPR
)
2101 t
= build2 (NE_EXPR
, TREE_TYPE (t
),
2102 TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1));
2104 if (is_gimple_condexpr (t
))
2110 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2111 the positions marked by the set ARGS_TO_SKIP. */
2114 gimple_call_copy_skip_args (gcall
*stmt
, bitmap args_to_skip
)
2117 int nargs
= gimple_call_num_args (stmt
);
2118 auto_vec
<tree
> vargs (nargs
);
2121 for (i
= 0; i
< nargs
; i
++)
2122 if (!bitmap_bit_p (args_to_skip
, i
))
2123 vargs
.quick_push (gimple_call_arg (stmt
, i
));
2125 if (gimple_call_internal_p (stmt
))
2126 new_stmt
= gimple_build_call_internal_vec (gimple_call_internal_fn (stmt
),
2129 new_stmt
= gimple_build_call_vec (gimple_call_fn (stmt
), vargs
);
2131 if (gimple_call_lhs (stmt
))
2132 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2134 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2135 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
2137 if (gimple_has_location (stmt
))
2138 gimple_set_location (new_stmt
, gimple_location (stmt
));
2139 gimple_call_copy_flags (new_stmt
, stmt
);
2140 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2142 gimple_set_modified (new_stmt
, true);
2149 /* Return true if the field decls F1 and F2 are at the same offset.
2151 This is intended to be used on GIMPLE types only. */
2154 gimple_compare_field_offset (tree f1
, tree f2
)
2156 if (DECL_OFFSET_ALIGN (f1
) == DECL_OFFSET_ALIGN (f2
))
2158 tree offset1
= DECL_FIELD_OFFSET (f1
);
2159 tree offset2
= DECL_FIELD_OFFSET (f2
);
2160 return ((offset1
== offset2
2161 /* Once gimplification is done, self-referential offsets are
2162 instantiated as operand #2 of the COMPONENT_REF built for
2163 each access and reset. Therefore, they are not relevant
2164 anymore and fields are interchangeable provided that they
2165 represent the same access. */
2166 || (TREE_CODE (offset1
) == PLACEHOLDER_EXPR
2167 && TREE_CODE (offset2
) == PLACEHOLDER_EXPR
2168 && (DECL_SIZE (f1
) == DECL_SIZE (f2
)
2169 || (TREE_CODE (DECL_SIZE (f1
)) == PLACEHOLDER_EXPR
2170 && TREE_CODE (DECL_SIZE (f2
)) == PLACEHOLDER_EXPR
)
2171 || operand_equal_p (DECL_SIZE (f1
), DECL_SIZE (f2
), 0))
2172 && DECL_ALIGN (f1
) == DECL_ALIGN (f2
))
2173 || operand_equal_p (offset1
, offset2
, 0))
2174 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1
),
2175 DECL_FIELD_BIT_OFFSET (f2
)));
2178 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2179 should be, so handle differing ones specially by decomposing
2180 the offset into a byte and bit offset manually. */
2181 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1
))
2182 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2
)))
2184 unsigned HOST_WIDE_INT byte_offset1
, byte_offset2
;
2185 unsigned HOST_WIDE_INT bit_offset1
, bit_offset2
;
2186 bit_offset1
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1
));
2187 byte_offset1
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1
))
2188 + bit_offset1
/ BITS_PER_UNIT
);
2189 bit_offset2
= TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2
));
2190 byte_offset2
= (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2
))
2191 + bit_offset2
/ BITS_PER_UNIT
);
2192 if (byte_offset1
!= byte_offset2
)
2194 return bit_offset1
% BITS_PER_UNIT
== bit_offset2
% BITS_PER_UNIT
;
2201 /* Return a type the same as TYPE except unsigned or
2202 signed according to UNSIGNEDP. */
2205 gimple_signed_or_unsigned_type (bool unsignedp
, tree type
)
2210 type1
= TYPE_MAIN_VARIANT (type
);
2211 if (type1
== signed_char_type_node
2212 || type1
== char_type_node
2213 || type1
== unsigned_char_type_node
)
2214 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2215 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2216 return unsignedp
? unsigned_type_node
: integer_type_node
;
2217 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2218 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2219 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2220 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2221 if (type1
== long_long_integer_type_node
2222 || type1
== long_long_unsigned_type_node
)
2224 ? long_long_unsigned_type_node
2225 : long_long_integer_type_node
;
2227 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2228 if (int_n_enabled_p
[i
]
2229 && (type1
== int_n_trees
[i
].unsigned_type
2230 || type1
== int_n_trees
[i
].signed_type
))
2232 ? int_n_trees
[i
].unsigned_type
2233 : int_n_trees
[i
].signed_type
;
2235 #if HOST_BITS_PER_WIDE_INT >= 64
2236 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2237 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2239 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2240 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2241 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2242 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2243 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2244 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2245 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2246 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2248 #define GIMPLE_FIXED_TYPES(NAME) \
2249 if (type1 == short_ ## NAME ## _type_node \
2250 || type1 == unsigned_short_ ## NAME ## _type_node) \
2251 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2252 : short_ ## NAME ## _type_node; \
2253 if (type1 == NAME ## _type_node \
2254 || type1 == unsigned_ ## NAME ## _type_node) \
2255 return unsignedp ? unsigned_ ## NAME ## _type_node \
2256 : NAME ## _type_node; \
2257 if (type1 == long_ ## NAME ## _type_node \
2258 || type1 == unsigned_long_ ## NAME ## _type_node) \
2259 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2260 : long_ ## NAME ## _type_node; \
2261 if (type1 == long_long_ ## NAME ## _type_node \
2262 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2263 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2264 : long_long_ ## NAME ## _type_node;
2266 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2267 if (type1 == NAME ## _type_node \
2268 || type1 == u ## NAME ## _type_node) \
2269 return unsignedp ? u ## NAME ## _type_node \
2270 : NAME ## _type_node;
2272 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2273 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2274 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2275 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2276 : sat_ ## short_ ## NAME ## _type_node; \
2277 if (type1 == sat_ ## NAME ## _type_node \
2278 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2279 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2280 : sat_ ## NAME ## _type_node; \
2281 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2282 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2283 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2284 : sat_ ## long_ ## NAME ## _type_node; \
2285 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2286 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2287 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2288 : sat_ ## long_long_ ## NAME ## _type_node;
2290 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2291 if (type1 == sat_ ## NAME ## _type_node \
2292 || type1 == sat_ ## u ## NAME ## _type_node) \
2293 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2294 : sat_ ## NAME ## _type_node;
2296 GIMPLE_FIXED_TYPES (fract
);
2297 GIMPLE_FIXED_TYPES_SAT (fract
);
2298 GIMPLE_FIXED_TYPES (accum
);
2299 GIMPLE_FIXED_TYPES_SAT (accum
);
2301 GIMPLE_FIXED_MODE_TYPES (qq
);
2302 GIMPLE_FIXED_MODE_TYPES (hq
);
2303 GIMPLE_FIXED_MODE_TYPES (sq
);
2304 GIMPLE_FIXED_MODE_TYPES (dq
);
2305 GIMPLE_FIXED_MODE_TYPES (tq
);
2306 GIMPLE_FIXED_MODE_TYPES_SAT (qq
);
2307 GIMPLE_FIXED_MODE_TYPES_SAT (hq
);
2308 GIMPLE_FIXED_MODE_TYPES_SAT (sq
);
2309 GIMPLE_FIXED_MODE_TYPES_SAT (dq
);
2310 GIMPLE_FIXED_MODE_TYPES_SAT (tq
);
2311 GIMPLE_FIXED_MODE_TYPES (ha
);
2312 GIMPLE_FIXED_MODE_TYPES (sa
);
2313 GIMPLE_FIXED_MODE_TYPES (da
);
2314 GIMPLE_FIXED_MODE_TYPES (ta
);
2315 GIMPLE_FIXED_MODE_TYPES_SAT (ha
);
2316 GIMPLE_FIXED_MODE_TYPES_SAT (sa
);
2317 GIMPLE_FIXED_MODE_TYPES_SAT (da
);
2318 GIMPLE_FIXED_MODE_TYPES_SAT (ta
);
2320 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2321 the precision; they have precision set to match their range, but
2322 may use a wider mode to match an ABI. If we change modes, we may
2323 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2324 the precision as well, so as to yield correct results for
2325 bit-field types. C++ does not have these separate bit-field
2326 types, and producing a signed or unsigned variant of an
2327 ENUMERAL_TYPE may cause other problems as well. */
2328 if (!INTEGRAL_TYPE_P (type
)
2329 || TYPE_UNSIGNED (type
) == unsignedp
)
2332 #define TYPE_OK(node) \
2333 (TYPE_MODE (type) == TYPE_MODE (node) \
2334 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2335 if (TYPE_OK (signed_char_type_node
))
2336 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2337 if (TYPE_OK (integer_type_node
))
2338 return unsignedp
? unsigned_type_node
: integer_type_node
;
2339 if (TYPE_OK (short_integer_type_node
))
2340 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2341 if (TYPE_OK (long_integer_type_node
))
2342 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2343 if (TYPE_OK (long_long_integer_type_node
))
2345 ? long_long_unsigned_type_node
2346 : long_long_integer_type_node
);
2348 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2349 if (int_n_enabled_p
[i
]
2350 && TYPE_MODE (type
) == int_n_data
[i
].m
2351 && TYPE_PRECISION (type
) == int_n_data
[i
].bitsize
)
2353 ? int_n_trees
[i
].unsigned_type
2354 : int_n_trees
[i
].signed_type
;
2356 #if HOST_BITS_PER_WIDE_INT >= 64
2357 if (TYPE_OK (intTI_type_node
))
2358 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2360 if (TYPE_OK (intDI_type_node
))
2361 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2362 if (TYPE_OK (intSI_type_node
))
2363 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2364 if (TYPE_OK (intHI_type_node
))
2365 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2366 if (TYPE_OK (intQI_type_node
))
2367 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2369 #undef GIMPLE_FIXED_TYPES
2370 #undef GIMPLE_FIXED_MODE_TYPES
2371 #undef GIMPLE_FIXED_TYPES_SAT
2372 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2375 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2379 /* Return an unsigned type the same as TYPE in other respects. */
2382 gimple_unsigned_type (tree type
)
2384 return gimple_signed_or_unsigned_type (true, type
);
2388 /* Return a signed type the same as TYPE in other respects. */
2391 gimple_signed_type (tree type
)
2393 return gimple_signed_or_unsigned_type (false, type
);
2397 /* Return the typed-based alias set for T, which may be an expression
2398 or a type. Return -1 if we don't do anything special. */
2401 gimple_get_alias_set (tree t
)
2403 /* That's all the expressions we handle specially. */
2407 /* For convenience, follow the C standard when dealing with
2408 character types. Any object may be accessed via an lvalue that
2409 has character type. */
2410 if (t
== char_type_node
2411 || t
== signed_char_type_node
2412 || t
== unsigned_char_type_node
)
2415 /* Allow aliasing between signed and unsigned variants of the same
2416 type. We treat the signed variant as canonical. */
2417 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2419 tree t1
= gimple_signed_type (t
);
2421 /* t1 == t can happen for boolean nodes which are always unsigned. */
2423 return get_alias_set (t1
);
2430 /* Helper for gimple_ior_addresses_taken_1. */
2433 gimple_ior_addresses_taken_1 (gimple
*, tree addr
, tree
, void *data
)
2435 bitmap addresses_taken
= (bitmap
)data
;
2436 addr
= get_base_address (addr
);
2440 bitmap_set_bit (addresses_taken
, DECL_UID (addr
));
2446 /* Set the bit for the uid of all decls that have their address taken
2447 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2448 were any in this stmt. */
2451 gimple_ior_addresses_taken (bitmap addresses_taken
, gimple
*stmt
)
2453 return walk_stmt_load_store_addr_ops (stmt
, addresses_taken
, NULL
, NULL
,
2454 gimple_ior_addresses_taken_1
);
2458 /* Return true when STMTs arguments and return value match those of FNDECL,
2459 a decl of a builtin function. */
2462 gimple_builtin_call_types_compatible_p (const gimple
*stmt
, tree fndecl
)
2464 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
);
2466 tree ret
= gimple_call_lhs (stmt
);
2468 && !useless_type_conversion_p (TREE_TYPE (ret
),
2469 TREE_TYPE (TREE_TYPE (fndecl
))))
2472 tree targs
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2473 unsigned nargs
= gimple_call_num_args (stmt
);
2474 for (unsigned i
= 0; i
< nargs
; ++i
)
2476 /* Variadic args follow. */
2479 tree arg
= gimple_call_arg (stmt
, i
);
2480 tree type
= TREE_VALUE (targs
);
2481 if (!useless_type_conversion_p (type
, TREE_TYPE (arg
))
2482 /* char/short integral arguments are promoted to int
2483 by several frontends if targetm.calls.promote_prototypes
2484 is true. Allow such promotion too. */
2485 && !(INTEGRAL_TYPE_P (type
)
2486 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)
2487 && targetm
.calls
.promote_prototypes (TREE_TYPE (fndecl
))
2488 && useless_type_conversion_p (integer_type_node
,
2491 targs
= TREE_CHAIN (targs
);
2493 if (targs
&& !VOID_TYPE_P (TREE_VALUE (targs
)))
2498 /* Return true when STMT is builtins call. */
2501 gimple_call_builtin_p (const gimple
*stmt
)
2504 if (is_gimple_call (stmt
)
2505 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2506 && DECL_BUILT_IN_CLASS (fndecl
) != NOT_BUILT_IN
)
2507 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2511 /* Return true when STMT is builtins call to CLASS. */
2514 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_class klass
)
2517 if (is_gimple_call (stmt
)
2518 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2519 && DECL_BUILT_IN_CLASS (fndecl
) == klass
)
2520 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2524 /* Return true when STMT is builtins call to CODE of CLASS. */
2527 gimple_call_builtin_p (const gimple
*stmt
, enum built_in_function code
)
2530 if (is_gimple_call (stmt
)
2531 && (fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
2532 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
2533 && DECL_FUNCTION_CODE (fndecl
) == code
)
2534 return gimple_builtin_call_types_compatible_p (stmt
, fndecl
);
2538 /* If CALL is a call to a combined_fn (i.e. an internal function or
2539 a normal built-in function), return its code, otherwise return
2543 gimple_call_combined_fn (const gimple
*stmt
)
2545 if (const gcall
*call
= dyn_cast
<const gcall
*> (stmt
))
2547 if (gimple_call_internal_p (call
))
2548 return as_combined_fn (gimple_call_internal_fn (call
));
2550 tree fndecl
= gimple_call_fndecl (stmt
);
2552 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
2553 && gimple_builtin_call_types_compatible_p (stmt
, fndecl
))
2554 return as_combined_fn (DECL_FUNCTION_CODE (fndecl
));
2559 /* Return true if STMT clobbers memory. STMT is required to be a
2563 gimple_asm_clobbers_memory_p (const gasm
*stmt
)
2567 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
2569 tree op
= gimple_asm_clobber_op (stmt
, i
);
2570 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op
)), "memory") == 0)
2574 /* Non-empty basic ASM implicitly clobbers memory. */
2575 if (gimple_asm_input_p (stmt
) && strlen (gimple_asm_string (stmt
)) != 0)
2581 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2584 dump_decl_set (FILE *file
, bitmap set
)
2591 fprintf (file
, "{ ");
2593 EXECUTE_IF_SET_IN_BITMAP (set
, 0, i
, bi
)
2595 fprintf (file
, "D.%u", i
);
2596 fprintf (file
, " ");
2599 fprintf (file
, "}");
2602 fprintf (file
, "NIL");
2605 /* Return true when CALL is a call stmt that definitely doesn't
2606 free any memory or makes it unavailable otherwise. */
2608 nonfreeing_call_p (gimple
*call
)
2610 if (gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2611 && gimple_call_flags (call
) & ECF_LEAF
)
2612 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call
)))
2614 /* Just in case these become ECF_LEAF in the future. */
2616 case BUILT_IN_TM_FREE
:
2617 case BUILT_IN_REALLOC
:
2618 case BUILT_IN_STACK_RESTORE
:
2623 else if (gimple_call_internal_p (call
))
2624 switch (gimple_call_internal_fn (call
))
2626 case IFN_ABNORMAL_DISPATCHER
:
2629 if (gimple_call_flags (call
) & ECF_LEAF
)
2634 tree fndecl
= gimple_call_fndecl (call
);
2637 struct cgraph_node
*n
= cgraph_node::get (fndecl
);
2640 enum availability availability
;
2641 n
= n
->function_symbol (&availability
);
2642 if (!n
|| availability
<= AVAIL_INTERPOSABLE
)
2644 return n
->nonfreeing_fn
;
2647 /* Return true when CALL is a call stmt that definitely need not
2648 be considered to be a memory barrier. */
2650 nonbarrier_call_p (gimple
*call
)
2652 if (gimple_call_flags (call
) & (ECF_PURE
| ECF_CONST
))
2654 /* Should extend this to have a nonbarrier_fn flag, just as above in
2655 the nonfreeing case. */
2659 /* Callback for walk_stmt_load_store_ops.
2661 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2664 This routine only makes a superficial check for a dereference. Thus
2665 it must only be used if it is safe to return a false negative. */
2667 check_loadstore (gimple
*, tree op
, tree
, void *data
)
2669 if (TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
2671 /* Some address spaces may legitimately dereference zero. */
2672 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (op
));
2673 if (targetm
.addr_space
.zero_address_valid (as
))
2676 return operand_equal_p (TREE_OPERAND (op
, 0), (tree
)data
, 0);
2682 /* Return true if OP can be inferred to be non-NULL after STMT executes,
2683 either by using a pointer dereference or attributes. */
2685 infer_nonnull_range (gimple
*stmt
, tree op
)
2687 return infer_nonnull_range_by_dereference (stmt
, op
)
2688 || infer_nonnull_range_by_attribute (stmt
, op
);
2691 /* Return true if OP can be inferred to be non-NULL after STMT
2692 executes by using a pointer dereference. */
2694 infer_nonnull_range_by_dereference (gimple
*stmt
, tree op
)
2696 /* We can only assume that a pointer dereference will yield
2697 non-NULL if -fdelete-null-pointer-checks is enabled. */
2698 if (!flag_delete_null_pointer_checks
2699 || !POINTER_TYPE_P (TREE_TYPE (op
))
2700 || gimple_code (stmt
) == GIMPLE_ASM
)
2703 if (walk_stmt_load_store_ops (stmt
, (void *)op
,
2704 check_loadstore
, check_loadstore
))
2710 /* Return true if OP can be inferred to be a non-NULL after STMT
2711 executes by using attributes. */
2713 infer_nonnull_range_by_attribute (gimple
*stmt
, tree op
)
2715 /* We can only assume that a pointer dereference will yield
2716 non-NULL if -fdelete-null-pointer-checks is enabled. */
2717 if (!flag_delete_null_pointer_checks
2718 || !POINTER_TYPE_P (TREE_TYPE (op
))
2719 || gimple_code (stmt
) == GIMPLE_ASM
)
2722 if (is_gimple_call (stmt
) && !gimple_call_internal_p (stmt
))
2724 tree fntype
= gimple_call_fntype (stmt
);
2725 tree attrs
= TYPE_ATTRIBUTES (fntype
);
2726 for (; attrs
; attrs
= TREE_CHAIN (attrs
))
2728 attrs
= lookup_attribute ("nonnull", attrs
);
2730 /* If "nonnull" wasn't specified, we know nothing about
2732 if (attrs
== NULL_TREE
)
2735 /* If "nonnull" applies to all the arguments, then ARG
2736 is non-null if it's in the argument list. */
2737 if (TREE_VALUE (attrs
) == NULL_TREE
)
2739 for (unsigned int i
= 0; i
< gimple_call_num_args (stmt
); i
++)
2741 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt
, i
)))
2742 && operand_equal_p (op
, gimple_call_arg (stmt
, i
), 0))
2748 /* Now see if op appears in the nonnull list. */
2749 for (tree t
= TREE_VALUE (attrs
); t
; t
= TREE_CHAIN (t
))
2751 unsigned int idx
= TREE_INT_CST_LOW (TREE_VALUE (t
)) - 1;
2752 if (idx
< gimple_call_num_args (stmt
))
2754 tree arg
= gimple_call_arg (stmt
, idx
);
2755 if (operand_equal_p (op
, arg
, 0))
2762 /* If this function is marked as returning non-null, then we can
2763 infer OP is non-null if it is used in the return statement. */
2764 if (greturn
*return_stmt
= dyn_cast
<greturn
*> (stmt
))
2765 if (gimple_return_retval (return_stmt
)
2766 && operand_equal_p (gimple_return_retval (return_stmt
), op
, 0)
2767 && lookup_attribute ("returns_nonnull",
2768 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl
))))
2774 /* Compare two case labels. Because the front end should already have
2775 made sure that case ranges do not overlap, it is enough to only compare
2776 the CASE_LOW values of each case label. */
2779 compare_case_labels (const void *p1
, const void *p2
)
2781 const_tree
const case1
= *(const_tree
const*)p1
;
2782 const_tree
const case2
= *(const_tree
const*)p2
;
2784 /* The 'default' case label always goes first. */
2785 if (!CASE_LOW (case1
))
2787 else if (!CASE_LOW (case2
))
2790 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
2793 /* Sort the case labels in LABEL_VEC in place in ascending order. */
2796 sort_case_labels (vec
<tree
> label_vec
)
2798 label_vec
.qsort (compare_case_labels
);
2801 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2803 LABELS is a vector that contains all case labels to look at.
2805 INDEX_TYPE is the type of the switch index expression. Case labels
2806 in LABELS are discarded if their values are not in the value range
2807 covered by INDEX_TYPE. The remaining case label values are folded
2810 If a default case exists in LABELS, it is removed from LABELS and
2811 returned in DEFAULT_CASEP. If no default case exists, but the
2812 case labels already cover the whole range of INDEX_TYPE, a default
2813 case is returned pointing to one of the existing case labels.
2814 Otherwise DEFAULT_CASEP is set to NULL_TREE.
2816 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2817 apply and no action is taken regardless of whether a default case is
2821 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
2823 tree
*default_casep
)
2825 tree min_value
, max_value
;
2826 tree default_case
= NULL_TREE
;
2830 min_value
= TYPE_MIN_VALUE (index_type
);
2831 max_value
= TYPE_MAX_VALUE (index_type
);
2832 while (i
< labels
.length ())
2834 tree elt
= labels
[i
];
2835 tree low
= CASE_LOW (elt
);
2836 tree high
= CASE_HIGH (elt
);
2837 bool remove_element
= FALSE
;
2841 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
2842 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
2844 /* This is a non-default case label, i.e. it has a value.
2846 See if the case label is reachable within the range of
2847 the index type. Remove out-of-range case values. Turn
2848 case ranges into a canonical form (high > low strictly)
2849 and convert the case label values to the index type.
2851 NB: The type of gimple_switch_index() may be the promoted
2852 type, but the case labels retain the original type. */
2856 /* This is a case range. Discard empty ranges.
2857 If the bounds or the range are equal, turn this
2858 into a simple (one-value) case. */
2859 int cmp
= tree_int_cst_compare (high
, low
);
2861 remove_element
= TRUE
;
2868 /* If the simple case value is unreachable, ignore it. */
2869 if ((TREE_CODE (min_value
) == INTEGER_CST
2870 && tree_int_cst_compare (low
, min_value
) < 0)
2871 || (TREE_CODE (max_value
) == INTEGER_CST
2872 && tree_int_cst_compare (low
, max_value
) > 0))
2873 remove_element
= TRUE
;
2875 low
= fold_convert (index_type
, low
);
2879 /* If the entire case range is unreachable, ignore it. */
2880 if ((TREE_CODE (min_value
) == INTEGER_CST
2881 && tree_int_cst_compare (high
, min_value
) < 0)
2882 || (TREE_CODE (max_value
) == INTEGER_CST
2883 && tree_int_cst_compare (low
, max_value
) > 0))
2884 remove_element
= TRUE
;
2887 /* If the lower bound is less than the index type's
2888 minimum value, truncate the range bounds. */
2889 if (TREE_CODE (min_value
) == INTEGER_CST
2890 && tree_int_cst_compare (low
, min_value
) < 0)
2892 low
= fold_convert (index_type
, low
);
2894 /* If the upper bound is greater than the index type's
2895 maximum value, truncate the range bounds. */
2896 if (TREE_CODE (max_value
) == INTEGER_CST
2897 && tree_int_cst_compare (high
, max_value
) > 0)
2899 high
= fold_convert (index_type
, high
);
2901 /* We may have folded a case range to a one-value case. */
2902 if (tree_int_cst_equal (low
, high
))
2907 CASE_LOW (elt
) = low
;
2908 CASE_HIGH (elt
) = high
;
2912 gcc_assert (!default_case
);
2914 /* The default case must be passed separately to the
2915 gimple_build_switch routine. But if DEFAULT_CASEP
2916 is NULL, we do not remove the default case (it would
2917 be completely lost). */
2919 remove_element
= TRUE
;
2923 labels
.ordered_remove (i
);
2929 if (!labels
.is_empty ())
2930 sort_case_labels (labels
);
2932 if (default_casep
&& !default_case
)
2934 /* If the switch has no default label, add one, so that we jump
2935 around the switch body. If the labels already cover the whole
2936 range of the switch index_type, add the default label pointing
2937 to one of the existing labels. */
2939 && TYPE_MIN_VALUE (index_type
)
2940 && TYPE_MAX_VALUE (index_type
)
2941 && tree_int_cst_equal (CASE_LOW (labels
[0]),
2942 TYPE_MIN_VALUE (index_type
)))
2944 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
2946 high
= CASE_LOW (labels
[len
- 1]);
2947 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
2949 tree widest_label
= labels
[0];
2950 for (i
= 1; i
< len
; i
++)
2952 high
= CASE_LOW (labels
[i
]);
2953 low
= CASE_HIGH (labels
[i
- 1]);
2955 low
= CASE_LOW (labels
[i
- 1]);
2957 if (CASE_HIGH (labels
[i
]) != NULL_TREE
2958 && (CASE_HIGH (widest_label
) == NULL_TREE
2959 || wi::gtu_p (wi::sub (CASE_HIGH (labels
[i
]),
2960 CASE_LOW (labels
[i
])),
2961 wi::sub (CASE_HIGH (widest_label
),
2962 CASE_LOW (widest_label
)))))
2963 widest_label
= labels
[i
];
2965 if (wi::add (low
, 1) != high
)
2970 /* Designate the label with the widest range to be the
2972 tree label
= CASE_LABEL (widest_label
);
2973 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
2981 *default_casep
= default_case
;
2984 /* Set the location of all statements in SEQ to LOC. */
2987 gimple_seq_set_location (gimple_seq seq
, location_t loc
)
2989 for (gimple_stmt_iterator i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
2990 gimple_set_location (gsi_stmt (i
), loc
);
2993 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
2996 gimple_seq_discard (gimple_seq seq
)
2998 gimple_stmt_iterator gsi
;
3000 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); )
3002 gimple
*stmt
= gsi_stmt (gsi
);
3003 gsi_remove (&gsi
, true);
3004 release_defs (stmt
);
3009 /* See if STMT now calls function that takes no parameters and if so, drop
3010 call arguments. This is used when devirtualization machinery redirects
3011 to __builtin_unreachable or __cxa_pure_virtual. */
3014 maybe_remove_unused_call_args (struct function
*fn
, gimple
*stmt
)
3016 tree decl
= gimple_call_fndecl (stmt
);
3017 if (TYPE_ARG_TYPES (TREE_TYPE (decl
))
3018 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
))) == void_type_node
3019 && gimple_call_num_args (stmt
))
3021 gimple_set_num_ops (stmt
, 3);
3022 update_stmt_fn (fn
, stmt
);
3026 /* Return false if STMT will likely expand to real function call. */
3029 gimple_inexpensive_call_p (gcall
*stmt
)
3031 if (gimple_call_internal_p (stmt
))
3033 tree decl
= gimple_call_fndecl (stmt
);
3034 if (decl
&& is_inexpensive_builtin (decl
))
3041 namespace selftest
{
3043 /* Selftests for core gimple structures. */
3045 /* Verify that STMT is pretty-printed as EXPECTED.
3046 Helper function for selftests. */
3049 verify_gimple_pp (const char *expected
, gimple
*stmt
)
3052 pp_gimple_stmt_1 (&pp
, stmt
, 0 /* spc */, 0 /* flags */);
3053 ASSERT_STREQ (expected
, pp_formatted_text (&pp
));
3056 /* Build a GIMPLE_ASSIGN equivalent to
3058 and verify various properties of it. */
3061 test_assign_single ()
3063 tree type
= integer_type_node
;
3064 tree lhs
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3065 get_identifier ("tmp"),
3067 tree rhs
= build_int_cst (type
, 5);
3068 gassign
*stmt
= gimple_build_assign (lhs
, rhs
);
3069 verify_gimple_pp ("tmp = 5;", stmt
);
3071 ASSERT_TRUE (is_gimple_assign (stmt
));
3072 ASSERT_EQ (lhs
, gimple_assign_lhs (stmt
));
3073 ASSERT_EQ (lhs
, gimple_get_lhs (stmt
));
3074 ASSERT_EQ (rhs
, gimple_assign_rhs1 (stmt
));
3075 ASSERT_EQ (NULL
, gimple_assign_rhs2 (stmt
));
3076 ASSERT_EQ (NULL
, gimple_assign_rhs3 (stmt
));
3077 ASSERT_TRUE (gimple_assign_single_p (stmt
));
3078 ASSERT_EQ (INTEGER_CST
, gimple_assign_rhs_code (stmt
));
3081 /* Build a GIMPLE_ASSIGN equivalent to
3083 and verify various properties of it. */
3086 test_assign_binop ()
3088 tree type
= integer_type_node
;
3089 tree lhs
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3090 get_identifier ("tmp"),
3092 tree a
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3093 get_identifier ("a"),
3095 tree b
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
3096 get_identifier ("b"),
3098 gassign
*stmt
= gimple_build_assign (lhs
, MULT_EXPR
, a
, b
);
3099 verify_gimple_pp ("tmp = a * b;", stmt
);
3101 ASSERT_TRUE (is_gimple_assign (stmt
));
3102 ASSERT_EQ (lhs
, gimple_assign_lhs (stmt
));
3103 ASSERT_EQ (lhs
, gimple_get_lhs (stmt
));
3104 ASSERT_EQ (a
, gimple_assign_rhs1 (stmt
));
3105 ASSERT_EQ (b
, gimple_assign_rhs2 (stmt
));
3106 ASSERT_EQ (NULL
, gimple_assign_rhs3 (stmt
));
3107 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3108 ASSERT_EQ (MULT_EXPR
, gimple_assign_rhs_code (stmt
));
3111 /* Build a GIMPLE_NOP and verify various properties of it. */
3116 gimple
*stmt
= gimple_build_nop ();
3117 verify_gimple_pp ("GIMPLE_NOP", stmt
);
3118 ASSERT_EQ (GIMPLE_NOP
, gimple_code (stmt
));
3119 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3120 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3123 /* Build a GIMPLE_RETURN equivalent to
3125 and verify various properties of it. */
3130 tree type
= integer_type_node
;
3131 tree val
= build_int_cst (type
, 7);
3132 greturn
*stmt
= gimple_build_return (val
);
3133 verify_gimple_pp ("return 7;", stmt
);
3135 ASSERT_EQ (GIMPLE_RETURN
, gimple_code (stmt
));
3136 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3137 ASSERT_EQ (val
, gimple_return_retval (stmt
));
3138 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3141 /* Build a GIMPLE_RETURN equivalent to
3143 and verify various properties of it. */
3146 test_return_without_value ()
3148 greturn
*stmt
= gimple_build_return (NULL
);
3149 verify_gimple_pp ("return;", stmt
);
3151 ASSERT_EQ (GIMPLE_RETURN
, gimple_code (stmt
));
3152 ASSERT_EQ (NULL
, gimple_get_lhs (stmt
));
3153 ASSERT_EQ (NULL
, gimple_return_retval (stmt
));
3154 ASSERT_FALSE (gimple_assign_single_p (stmt
));
3157 /* Run all of the selftests within this file. */
3162 test_assign_single ();
3163 test_assign_binop ();
3165 test_return_stmt ();
3166 test_return_without_value ();
3169 } // namespace selftest
3172 #endif /* CHECKING_P */