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"
45 /* All the tuples have their operand vector (if present) at the very bottom
46 of the structure. Therefore, the offset required to find the
47 operands vector the size of the structure minus the size of the 1
48 element tree array at the end (see gimple_ops). */
49 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
50 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
51 EXPORTED_CONST size_t gimple_ops_offset_[] = {
52 #include "gsstruct.def"
56 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
57 static const size_t gsstruct_code_size[] = {
58 #include "gsstruct.def"
62 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
63 const char *const gimple_code_name[] = {
68 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
69 EXPORTED_CONST enum gimple_statement_structure_enum gss_for_code_[] = {
76 int gimple_alloc_counts[(int) gimple_alloc_kind_all];
77 int gimple_alloc_sizes[(int) gimple_alloc_kind_all];
79 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
80 static const char * const gimple_alloc_kind_names[] = {
87 /* Static gimple tuple members. */
88 const enum gimple_code gassign::code_;
89 const enum gimple_code gcall::code_;
90 const enum gimple_code gcond::code_;
93 /* Gimple tuple constructors.
94 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
95 be passed a NULL to start with an empty sequence. */
97 /* Set the code for statement G to CODE. */
100 gimple_set_code (gimple *g, enum gimple_code code)
105 /* Return the number of bytes needed to hold a GIMPLE statement with
109 gimple_size (enum gimple_code code)
111 return gsstruct_code_size[gss_for_code (code)];
114 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
118 gimple_alloc_stat (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
123 size = gimple_size (code);
125 size += sizeof (tree) * (num_ops - 1);
127 if (GATHER_STATISTICS)
129 enum gimple_alloc_kind kind = gimple_alloc_kind (code);
130 gimple_alloc_counts[(int) kind]++;
131 gimple_alloc_sizes[(int) kind] += size;
134 stmt = ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT);
135 gimple_set_code (stmt, code);
136 gimple_set_num_ops (stmt, num_ops);
138 /* Do not call gimple_set_modified here as it has other side
139 effects and this tuple is still not completely built. */
141 gimple_init_singleton (stmt);
146 /* Set SUBCODE to be the code of the expression computed by statement G. */
149 gimple_set_subcode (gimple *g, unsigned subcode)
151 /* We only have 16 bits for the RHS code. Assert that we are not
153 gcc_assert (subcode < (1 << 16));
154 g->subcode = subcode;
159 /* Build a tuple with operands. CODE is the statement to build (which
160 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
161 for the new tuple. NUM_OPS is the number of operands to allocate. */
163 #define gimple_build_with_ops(c, s, n) \
164 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
167 gimple_build_with_ops_stat (enum gimple_code code, unsigned subcode,
168 unsigned num_ops MEM_STAT_DECL)
170 gimple *s = gimple_alloc_stat (code, num_ops PASS_MEM_STAT);
171 gimple_set_subcode (s, subcode);
177 /* Build a GIMPLE_RETURN statement returning RETVAL. */
180 gimple_build_return (tree retval)
183 = as_a <greturn *> (gimple_build_with_ops (GIMPLE_RETURN, ERROR_MARK,
186 gimple_return_set_retval (s, retval);
190 /* Reset alias information on call S. */
193 gimple_call_reset_alias_info (gcall *s)
195 if (gimple_call_flags (s) & ECF_CONST)
196 memset (gimple_call_use_set (s), 0, sizeof (struct pt_solution));
198 pt_solution_reset (gimple_call_use_set (s));
199 if (gimple_call_flags (s) & (ECF_CONST|ECF_PURE|ECF_NOVOPS))
200 memset (gimple_call_clobber_set (s), 0, sizeof (struct pt_solution));
202 pt_solution_reset (gimple_call_clobber_set (s));
205 /* Helper for gimple_build_call, gimple_build_call_valist,
206 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
207 components of a GIMPLE_CALL statement to function FN with NARGS
210 static inline gcall *
211 gimple_build_call_1 (tree fn, unsigned nargs)
214 = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
216 if (TREE_CODE (fn) == FUNCTION_DECL)
217 fn = build_fold_addr_expr (fn);
218 gimple_set_op (s, 1, fn);
219 gimple_call_set_fntype (s, TREE_TYPE (TREE_TYPE (fn)));
220 gimple_call_reset_alias_info (s);
225 /* Build a GIMPLE_CALL statement to function FN with the arguments
226 specified in vector ARGS. */
229 gimple_build_call_vec (tree fn, vec<tree> args)
232 unsigned nargs = args.length ();
233 gcall *call = gimple_build_call_1 (fn, nargs);
235 for (i = 0; i < nargs; i++)
236 gimple_call_set_arg (call, i, args[i]);
242 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
243 arguments. The ... are the arguments. */
246 gimple_build_call (tree fn, unsigned nargs, ...)
252 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
254 call = gimple_build_call_1 (fn, nargs);
256 va_start (ap, nargs);
257 for (i = 0; i < nargs; i++)
258 gimple_call_set_arg (call, i, va_arg (ap, tree));
265 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
266 arguments. AP contains the arguments. */
269 gimple_build_call_valist (tree fn, unsigned nargs, va_list ap)
274 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
276 call = gimple_build_call_1 (fn, nargs);
278 for (i = 0; i < nargs; i++)
279 gimple_call_set_arg (call, i, va_arg (ap, tree));
285 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
286 Build the basic components of a GIMPLE_CALL statement to internal
287 function FN with NARGS arguments. */
289 static inline gcall *
290 gimple_build_call_internal_1 (enum internal_fn fn, unsigned nargs)
293 = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
295 s->subcode |= GF_CALL_INTERNAL;
296 gimple_call_set_internal_fn (s, fn);
297 gimple_call_reset_alias_info (s);
302 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
303 the number of arguments. The ... are the arguments. */
306 gimple_build_call_internal (enum internal_fn fn, unsigned nargs, ...)
312 call = gimple_build_call_internal_1 (fn, nargs);
313 va_start (ap, nargs);
314 for (i = 0; i < nargs; i++)
315 gimple_call_set_arg (call, i, va_arg (ap, tree));
322 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
323 specified in vector ARGS. */
326 gimple_build_call_internal_vec (enum internal_fn fn, vec<tree> args)
331 nargs = args.length ();
332 call = gimple_build_call_internal_1 (fn, nargs);
333 for (i = 0; i < nargs; i++)
334 gimple_call_set_arg (call, i, args[i]);
340 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
341 assumed to be in GIMPLE form already. Minimal checking is done of
345 gimple_build_call_from_tree (tree t)
349 tree fndecl = get_callee_fndecl (t);
351 gcc_assert (TREE_CODE (t) == CALL_EXPR);
353 nargs = call_expr_nargs (t);
354 call = gimple_build_call_1 (fndecl ? fndecl : CALL_EXPR_FN (t), nargs);
356 for (i = 0; i < nargs; i++)
357 gimple_call_set_arg (call, i, CALL_EXPR_ARG (t, i));
359 gimple_set_block (call, TREE_BLOCK (t));
361 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
362 gimple_call_set_chain (call, CALL_EXPR_STATIC_CHAIN (t));
363 gimple_call_set_tail (call, CALL_EXPR_TAILCALL (t));
364 gimple_call_set_return_slot_opt (call, CALL_EXPR_RETURN_SLOT_OPT (t));
366 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
367 && (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_ALLOCA
368 || DECL_FUNCTION_CODE (fndecl) == BUILT_IN_ALLOCA_WITH_ALIGN))
369 gimple_call_set_alloca_for_var (call, CALL_ALLOCA_FOR_VAR_P (t));
371 gimple_call_set_from_thunk (call, CALL_FROM_THUNK_P (t));
372 gimple_call_set_va_arg_pack (call, CALL_EXPR_VA_ARG_PACK (t));
373 gimple_call_set_nothrow (call, TREE_NOTHROW (t));
374 gimple_set_no_warning (call, TREE_NO_WARNING (t));
375 gimple_call_set_with_bounds (call, CALL_WITH_BOUNDS_P (t));
381 /* Build a GIMPLE_ASSIGN statement.
383 LHS of the assignment.
384 RHS of the assignment which can be unary or binary. */
387 gimple_build_assign (tree lhs, tree rhs MEM_STAT_DECL)
389 enum tree_code subcode;
392 extract_ops_from_tree (rhs, &subcode, &op1, &op2, &op3);
393 return gimple_build_assign (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
397 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
400 static inline gassign *
401 gimple_build_assign_1 (tree lhs, enum tree_code subcode, tree op1,
402 tree op2, tree op3 MEM_STAT_DECL)
407 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
409 num_ops = get_gimple_rhs_num_ops (subcode) + 1;
411 p = as_a <gassign *> (
412 gimple_build_with_ops_stat (GIMPLE_ASSIGN, (unsigned)subcode, num_ops
414 gimple_assign_set_lhs (p, lhs);
415 gimple_assign_set_rhs1 (p, op1);
418 gcc_assert (num_ops > 2);
419 gimple_assign_set_rhs2 (p, op2);
424 gcc_assert (num_ops > 3);
425 gimple_assign_set_rhs3 (p, op3);
431 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
435 gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
436 tree op2, tree op3 MEM_STAT_DECL)
438 return gimple_build_assign_1 (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
441 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
445 gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
446 tree op2 MEM_STAT_DECL)
448 return gimple_build_assign_1 (lhs, subcode, op1, op2, NULL_TREE
452 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
455 gimple_build_assign (tree lhs, enum tree_code subcode, tree op1 MEM_STAT_DECL)
457 return gimple_build_assign_1 (lhs, subcode, op1, NULL_TREE, NULL_TREE
462 /* Build a GIMPLE_COND statement.
464 PRED is the condition used to compare LHS and the RHS.
465 T_LABEL is the label to jump to if the condition is true.
466 F_LABEL is the label to jump to otherwise. */
469 gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs,
470 tree t_label, tree f_label)
474 gcc_assert (TREE_CODE_CLASS (pred_code) == tcc_comparison);
475 p = as_a <gcond *> (gimple_build_with_ops (GIMPLE_COND, pred_code, 4));
476 gimple_cond_set_lhs (p, lhs);
477 gimple_cond_set_rhs (p, rhs);
478 gimple_cond_set_true_label (p, t_label);
479 gimple_cond_set_false_label (p, f_label);
483 /* Build a GIMPLE_COND statement from the conditional expression tree
484 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
487 gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
492 gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
493 return gimple_build_cond (code, lhs, rhs, t_label, f_label);
496 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
497 boolean expression tree COND. */
500 gimple_cond_set_condition_from_tree (gcond *stmt, tree cond)
505 gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
506 gimple_cond_set_condition (stmt, code, lhs, rhs);
509 /* Build a GIMPLE_LABEL statement for LABEL. */
512 gimple_build_label (tree label)
515 = as_a <glabel *> (gimple_build_with_ops (GIMPLE_LABEL, ERROR_MARK, 1));
516 gimple_label_set_label (p, label);
520 /* Build a GIMPLE_GOTO statement to label DEST. */
523 gimple_build_goto (tree dest)
526 = as_a <ggoto *> (gimple_build_with_ops (GIMPLE_GOTO, ERROR_MARK, 1));
527 gimple_goto_set_dest (p, dest);
532 /* Build a GIMPLE_NOP statement. */
535 gimple_build_nop (void)
537 return gimple_alloc (GIMPLE_NOP, 0);
541 /* Build a GIMPLE_BIND statement.
542 VARS are the variables in BODY.
543 BLOCK is the containing block. */
546 gimple_build_bind (tree vars, gimple_seq body, tree block)
548 gbind *p = as_a <gbind *> (gimple_alloc (GIMPLE_BIND, 0));
549 gimple_bind_set_vars (p, vars);
551 gimple_bind_set_body (p, body);
553 gimple_bind_set_block (p, block);
557 /* Helper function to set the simple fields of a asm stmt.
559 STRING is a pointer to a string that is the asm blocks assembly code.
560 NINPUT is the number of register inputs.
561 NOUTPUT is the number of register outputs.
562 NCLOBBERS is the number of clobbered registers.
566 gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
567 unsigned nclobbers, unsigned nlabels)
570 int size = strlen (string);
572 /* ASMs with labels cannot have outputs. This should have been
573 enforced by the front end. */
574 gcc_assert (nlabels == 0 || noutputs == 0);
577 gimple_build_with_ops (GIMPLE_ASM, ERROR_MARK,
578 ninputs + noutputs + nclobbers + nlabels));
584 p->string = ggc_alloc_string (string, size);
586 if (GATHER_STATISTICS)
587 gimple_alloc_sizes[(int) gimple_alloc_kind (GIMPLE_ASM)] += size;
592 /* Build a GIMPLE_ASM statement.
594 STRING is the assembly code.
595 NINPUT is the number of register inputs.
596 NOUTPUT is the number of register outputs.
597 NCLOBBERS is the number of clobbered registers.
598 INPUTS is a vector of the input register parameters.
599 OUTPUTS is a vector of the output register parameters.
600 CLOBBERS is a vector of the clobbered register parameters.
601 LABELS is a vector of destination labels. */
604 gimple_build_asm_vec (const char *string, vec<tree, va_gc> *inputs,
605 vec<tree, va_gc> *outputs, vec<tree, va_gc> *clobbers,
606 vec<tree, va_gc> *labels)
611 p = gimple_build_asm_1 (string,
612 vec_safe_length (inputs),
613 vec_safe_length (outputs),
614 vec_safe_length (clobbers),
615 vec_safe_length (labels));
617 for (i = 0; i < vec_safe_length (inputs); i++)
618 gimple_asm_set_input_op (p, i, (*inputs)[i]);
620 for (i = 0; i < vec_safe_length (outputs); i++)
621 gimple_asm_set_output_op (p, i, (*outputs)[i]);
623 for (i = 0; i < vec_safe_length (clobbers); i++)
624 gimple_asm_set_clobber_op (p, i, (*clobbers)[i]);
626 for (i = 0; i < vec_safe_length (labels); i++)
627 gimple_asm_set_label_op (p, i, (*labels)[i]);
632 /* Build a GIMPLE_CATCH statement.
634 TYPES are the catch types.
635 HANDLER is the exception handler. */
638 gimple_build_catch (tree types, gimple_seq handler)
640 gcatch *p = as_a <gcatch *> (gimple_alloc (GIMPLE_CATCH, 0));
641 gimple_catch_set_types (p, types);
643 gimple_catch_set_handler (p, handler);
648 /* Build a GIMPLE_EH_FILTER statement.
650 TYPES are the filter's types.
651 FAILURE is the filter's failure action. */
654 gimple_build_eh_filter (tree types, gimple_seq failure)
656 geh_filter *p = as_a <geh_filter *> (gimple_alloc (GIMPLE_EH_FILTER, 0));
657 gimple_eh_filter_set_types (p, types);
659 gimple_eh_filter_set_failure (p, failure);
664 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
667 gimple_build_eh_must_not_throw (tree decl)
669 geh_mnt *p = as_a <geh_mnt *> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW, 0));
671 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
672 gcc_assert (flags_from_decl_or_type (decl) & ECF_NORETURN);
673 gimple_eh_must_not_throw_set_fndecl (p, decl);
678 /* Build a GIMPLE_EH_ELSE statement. */
681 gimple_build_eh_else (gimple_seq n_body, gimple_seq e_body)
683 geh_else *p = as_a <geh_else *> (gimple_alloc (GIMPLE_EH_ELSE, 0));
684 gimple_eh_else_set_n_body (p, n_body);
685 gimple_eh_else_set_e_body (p, e_body);
689 /* Build a GIMPLE_TRY statement.
691 EVAL is the expression to evaluate.
692 CLEANUP is the cleanup expression.
693 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
694 whether this is a try/catch or a try/finally respectively. */
697 gimple_build_try (gimple_seq eval, gimple_seq cleanup,
698 enum gimple_try_flags kind)
702 gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
703 p = as_a <gtry *> (gimple_alloc (GIMPLE_TRY, 0));
704 gimple_set_subcode (p, kind);
706 gimple_try_set_eval (p, eval);
708 gimple_try_set_cleanup (p, cleanup);
713 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
715 CLEANUP is the cleanup expression. */
718 gimple_build_wce (gimple_seq cleanup)
720 gimple *p = gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR, 0);
722 gimple_wce_set_cleanup (p, cleanup);
728 /* Build a GIMPLE_RESX statement. */
731 gimple_build_resx (int region)
734 = as_a <gresx *> (gimple_build_with_ops (GIMPLE_RESX, ERROR_MARK, 0));
740 /* The helper for constructing a gimple switch statement.
741 INDEX is the switch's index.
742 NLABELS is the number of labels in the switch excluding the default.
743 DEFAULT_LABEL is the default label for the switch statement. */
746 gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
748 /* nlabels + 1 default label + 1 index. */
749 gcc_checking_assert (default_label);
750 gswitch *p = as_a <gswitch *> (gimple_build_with_ops (GIMPLE_SWITCH,
753 gimple_switch_set_index (p, index);
754 gimple_switch_set_default_label (p, default_label);
758 /* Build a GIMPLE_SWITCH statement.
760 INDEX is the switch's index.
761 DEFAULT_LABEL is the default label
762 ARGS is a vector of labels excluding the default. */
765 gimple_build_switch (tree index, tree default_label, vec<tree> args)
767 unsigned i, nlabels = args.length ();
769 gswitch *p = gimple_build_switch_nlabels (nlabels, index, default_label);
771 /* Copy the labels from the vector to the switch statement. */
772 for (i = 0; i < nlabels; i++)
773 gimple_switch_set_label (p, i + 1, args[i]);
778 /* Build a GIMPLE_EH_DISPATCH statement. */
781 gimple_build_eh_dispatch (int region)
784 = as_a <geh_dispatch *> (
785 gimple_build_with_ops (GIMPLE_EH_DISPATCH, ERROR_MARK, 0));
790 /* Build a new GIMPLE_DEBUG_BIND statement.
792 VAR is bound to VALUE; block and location are taken from STMT. */
795 gimple_build_debug_bind_stat (tree var, tree value, gimple *stmt MEM_STAT_DECL)
798 = as_a <gdebug *> (gimple_build_with_ops_stat (GIMPLE_DEBUG,
799 (unsigned)GIMPLE_DEBUG_BIND, 2
801 gimple_debug_bind_set_var (p, var);
802 gimple_debug_bind_set_value (p, value);
804 gimple_set_location (p, gimple_location (stmt));
810 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
812 VAR is bound to VALUE; block and location are taken from STMT. */
815 gimple_build_debug_source_bind_stat (tree var, tree value,
816 gimple *stmt MEM_STAT_DECL)
820 gimple_build_with_ops_stat (GIMPLE_DEBUG,
821 (unsigned)GIMPLE_DEBUG_SOURCE_BIND, 2
824 gimple_debug_source_bind_set_var (p, var);
825 gimple_debug_source_bind_set_value (p, value);
827 gimple_set_location (p, gimple_location (stmt));
833 /* Build a GIMPLE_OMP_CRITICAL statement.
835 BODY is the sequence of statements for which only one thread can execute.
836 NAME is optional identifier for this critical block.
837 CLAUSES are clauses for this critical block. */
840 gimple_build_omp_critical (gimple_seq body, tree name, tree clauses)
843 = as_a <gomp_critical *> (gimple_alloc (GIMPLE_OMP_CRITICAL, 0));
844 gimple_omp_critical_set_name (p, name);
845 gimple_omp_critical_set_clauses (p, clauses);
847 gimple_omp_set_body (p, body);
852 /* Build a GIMPLE_OMP_FOR statement.
854 BODY is sequence of statements inside the for loop.
855 KIND is the `for' variant.
856 CLAUSES, are any of the construct's clauses.
857 COLLAPSE is the collapse count.
858 PRE_BODY is the sequence of statements that are loop invariant. */
861 gimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse,
864 gomp_for *p = as_a <gomp_for *> (gimple_alloc (GIMPLE_OMP_FOR, 0));
866 gimple_omp_set_body (p, body);
867 gimple_omp_for_set_clauses (p, clauses);
868 gimple_omp_for_set_kind (p, kind);
869 p->collapse = collapse;
870 p->iter = ggc_cleared_vec_alloc<gimple_omp_for_iter> (collapse);
873 gimple_omp_for_set_pre_body (p, pre_body);
879 /* Build a GIMPLE_OMP_PARALLEL statement.
881 BODY is sequence of statements which are executed in parallel.
882 CLAUSES, are the OMP parallel construct's clauses.
883 CHILD_FN is the function created for the parallel threads to execute.
884 DATA_ARG are the shared data argument(s). */
887 gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
891 = as_a <gomp_parallel *> (gimple_alloc (GIMPLE_OMP_PARALLEL, 0));
893 gimple_omp_set_body (p, body);
894 gimple_omp_parallel_set_clauses (p, clauses);
895 gimple_omp_parallel_set_child_fn (p, child_fn);
896 gimple_omp_parallel_set_data_arg (p, data_arg);
902 /* Build a GIMPLE_OMP_TASK statement.
904 BODY is sequence of statements which are executed by the explicit task.
905 CLAUSES, are the OMP parallel construct's clauses.
906 CHILD_FN is the function created for the parallel threads to execute.
907 DATA_ARG are the shared data argument(s).
908 COPY_FN is the optional function for firstprivate initialization.
909 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
912 gimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn,
913 tree data_arg, tree copy_fn, tree arg_size,
916 gomp_task *p = as_a <gomp_task *> (gimple_alloc (GIMPLE_OMP_TASK, 0));
918 gimple_omp_set_body (p, body);
919 gimple_omp_task_set_clauses (p, clauses);
920 gimple_omp_task_set_child_fn (p, child_fn);
921 gimple_omp_task_set_data_arg (p, data_arg);
922 gimple_omp_task_set_copy_fn (p, copy_fn);
923 gimple_omp_task_set_arg_size (p, arg_size);
924 gimple_omp_task_set_arg_align (p, arg_align);
930 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
932 BODY is the sequence of statements in the section. */
935 gimple_build_omp_section (gimple_seq body)
937 gimple *p = gimple_alloc (GIMPLE_OMP_SECTION, 0);
939 gimple_omp_set_body (p, body);
945 /* Build a GIMPLE_OMP_MASTER statement.
947 BODY is the sequence of statements to be executed by just the master. */
950 gimple_build_omp_master (gimple_seq body)
952 gimple *p = gimple_alloc (GIMPLE_OMP_MASTER, 0);
954 gimple_omp_set_body (p, body);
959 /* Build a GIMPLE_OMP_GRID_BODY statement.
961 BODY is the sequence of statements to be executed by the kernel. */
964 gimple_build_omp_grid_body (gimple_seq body)
966 gimple *p = gimple_alloc (GIMPLE_OMP_GRID_BODY, 0);
968 gimple_omp_set_body (p, body);
973 /* Build a GIMPLE_OMP_TASKGROUP statement.
975 BODY is the sequence of statements to be executed by the taskgroup
979 gimple_build_omp_taskgroup (gimple_seq body)
981 gimple *p = gimple_alloc (GIMPLE_OMP_TASKGROUP, 0);
983 gimple_omp_set_body (p, body);
989 /* Build a GIMPLE_OMP_CONTINUE statement.
991 CONTROL_DEF is the definition of the control variable.
992 CONTROL_USE is the use of the control variable. */
995 gimple_build_omp_continue (tree control_def, tree control_use)
998 = as_a <gomp_continue *> (gimple_alloc (GIMPLE_OMP_CONTINUE, 0));
999 gimple_omp_continue_set_control_def (p, control_def);
1000 gimple_omp_continue_set_control_use (p, control_use);
1004 /* Build a GIMPLE_OMP_ORDERED statement.
1006 BODY is the sequence of statements inside a loop that will executed in
1008 CLAUSES are clauses for this statement. */
1011 gimple_build_omp_ordered (gimple_seq body, tree clauses)
1014 = as_a <gomp_ordered *> (gimple_alloc (GIMPLE_OMP_ORDERED, 0));
1015 gimple_omp_ordered_set_clauses (p, clauses);
1017 gimple_omp_set_body (p, body);
1023 /* Build a GIMPLE_OMP_RETURN statement.
1024 WAIT_P is true if this is a non-waiting return. */
1027 gimple_build_omp_return (bool wait_p)
1029 gimple *p = gimple_alloc (GIMPLE_OMP_RETURN, 0);
1031 gimple_omp_return_set_nowait (p);
1037 /* Build a GIMPLE_OMP_SECTIONS statement.
1039 BODY is a sequence of section statements.
1040 CLAUSES are any of the OMP sections contsruct's clauses: private,
1041 firstprivate, lastprivate, reduction, and nowait. */
1044 gimple_build_omp_sections (gimple_seq body, tree clauses)
1047 = as_a <gomp_sections *> (gimple_alloc (GIMPLE_OMP_SECTIONS, 0));
1049 gimple_omp_set_body (p, body);
1050 gimple_omp_sections_set_clauses (p, clauses);
1056 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1059 gimple_build_omp_sections_switch (void)
1061 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH, 0);
1065 /* Build a GIMPLE_OMP_SINGLE statement.
1067 BODY is the sequence of statements that will be executed once.
1068 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1069 copyprivate, nowait. */
1072 gimple_build_omp_single (gimple_seq body, tree clauses)
1075 = as_a <gomp_single *> (gimple_alloc (GIMPLE_OMP_SINGLE, 0));
1077 gimple_omp_set_body (p, body);
1078 gimple_omp_single_set_clauses (p, clauses);
1084 /* Build a GIMPLE_OMP_TARGET statement.
1086 BODY is the sequence of statements that will be executed.
1087 KIND is the kind of the region.
1088 CLAUSES are any of the construct's clauses. */
1091 gimple_build_omp_target (gimple_seq body, int kind, tree clauses)
1094 = as_a <gomp_target *> (gimple_alloc (GIMPLE_OMP_TARGET, 0));
1096 gimple_omp_set_body (p, body);
1097 gimple_omp_target_set_clauses (p, clauses);
1098 gimple_omp_target_set_kind (p, kind);
1104 /* Build a GIMPLE_OMP_TEAMS statement.
1106 BODY is the sequence of statements that will be executed.
1107 CLAUSES are any of the OMP teams construct's clauses. */
1110 gimple_build_omp_teams (gimple_seq body, tree clauses)
1112 gomp_teams *p = as_a <gomp_teams *> (gimple_alloc (GIMPLE_OMP_TEAMS, 0));
1114 gimple_omp_set_body (p, body);
1115 gimple_omp_teams_set_clauses (p, clauses);
1121 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1124 gimple_build_omp_atomic_load (tree lhs, tree rhs)
1127 = as_a <gomp_atomic_load *> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0));
1128 gimple_omp_atomic_load_set_lhs (p, lhs);
1129 gimple_omp_atomic_load_set_rhs (p, rhs);
1133 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1135 VAL is the value we are storing. */
1138 gimple_build_omp_atomic_store (tree val)
1140 gomp_atomic_store *p
1141 = as_a <gomp_atomic_store *> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE, 0));
1142 gimple_omp_atomic_store_set_val (p, val);
1146 /* Build a GIMPLE_TRANSACTION statement. */
1149 gimple_build_transaction (gimple_seq body)
1152 = as_a <gtransaction *> (gimple_alloc (GIMPLE_TRANSACTION, 0));
1153 gimple_transaction_set_body (p, body);
1154 gimple_transaction_set_label_norm (p, 0);
1155 gimple_transaction_set_label_uninst (p, 0);
1156 gimple_transaction_set_label_over (p, 0);
1160 #if defined ENABLE_GIMPLE_CHECKING
1161 /* Complain of a gimple type mismatch and die. */
1164 gimple_check_failed (const gimple *gs, const char *file, int line,
1165 const char *function, enum gimple_code code,
1166 enum tree_code subcode)
1168 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1169 gimple_code_name[code],
1170 get_tree_code_name (subcode),
1171 gimple_code_name[gimple_code (gs)],
1173 ? get_tree_code_name ((enum tree_code) gs->subcode)
1175 function, trim_filename (file), line);
1177 #endif /* ENABLE_GIMPLE_CHECKING */
1180 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1181 *SEQ_P is NULL, a new sequence is allocated. */
1184 gimple_seq_add_stmt (gimple_seq *seq_p, gimple *gs)
1186 gimple_stmt_iterator si;
1190 si = gsi_last (*seq_p);
1191 gsi_insert_after (&si, gs, GSI_NEW_STMT);
1194 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1195 *SEQ_P is NULL, a new sequence is allocated. This function is
1196 similar to gimple_seq_add_stmt, but does not scan the operands.
1197 During gimplification, we need to manipulate statement sequences
1198 before the def/use vectors have been constructed. */
1201 gimple_seq_add_stmt_without_update (gimple_seq *seq_p, gimple *gs)
1203 gimple_stmt_iterator si;
1208 si = gsi_last (*seq_p);
1209 gsi_insert_after_without_update (&si, gs, GSI_NEW_STMT);
1212 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1213 NULL, a new sequence is allocated. */
1216 gimple_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
1218 gimple_stmt_iterator si;
1222 si = gsi_last (*dst_p);
1223 gsi_insert_seq_after (&si, src, GSI_NEW_STMT);
1226 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1227 NULL, a new sequence is allocated. This function is
1228 similar to gimple_seq_add_seq, but does not scan the operands. */
1231 gimple_seq_add_seq_without_update (gimple_seq *dst_p, gimple_seq src)
1233 gimple_stmt_iterator si;
1237 si = gsi_last (*dst_p);
1238 gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
1241 /* Determine whether to assign a location to the statement GS. */
1244 should_carry_location_p (gimple *gs)
1246 /* Don't emit a line note for a label. We particularly don't want to
1247 emit one for the break label, since it doesn't actually correspond
1248 to the beginning of the loop/switch. */
1249 if (gimple_code (gs) == GIMPLE_LABEL)
1255 /* Set the location for gimple statement GS to LOCATION. */
1258 annotate_one_with_location (gimple *gs, location_t location)
1260 if (!gimple_has_location (gs)
1261 && !gimple_do_not_emit_location_p (gs)
1262 && should_carry_location_p (gs))
1263 gimple_set_location (gs, location);
1266 /* Set LOCATION for all the statements after iterator GSI in sequence
1267 SEQ. If GSI is pointing to the end of the sequence, start with the
1268 first statement in SEQ. */
1271 annotate_all_with_location_after (gimple_seq seq, gimple_stmt_iterator gsi,
1272 location_t location)
1274 if (gsi_end_p (gsi))
1275 gsi = gsi_start (seq);
1279 for (; !gsi_end_p (gsi); gsi_next (&gsi))
1280 annotate_one_with_location (gsi_stmt (gsi), location);
1283 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1286 annotate_all_with_location (gimple_seq stmt_p, location_t location)
1288 gimple_stmt_iterator i;
1290 if (gimple_seq_empty_p (stmt_p))
1293 for (i = gsi_start (stmt_p); !gsi_end_p (i); gsi_next (&i))
1295 gimple *gs = gsi_stmt (i);
1296 annotate_one_with_location (gs, location);
1300 /* Helper function of empty_body_p. Return true if STMT is an empty
1304 empty_stmt_p (gimple *stmt)
1306 if (gimple_code (stmt) == GIMPLE_NOP)
1308 if (gbind *bind_stmt = dyn_cast <gbind *> (stmt))
1309 return empty_body_p (gimple_bind_body (bind_stmt));
1314 /* Return true if BODY contains nothing but empty statements. */
1317 empty_body_p (gimple_seq body)
1319 gimple_stmt_iterator i;
1321 if (gimple_seq_empty_p (body))
1323 for (i = gsi_start (body); !gsi_end_p (i); gsi_next (&i))
1324 if (!empty_stmt_p (gsi_stmt (i))
1325 && !is_gimple_debug (gsi_stmt (i)))
1332 /* Perform a deep copy of sequence SRC and return the result. */
1335 gimple_seq_copy (gimple_seq src)
1337 gimple_stmt_iterator gsi;
1338 gimple_seq new_seq = NULL;
1341 for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi))
1343 stmt = gimple_copy (gsi_stmt (gsi));
1344 gimple_seq_add_stmt (&new_seq, stmt);
1352 /* Return true if calls C1 and C2 are known to go to the same function. */
1355 gimple_call_same_target_p (const gimple *c1, const gimple *c2)
1357 if (gimple_call_internal_p (c1))
1358 return (gimple_call_internal_p (c2)
1359 && gimple_call_internal_fn (c1) == gimple_call_internal_fn (c2)
1360 && (!gimple_call_internal_unique_p (as_a <const gcall *> (c1))
1363 return (gimple_call_fn (c1) == gimple_call_fn (c2)
1364 || (gimple_call_fndecl (c1)
1365 && gimple_call_fndecl (c1) == gimple_call_fndecl (c2)));
1368 /* Detect flags from a GIMPLE_CALL. This is just like
1369 call_expr_flags, but for gimple tuples. */
1372 gimple_call_flags (const gimple *stmt)
1375 tree decl = gimple_call_fndecl (stmt);
1378 flags = flags_from_decl_or_type (decl);
1379 else if (gimple_call_internal_p (stmt))
1380 flags = internal_fn_flags (gimple_call_internal_fn (stmt));
1382 flags = flags_from_decl_or_type (gimple_call_fntype (stmt));
1384 if (stmt->subcode & GF_CALL_NOTHROW)
1385 flags |= ECF_NOTHROW;
1390 /* Return the "fn spec" string for call STMT. */
1393 gimple_call_fnspec (const gcall *stmt)
1397 if (gimple_call_internal_p (stmt))
1398 return internal_fn_fnspec (gimple_call_internal_fn (stmt));
1400 type = gimple_call_fntype (stmt);
1404 attr = lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type));
1408 return TREE_VALUE (TREE_VALUE (attr));
1411 /* Detects argument flags for argument number ARG on call STMT. */
1414 gimple_call_arg_flags (const gcall *stmt, unsigned arg)
1416 const_tree attr = gimple_call_fnspec (stmt);
1418 if (!attr || 1 + arg >= (unsigned) TREE_STRING_LENGTH (attr))
1421 switch (TREE_STRING_POINTER (attr)[1 + arg])
1428 return EAF_DIRECT | EAF_NOCLOBBER | EAF_NOESCAPE;
1431 return EAF_NOCLOBBER | EAF_NOESCAPE;
1434 return EAF_DIRECT | EAF_NOESCAPE;
1437 return EAF_NOESCAPE;
1445 /* Detects return flags for the call STMT. */
1448 gimple_call_return_flags (const gcall *stmt)
1452 if (gimple_call_flags (stmt) & ECF_MALLOC)
1455 attr = gimple_call_fnspec (stmt);
1456 if (!attr || TREE_STRING_LENGTH (attr) < 1)
1459 switch (TREE_STRING_POINTER (attr)[0])
1465 return ERF_RETURNS_ARG | (TREE_STRING_POINTER (attr)[0] - '1');
1477 /* Return true if GS is a copy assignment. */
1480 gimple_assign_copy_p (gimple *gs)
1482 return (gimple_assign_single_p (gs)
1483 && is_gimple_val (gimple_op (gs, 1)));
1487 /* Return true if GS is a SSA_NAME copy assignment. */
1490 gimple_assign_ssa_name_copy_p (gimple *gs)
1492 return (gimple_assign_single_p (gs)
1493 && TREE_CODE (gimple_assign_lhs (gs)) == SSA_NAME
1494 && TREE_CODE (gimple_assign_rhs1 (gs)) == SSA_NAME);
1498 /* Return true if GS is an assignment with a unary RHS, but the
1499 operator has no effect on the assigned value. The logic is adapted
1500 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1501 instances in which STRIP_NOPS was previously applied to the RHS of
1504 NOTE: In the use cases that led to the creation of this function
1505 and of gimple_assign_single_p, it is typical to test for either
1506 condition and to proceed in the same manner. In each case, the
1507 assigned value is represented by the single RHS operand of the
1508 assignment. I suspect there may be cases where gimple_assign_copy_p,
1509 gimple_assign_single_p, or equivalent logic is used where a similar
1510 treatment of unary NOPs is appropriate. */
1513 gimple_assign_unary_nop_p (gimple *gs)
1515 return (is_gimple_assign (gs)
1516 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
1517 || gimple_assign_rhs_code (gs) == NON_LVALUE_EXPR)
1518 && gimple_assign_rhs1 (gs) != error_mark_node
1519 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs)))
1520 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs)))));
1523 /* Set BB to be the basic block holding G. */
1526 gimple_set_bb (gimple *stmt, basic_block bb)
1530 if (gimple_code (stmt) != GIMPLE_LABEL)
1533 /* If the statement is a label, add the label to block-to-labels map
1534 so that we can speed up edge creation for GIMPLE_GOTOs. */
1540 t = gimple_label_label (as_a <glabel *> (stmt));
1541 uid = LABEL_DECL_UID (t);
1545 vec_safe_length (label_to_block_map_for_fn (cfun));
1546 LABEL_DECL_UID (t) = uid = cfun->cfg->last_label_uid++;
1547 if (old_len <= (unsigned) uid)
1549 unsigned new_len = 3 * uid / 2 + 1;
1551 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun),
1556 (*label_to_block_map_for_fn (cfun))[uid] = bb;
1561 /* Modify the RHS of the assignment pointed-to by GSI using the
1562 operands in the expression tree EXPR.
1564 NOTE: The statement pointed-to by GSI may be reallocated if it
1565 did not have enough operand slots.
1567 This function is useful to convert an existing tree expression into
1568 the flat representation used for the RHS of a GIMPLE assignment.
1569 It will reallocate memory as needed to expand or shrink the number
1570 of operand slots needed to represent EXPR.
1572 NOTE: If you find yourself building a tree and then calling this
1573 function, you are most certainly doing it the slow way. It is much
1574 better to build a new assignment or to use the function
1575 gimple_assign_set_rhs_with_ops, which does not require an
1576 expression tree to be built. */
1579 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *gsi, tree expr)
1581 enum tree_code subcode;
1584 extract_ops_from_tree (expr, &subcode, &op1, &op2, &op3);
1585 gimple_assign_set_rhs_with_ops (gsi, subcode, op1, op2, op3);
1589 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1590 operands OP1, OP2 and OP3.
1592 NOTE: The statement pointed-to by GSI may be reallocated if it
1593 did not have enough operand slots. */
1596 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
1597 tree op1, tree op2, tree op3)
1599 unsigned new_rhs_ops = get_gimple_rhs_num_ops (code);
1600 gimple *stmt = gsi_stmt (*gsi);
1602 /* If the new CODE needs more operands, allocate a new statement. */
1603 if (gimple_num_ops (stmt) < new_rhs_ops + 1)
1605 tree lhs = gimple_assign_lhs (stmt);
1606 gimple *new_stmt = gimple_alloc (gimple_code (stmt), new_rhs_ops + 1);
1607 memcpy (new_stmt, stmt, gimple_size (gimple_code (stmt)));
1608 gimple_init_singleton (new_stmt);
1609 gsi_replace (gsi, new_stmt, true);
1612 /* The LHS needs to be reset as this also changes the SSA name
1614 gimple_assign_set_lhs (stmt, lhs);
1617 gimple_set_num_ops (stmt, new_rhs_ops + 1);
1618 gimple_set_subcode (stmt, code);
1619 gimple_assign_set_rhs1 (stmt, op1);
1620 if (new_rhs_ops > 1)
1621 gimple_assign_set_rhs2 (stmt, op2);
1622 if (new_rhs_ops > 2)
1623 gimple_assign_set_rhs3 (stmt, op3);
1627 /* Return the LHS of a statement that performs an assignment,
1628 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1629 for a call to a function that returns no value, or for a
1630 statement other than an assignment or a call. */
1633 gimple_get_lhs (const gimple *stmt)
1635 enum gimple_code code = gimple_code (stmt);
1637 if (code == GIMPLE_ASSIGN)
1638 return gimple_assign_lhs (stmt);
1639 else if (code == GIMPLE_CALL)
1640 return gimple_call_lhs (stmt);
1646 /* Set the LHS of a statement that performs an assignment,
1647 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1650 gimple_set_lhs (gimple *stmt, tree lhs)
1652 enum gimple_code code = gimple_code (stmt);
1654 if (code == GIMPLE_ASSIGN)
1655 gimple_assign_set_lhs (stmt, lhs);
1656 else if (code == GIMPLE_CALL)
1657 gimple_call_set_lhs (stmt, lhs);
1663 /* Return a deep copy of statement STMT. All the operands from STMT
1664 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1665 and VUSE operand arrays are set to empty in the new copy. The new
1666 copy isn't part of any sequence. */
1669 gimple_copy (gimple *stmt)
1671 enum gimple_code code = gimple_code (stmt);
1672 unsigned num_ops = gimple_num_ops (stmt);
1673 gimple *copy = gimple_alloc (code, num_ops);
1676 /* Shallow copy all the fields from STMT. */
1677 memcpy (copy, stmt, gimple_size (code));
1678 gimple_init_singleton (copy);
1680 /* If STMT has sub-statements, deep-copy them as well. */
1681 if (gimple_has_substatements (stmt))
1686 switch (gimple_code (stmt))
1690 gbind *bind_stmt = as_a <gbind *> (stmt);
1691 gbind *bind_copy = as_a <gbind *> (copy);
1692 new_seq = gimple_seq_copy (gimple_bind_body (bind_stmt));
1693 gimple_bind_set_body (bind_copy, new_seq);
1694 gimple_bind_set_vars (bind_copy,
1695 unshare_expr (gimple_bind_vars (bind_stmt)));
1696 gimple_bind_set_block (bind_copy, gimple_bind_block (bind_stmt));
1702 gcatch *catch_stmt = as_a <gcatch *> (stmt);
1703 gcatch *catch_copy = as_a <gcatch *> (copy);
1704 new_seq = gimple_seq_copy (gimple_catch_handler (catch_stmt));
1705 gimple_catch_set_handler (catch_copy, new_seq);
1706 t = unshare_expr (gimple_catch_types (catch_stmt));
1707 gimple_catch_set_types (catch_copy, t);
1711 case GIMPLE_EH_FILTER:
1713 geh_filter *eh_filter_stmt = as_a <geh_filter *> (stmt);
1714 geh_filter *eh_filter_copy = as_a <geh_filter *> (copy);
1716 = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt));
1717 gimple_eh_filter_set_failure (eh_filter_copy, new_seq);
1718 t = unshare_expr (gimple_eh_filter_types (eh_filter_stmt));
1719 gimple_eh_filter_set_types (eh_filter_copy, t);
1723 case GIMPLE_EH_ELSE:
1725 geh_else *eh_else_stmt = as_a <geh_else *> (stmt);
1726 geh_else *eh_else_copy = as_a <geh_else *> (copy);
1727 new_seq = gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt));
1728 gimple_eh_else_set_n_body (eh_else_copy, new_seq);
1729 new_seq = gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt));
1730 gimple_eh_else_set_e_body (eh_else_copy, new_seq);
1736 gtry *try_stmt = as_a <gtry *> (stmt);
1737 gtry *try_copy = as_a <gtry *> (copy);
1738 new_seq = gimple_seq_copy (gimple_try_eval (try_stmt));
1739 gimple_try_set_eval (try_copy, new_seq);
1740 new_seq = gimple_seq_copy (gimple_try_cleanup (try_stmt));
1741 gimple_try_set_cleanup (try_copy, new_seq);
1745 case GIMPLE_OMP_FOR:
1746 new_seq = gimple_seq_copy (gimple_omp_for_pre_body (stmt));
1747 gimple_omp_for_set_pre_body (copy, new_seq);
1748 t = unshare_expr (gimple_omp_for_clauses (stmt));
1749 gimple_omp_for_set_clauses (copy, t);
1751 gomp_for *omp_for_copy = as_a <gomp_for *> (copy);
1752 omp_for_copy->iter = ggc_vec_alloc<gimple_omp_for_iter>
1753 ( gimple_omp_for_collapse (stmt));
1755 for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
1757 gimple_omp_for_set_cond (copy, i,
1758 gimple_omp_for_cond (stmt, i));
1759 gimple_omp_for_set_index (copy, i,
1760 gimple_omp_for_index (stmt, i));
1761 t = unshare_expr (gimple_omp_for_initial (stmt, i));
1762 gimple_omp_for_set_initial (copy, i, t);
1763 t = unshare_expr (gimple_omp_for_final (stmt, i));
1764 gimple_omp_for_set_final (copy, i, t);
1765 t = unshare_expr (gimple_omp_for_incr (stmt, i));
1766 gimple_omp_for_set_incr (copy, i, t);
1770 case GIMPLE_OMP_PARALLEL:
1772 gomp_parallel *omp_par_stmt = as_a <gomp_parallel *> (stmt);
1773 gomp_parallel *omp_par_copy = as_a <gomp_parallel *> (copy);
1774 t = unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt));
1775 gimple_omp_parallel_set_clauses (omp_par_copy, t);
1776 t = unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt));
1777 gimple_omp_parallel_set_child_fn (omp_par_copy, t);
1778 t = unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt));
1779 gimple_omp_parallel_set_data_arg (omp_par_copy, t);
1783 case GIMPLE_OMP_TASK:
1784 t = unshare_expr (gimple_omp_task_clauses (stmt));
1785 gimple_omp_task_set_clauses (copy, t);
1786 t = unshare_expr (gimple_omp_task_child_fn (stmt));
1787 gimple_omp_task_set_child_fn (copy, t);
1788 t = unshare_expr (gimple_omp_task_data_arg (stmt));
1789 gimple_omp_task_set_data_arg (copy, t);
1790 t = unshare_expr (gimple_omp_task_copy_fn (stmt));
1791 gimple_omp_task_set_copy_fn (copy, t);
1792 t = unshare_expr (gimple_omp_task_arg_size (stmt));
1793 gimple_omp_task_set_arg_size (copy, t);
1794 t = unshare_expr (gimple_omp_task_arg_align (stmt));
1795 gimple_omp_task_set_arg_align (copy, t);
1798 case GIMPLE_OMP_CRITICAL:
1799 t = unshare_expr (gimple_omp_critical_name
1800 (as_a <gomp_critical *> (stmt)));
1801 gimple_omp_critical_set_name (as_a <gomp_critical *> (copy), t);
1802 t = unshare_expr (gimple_omp_critical_clauses
1803 (as_a <gomp_critical *> (stmt)));
1804 gimple_omp_critical_set_clauses (as_a <gomp_critical *> (copy), t);
1807 case GIMPLE_OMP_ORDERED:
1808 t = unshare_expr (gimple_omp_ordered_clauses
1809 (as_a <gomp_ordered *> (stmt)));
1810 gimple_omp_ordered_set_clauses (as_a <gomp_ordered *> (copy), t);
1813 case GIMPLE_OMP_SECTIONS:
1814 t = unshare_expr (gimple_omp_sections_clauses (stmt));
1815 gimple_omp_sections_set_clauses (copy, t);
1816 t = unshare_expr (gimple_omp_sections_control (stmt));
1817 gimple_omp_sections_set_control (copy, t);
1820 case GIMPLE_OMP_SINGLE:
1821 case GIMPLE_OMP_TARGET:
1822 case GIMPLE_OMP_TEAMS:
1823 case GIMPLE_OMP_SECTION:
1824 case GIMPLE_OMP_MASTER:
1825 case GIMPLE_OMP_TASKGROUP:
1826 case GIMPLE_OMP_GRID_BODY:
1828 new_seq = gimple_seq_copy (gimple_omp_body (stmt));
1829 gimple_omp_set_body (copy, new_seq);
1832 case GIMPLE_TRANSACTION:
1833 new_seq = gimple_seq_copy (gimple_transaction_body (
1834 as_a <gtransaction *> (stmt)));
1835 gimple_transaction_set_body (as_a <gtransaction *> (copy),
1839 case GIMPLE_WITH_CLEANUP_EXPR:
1840 new_seq = gimple_seq_copy (gimple_wce_cleanup (stmt));
1841 gimple_wce_set_cleanup (copy, new_seq);
1849 /* Make copy of operands. */
1850 for (i = 0; i < num_ops; i++)
1851 gimple_set_op (copy, i, unshare_expr (gimple_op (stmt, i)));
1853 if (gimple_has_mem_ops (stmt))
1855 gimple_set_vdef (copy, gimple_vdef (stmt));
1856 gimple_set_vuse (copy, gimple_vuse (stmt));
1859 /* Clear out SSA operand vectors on COPY. */
1860 if (gimple_has_ops (stmt))
1862 gimple_set_use_ops (copy, NULL);
1864 /* SSA operands need to be updated. */
1865 gimple_set_modified (copy, true);
1872 /* Return true if statement S has side-effects. We consider a
1873 statement to have side effects if:
1875 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
1876 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
1879 gimple_has_side_effects (const gimple *s)
1881 if (is_gimple_debug (s))
1884 /* We don't have to scan the arguments to check for
1885 volatile arguments, though, at present, we still
1886 do a scan to check for TREE_SIDE_EFFECTS. */
1887 if (gimple_has_volatile_ops (s))
1890 if (gimple_code (s) == GIMPLE_ASM
1891 && gimple_asm_volatile_p (as_a <const gasm *> (s)))
1894 if (is_gimple_call (s))
1896 int flags = gimple_call_flags (s);
1898 /* An infinite loop is considered a side effect. */
1899 if (!(flags & (ECF_CONST | ECF_PURE))
1900 || (flags & ECF_LOOPING_CONST_OR_PURE))
1909 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
1910 Return true if S can trap. When INCLUDE_MEM is true, check whether
1911 the memory operations could trap. When INCLUDE_STORES is true and
1912 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
1915 gimple_could_trap_p_1 (gimple *s, bool include_mem, bool include_stores)
1917 tree t, div = NULL_TREE;
1922 unsigned i, start = (is_gimple_assign (s) && !include_stores) ? 1 : 0;
1924 for (i = start; i < gimple_num_ops (s); i++)
1925 if (tree_could_trap_p (gimple_op (s, i)))
1929 switch (gimple_code (s))
1932 return gimple_asm_volatile_p (as_a <gasm *> (s));
1935 t = gimple_call_fndecl (s);
1936 /* Assume that calls to weak functions may trap. */
1937 if (!t || !DECL_P (t) || DECL_WEAK (t))
1942 t = gimple_expr_type (s);
1943 op = gimple_assign_rhs_code (s);
1944 if (get_gimple_rhs_class (op) == GIMPLE_BINARY_RHS)
1945 div = gimple_assign_rhs2 (s);
1946 return (operation_could_trap_p (op, FLOAT_TYPE_P (t),
1947 (INTEGRAL_TYPE_P (t)
1948 && TYPE_OVERFLOW_TRAPS (t)),
1952 t = TREE_TYPE (gimple_cond_lhs (s));
1953 return operation_could_trap_p (gimple_cond_code (s),
1954 FLOAT_TYPE_P (t), false, NULL_TREE);
1963 /* Return true if statement S can trap. */
1966 gimple_could_trap_p (gimple *s)
1968 return gimple_could_trap_p_1 (s, true, true);
1971 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
1974 gimple_assign_rhs_could_trap_p (gimple *s)
1976 gcc_assert (is_gimple_assign (s));
1977 return gimple_could_trap_p_1 (s, true, false);
1981 /* Print debugging information for gimple stmts generated. */
1984 dump_gimple_statistics (void)
1986 int i, total_tuples = 0, total_bytes = 0;
1988 if (! GATHER_STATISTICS)
1990 fprintf (stderr, "No gimple statistics\n");
1994 fprintf (stderr, "\nGIMPLE statements\n");
1995 fprintf (stderr, "Kind Stmts Bytes\n");
1996 fprintf (stderr, "---------------------------------------\n");
1997 for (i = 0; i < (int) gimple_alloc_kind_all; ++i)
1999 fprintf (stderr, "%-20s %7d %10d\n", gimple_alloc_kind_names[i],
2000 gimple_alloc_counts[i], gimple_alloc_sizes[i]);
2001 total_tuples += gimple_alloc_counts[i];
2002 total_bytes += gimple_alloc_sizes[i];
2004 fprintf (stderr, "---------------------------------------\n");
2005 fprintf (stderr, "%-20s %7d %10d\n", "Total", total_tuples, total_bytes);
2006 fprintf (stderr, "---------------------------------------\n");
2010 /* Return the number of operands needed on the RHS of a GIMPLE
2011 assignment for an expression with tree code CODE. */
2014 get_gimple_rhs_num_ops (enum tree_code code)
2016 enum gimple_rhs_class rhs_class = get_gimple_rhs_class (code);
2018 if (rhs_class == GIMPLE_UNARY_RHS || rhs_class == GIMPLE_SINGLE_RHS)
2020 else if (rhs_class == GIMPLE_BINARY_RHS)
2022 else if (rhs_class == GIMPLE_TERNARY_RHS)
2028 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2030 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2031 : ((TYPE) == tcc_binary \
2032 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2033 : ((TYPE) == tcc_constant \
2034 || (TYPE) == tcc_declaration \
2035 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2036 : ((SYM) == TRUTH_AND_EXPR \
2037 || (SYM) == TRUTH_OR_EXPR \
2038 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2039 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2040 : ((SYM) == COND_EXPR \
2041 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2042 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2043 || (SYM) == DOT_PROD_EXPR \
2044 || (SYM) == SAD_EXPR \
2045 || (SYM) == REALIGN_LOAD_EXPR \
2046 || (SYM) == VEC_COND_EXPR \
2047 || (SYM) == VEC_PERM_EXPR \
2048 || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS \
2049 : ((SYM) == CONSTRUCTOR \
2050 || (SYM) == OBJ_TYPE_REF \
2051 || (SYM) == ASSERT_EXPR \
2052 || (SYM) == ADDR_EXPR \
2053 || (SYM) == WITH_SIZE_EXPR \
2054 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2055 : ((SYM) == STATEMENT_LIST_END) ? GIMPLE_SINGLE_RHS \
2056 : GIMPLE_INVALID_RHS),
2057 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2059 const unsigned char gimple_rhs_class_table[] = {
2060 #include "all-tree.def"
2064 #undef END_OF_BASE_TREE_CODES
2066 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2067 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2068 we failed to create one. */
2071 canonicalize_cond_expr_cond (tree t)
2073 /* Strip conversions around boolean operations. */
2074 if (CONVERT_EXPR_P (t)
2075 && (truth_value_p (TREE_CODE (TREE_OPERAND (t, 0)))
2076 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0)))
2078 t = TREE_OPERAND (t, 0);
2080 /* For !x use x == 0. */
2081 if (TREE_CODE (t) == TRUTH_NOT_EXPR)
2083 tree top0 = TREE_OPERAND (t, 0);
2084 t = build2 (EQ_EXPR, TREE_TYPE (t),
2085 top0, build_int_cst (TREE_TYPE (top0), 0));
2087 /* For cmp ? 1 : 0 use cmp. */
2088 else if (TREE_CODE (t) == COND_EXPR
2089 && COMPARISON_CLASS_P (TREE_OPERAND (t, 0))
2090 && integer_onep (TREE_OPERAND (t, 1))
2091 && integer_zerop (TREE_OPERAND (t, 2)))
2093 tree top0 = TREE_OPERAND (t, 0);
2094 t = build2 (TREE_CODE (top0), TREE_TYPE (t),
2095 TREE_OPERAND (top0, 0), TREE_OPERAND (top0, 1));
2097 /* For x ^ y use x != y. */
2098 else if (TREE_CODE (t) == BIT_XOR_EXPR)
2099 t = build2 (NE_EXPR, TREE_TYPE (t),
2100 TREE_OPERAND (t, 0), TREE_OPERAND (t, 1));
2102 if (is_gimple_condexpr (t))
2108 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2109 the positions marked by the set ARGS_TO_SKIP. */
2112 gimple_call_copy_skip_args (gcall *stmt, bitmap args_to_skip)
2115 int nargs = gimple_call_num_args (stmt);
2116 auto_vec<tree> vargs (nargs);
2119 for (i = 0; i < nargs; i++)
2120 if (!bitmap_bit_p (args_to_skip, i))
2121 vargs.quick_push (gimple_call_arg (stmt, i));
2123 if (gimple_call_internal_p (stmt))
2124 new_stmt = gimple_build_call_internal_vec (gimple_call_internal_fn (stmt),
2127 new_stmt = gimple_build_call_vec (gimple_call_fn (stmt), vargs);
2129 if (gimple_call_lhs (stmt))
2130 gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
2132 gimple_set_vuse (new_stmt, gimple_vuse (stmt));
2133 gimple_set_vdef (new_stmt, gimple_vdef (stmt));
2135 if (gimple_has_location (stmt))
2136 gimple_set_location (new_stmt, gimple_location (stmt));
2137 gimple_call_copy_flags (new_stmt, stmt);
2138 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
2140 gimple_set_modified (new_stmt, true);
2147 /* Return true if the field decls F1 and F2 are at the same offset.
2149 This is intended to be used on GIMPLE types only. */
2152 gimple_compare_field_offset (tree f1, tree f2)
2154 if (DECL_OFFSET_ALIGN (f1) == DECL_OFFSET_ALIGN (f2))
2156 tree offset1 = DECL_FIELD_OFFSET (f1);
2157 tree offset2 = DECL_FIELD_OFFSET (f2);
2158 return ((offset1 == offset2
2159 /* Once gimplification is done, self-referential offsets are
2160 instantiated as operand #2 of the COMPONENT_REF built for
2161 each access and reset. Therefore, they are not relevant
2162 anymore and fields are interchangeable provided that they
2163 represent the same access. */
2164 || (TREE_CODE (offset1) == PLACEHOLDER_EXPR
2165 && TREE_CODE (offset2) == PLACEHOLDER_EXPR
2166 && (DECL_SIZE (f1) == DECL_SIZE (f2)
2167 || (TREE_CODE (DECL_SIZE (f1)) == PLACEHOLDER_EXPR
2168 && TREE_CODE (DECL_SIZE (f2)) == PLACEHOLDER_EXPR)
2169 || operand_equal_p (DECL_SIZE (f1), DECL_SIZE (f2), 0))
2170 && DECL_ALIGN (f1) == DECL_ALIGN (f2))
2171 || operand_equal_p (offset1, offset2, 0))
2172 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1),
2173 DECL_FIELD_BIT_OFFSET (f2)));
2176 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2177 should be, so handle differing ones specially by decomposing
2178 the offset into a byte and bit offset manually. */
2179 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1))
2180 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2)))
2182 unsigned HOST_WIDE_INT byte_offset1, byte_offset2;
2183 unsigned HOST_WIDE_INT bit_offset1, bit_offset2;
2184 bit_offset1 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1));
2185 byte_offset1 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1))
2186 + bit_offset1 / BITS_PER_UNIT);
2187 bit_offset2 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2));
2188 byte_offset2 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2))
2189 + bit_offset2 / BITS_PER_UNIT);
2190 if (byte_offset1 != byte_offset2)
2192 return bit_offset1 % BITS_PER_UNIT == bit_offset2 % BITS_PER_UNIT;
2199 /* Return a type the same as TYPE except unsigned or
2200 signed according to UNSIGNEDP. */
2203 gimple_signed_or_unsigned_type (bool unsignedp, tree type)
2208 type1 = TYPE_MAIN_VARIANT (type);
2209 if (type1 == signed_char_type_node
2210 || type1 == char_type_node
2211 || type1 == unsigned_char_type_node)
2212 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2213 if (type1 == integer_type_node || type1 == unsigned_type_node)
2214 return unsignedp ? unsigned_type_node : integer_type_node;
2215 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
2216 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2217 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
2218 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2219 if (type1 == long_long_integer_type_node
2220 || type1 == long_long_unsigned_type_node)
2222 ? long_long_unsigned_type_node
2223 : long_long_integer_type_node;
2225 for (i = 0; i < NUM_INT_N_ENTS; i ++)
2226 if (int_n_enabled_p[i]
2227 && (type1 == int_n_trees[i].unsigned_type
2228 || type1 == int_n_trees[i].signed_type))
2230 ? int_n_trees[i].unsigned_type
2231 : int_n_trees[i].signed_type;
2233 #if HOST_BITS_PER_WIDE_INT >= 64
2234 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
2235 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2237 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
2238 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2239 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
2240 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2241 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
2242 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2243 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
2244 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2246 #define GIMPLE_FIXED_TYPES(NAME) \
2247 if (type1 == short_ ## NAME ## _type_node \
2248 || type1 == unsigned_short_ ## NAME ## _type_node) \
2249 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2250 : short_ ## NAME ## _type_node; \
2251 if (type1 == NAME ## _type_node \
2252 || type1 == unsigned_ ## NAME ## _type_node) \
2253 return unsignedp ? unsigned_ ## NAME ## _type_node \
2254 : NAME ## _type_node; \
2255 if (type1 == long_ ## NAME ## _type_node \
2256 || type1 == unsigned_long_ ## NAME ## _type_node) \
2257 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2258 : long_ ## NAME ## _type_node; \
2259 if (type1 == long_long_ ## NAME ## _type_node \
2260 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2261 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2262 : long_long_ ## NAME ## _type_node;
2264 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2265 if (type1 == NAME ## _type_node \
2266 || type1 == u ## NAME ## _type_node) \
2267 return unsignedp ? u ## NAME ## _type_node \
2268 : NAME ## _type_node;
2270 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2271 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2272 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2273 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2274 : sat_ ## short_ ## NAME ## _type_node; \
2275 if (type1 == sat_ ## NAME ## _type_node \
2276 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2277 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2278 : sat_ ## NAME ## _type_node; \
2279 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2280 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2281 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2282 : sat_ ## long_ ## NAME ## _type_node; \
2283 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2284 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2285 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2286 : sat_ ## long_long_ ## NAME ## _type_node;
2288 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2289 if (type1 == sat_ ## NAME ## _type_node \
2290 || type1 == sat_ ## u ## NAME ## _type_node) \
2291 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2292 : sat_ ## NAME ## _type_node;
2294 GIMPLE_FIXED_TYPES (fract);
2295 GIMPLE_FIXED_TYPES_SAT (fract);
2296 GIMPLE_FIXED_TYPES (accum);
2297 GIMPLE_FIXED_TYPES_SAT (accum);
2299 GIMPLE_FIXED_MODE_TYPES (qq);
2300 GIMPLE_FIXED_MODE_TYPES (hq);
2301 GIMPLE_FIXED_MODE_TYPES (sq);
2302 GIMPLE_FIXED_MODE_TYPES (dq);
2303 GIMPLE_FIXED_MODE_TYPES (tq);
2304 GIMPLE_FIXED_MODE_TYPES_SAT (qq);
2305 GIMPLE_FIXED_MODE_TYPES_SAT (hq);
2306 GIMPLE_FIXED_MODE_TYPES_SAT (sq);
2307 GIMPLE_FIXED_MODE_TYPES_SAT (dq);
2308 GIMPLE_FIXED_MODE_TYPES_SAT (tq);
2309 GIMPLE_FIXED_MODE_TYPES (ha);
2310 GIMPLE_FIXED_MODE_TYPES (sa);
2311 GIMPLE_FIXED_MODE_TYPES (da);
2312 GIMPLE_FIXED_MODE_TYPES (ta);
2313 GIMPLE_FIXED_MODE_TYPES_SAT (ha);
2314 GIMPLE_FIXED_MODE_TYPES_SAT (sa);
2315 GIMPLE_FIXED_MODE_TYPES_SAT (da);
2316 GIMPLE_FIXED_MODE_TYPES_SAT (ta);
2318 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2319 the precision; they have precision set to match their range, but
2320 may use a wider mode to match an ABI. If we change modes, we may
2321 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2322 the precision as well, so as to yield correct results for
2323 bit-field types. C++ does not have these separate bit-field
2324 types, and producing a signed or unsigned variant of an
2325 ENUMERAL_TYPE may cause other problems as well. */
2326 if (!INTEGRAL_TYPE_P (type)
2327 || TYPE_UNSIGNED (type) == unsignedp)
2330 #define TYPE_OK(node) \
2331 (TYPE_MODE (type) == TYPE_MODE (node) \
2332 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2333 if (TYPE_OK (signed_char_type_node))
2334 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2335 if (TYPE_OK (integer_type_node))
2336 return unsignedp ? unsigned_type_node : integer_type_node;
2337 if (TYPE_OK (short_integer_type_node))
2338 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2339 if (TYPE_OK (long_integer_type_node))
2340 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2341 if (TYPE_OK (long_long_integer_type_node))
2343 ? long_long_unsigned_type_node
2344 : long_long_integer_type_node);
2346 for (i = 0; i < NUM_INT_N_ENTS; i ++)
2347 if (int_n_enabled_p[i]
2348 && TYPE_MODE (type) == int_n_data[i].m
2349 && TYPE_PRECISION (type) == int_n_data[i].bitsize)
2351 ? int_n_trees[i].unsigned_type
2352 : int_n_trees[i].signed_type;
2354 #if HOST_BITS_PER_WIDE_INT >= 64
2355 if (TYPE_OK (intTI_type_node))
2356 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2358 if (TYPE_OK (intDI_type_node))
2359 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2360 if (TYPE_OK (intSI_type_node))
2361 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2362 if (TYPE_OK (intHI_type_node))
2363 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2364 if (TYPE_OK (intQI_type_node))
2365 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2367 #undef GIMPLE_FIXED_TYPES
2368 #undef GIMPLE_FIXED_MODE_TYPES
2369 #undef GIMPLE_FIXED_TYPES_SAT
2370 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2373 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2377 /* Return an unsigned type the same as TYPE in other respects. */
2380 gimple_unsigned_type (tree type)
2382 return gimple_signed_or_unsigned_type (true, type);
2386 /* Return a signed type the same as TYPE in other respects. */
2389 gimple_signed_type (tree type)
2391 return gimple_signed_or_unsigned_type (false, type);
2395 /* Return the typed-based alias set for T, which may be an expression
2396 or a type. Return -1 if we don't do anything special. */
2399 gimple_get_alias_set (tree t)
2403 /* Permit type-punning when accessing a union, provided the access
2404 is directly through the union. For example, this code does not
2405 permit taking the address of a union member and then storing
2406 through it. Even the type-punning allowed here is a GCC
2407 extension, albeit a common and useful one; the C standard says
2408 that such accesses have implementation-defined behavior. */
2410 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2411 u = TREE_OPERAND (u, 0))
2412 if (TREE_CODE (u) == COMPONENT_REF
2413 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2416 /* That's all the expressions we handle specially. */
2420 /* For convenience, follow the C standard when dealing with
2421 character types. Any object may be accessed via an lvalue that
2422 has character type. */
2423 if (t == char_type_node
2424 || t == signed_char_type_node
2425 || t == unsigned_char_type_node)
2428 /* Allow aliasing between signed and unsigned variants of the same
2429 type. We treat the signed variant as canonical. */
2430 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2432 tree t1 = gimple_signed_type (t);
2434 /* t1 == t can happen for boolean nodes which are always unsigned. */
2436 return get_alias_set (t1);
2443 /* Helper for gimple_ior_addresses_taken_1. */
2446 gimple_ior_addresses_taken_1 (gimple *, tree addr, tree, void *data)
2448 bitmap addresses_taken = (bitmap)data;
2449 addr = get_base_address (addr);
2453 bitmap_set_bit (addresses_taken, DECL_UID (addr));
2459 /* Set the bit for the uid of all decls that have their address taken
2460 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2461 were any in this stmt. */
2464 gimple_ior_addresses_taken (bitmap addresses_taken, gimple *stmt)
2466 return walk_stmt_load_store_addr_ops (stmt, addresses_taken, NULL, NULL,
2467 gimple_ior_addresses_taken_1);
2471 /* Return true when STMTs arguments and return value match those of FNDECL,
2472 a decl of a builtin function. */
2475 gimple_builtin_call_types_compatible_p (const gimple *stmt, tree fndecl)
2477 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN);
2479 tree ret = gimple_call_lhs (stmt);
2481 && !useless_type_conversion_p (TREE_TYPE (ret),
2482 TREE_TYPE (TREE_TYPE (fndecl))))
2485 tree targs = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2486 unsigned nargs = gimple_call_num_args (stmt);
2487 for (unsigned i = 0; i < nargs; ++i)
2489 /* Variadic args follow. */
2492 tree arg = gimple_call_arg (stmt, i);
2493 if (!useless_type_conversion_p (TREE_VALUE (targs), TREE_TYPE (arg)))
2495 targs = TREE_CHAIN (targs);
2497 if (targs && !VOID_TYPE_P (TREE_VALUE (targs)))
2502 /* Return true when STMT is builtins call. */
2505 gimple_call_builtin_p (const gimple *stmt)
2508 if (is_gimple_call (stmt)
2509 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2510 && DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN)
2511 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2515 /* Return true when STMT is builtins call to CLASS. */
2518 gimple_call_builtin_p (const gimple *stmt, enum built_in_class klass)
2521 if (is_gimple_call (stmt)
2522 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2523 && DECL_BUILT_IN_CLASS (fndecl) == klass)
2524 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2528 /* Return true when STMT is builtins call to CODE of CLASS. */
2531 gimple_call_builtin_p (const gimple *stmt, enum built_in_function code)
2534 if (is_gimple_call (stmt)
2535 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2536 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
2537 && DECL_FUNCTION_CODE (fndecl) == code)
2538 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2542 /* If CALL is a call to a combined_fn (i.e. an internal function or
2543 a normal built-in function), return its code, otherwise return
2547 gimple_call_combined_fn (const gimple *stmt)
2549 if (const gcall *call = dyn_cast <const gcall *> (stmt))
2551 if (gimple_call_internal_p (call))
2552 return as_combined_fn (gimple_call_internal_fn (call));
2554 tree fndecl = gimple_call_fndecl (stmt);
2556 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
2557 && gimple_builtin_call_types_compatible_p (stmt, fndecl))
2558 return as_combined_fn (DECL_FUNCTION_CODE (fndecl));
2563 /* Return true if STMT clobbers memory. STMT is required to be a
2567 gimple_asm_clobbers_memory_p (const gasm *stmt)
2571 for (i = 0; i < gimple_asm_nclobbers (stmt); i++)
2573 tree op = gimple_asm_clobber_op (stmt, i);
2574 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op)), "memory") == 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 return tree_to_uhwi (gimple_call_arg (call, 0)) == ASAN_MARK_UNPOISON;
2631 if (gimple_call_flags (call) & ECF_LEAF)
2636 tree fndecl = gimple_call_fndecl (call);
2639 struct cgraph_node *n = cgraph_node::get (fndecl);
2642 enum availability availability;
2643 n = n->function_symbol (&availability);
2644 if (!n || availability <= AVAIL_INTERPOSABLE)
2646 return n->nonfreeing_fn;
2649 /* Return true when CALL is a call stmt that definitely need not
2650 be considered to be a memory barrier. */
2652 nonbarrier_call_p (gimple *call)
2654 if (gimple_call_flags (call) & (ECF_PURE | ECF_CONST))
2656 /* Should extend this to have a nonbarrier_fn flag, just as above in
2657 the nonfreeing case. */
2661 /* Callback for walk_stmt_load_store_ops.
2663 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2666 This routine only makes a superficial check for a dereference. Thus
2667 it must only be used if it is safe to return a false negative. */
2669 check_loadstore (gimple *, tree op, tree, void *data)
2671 if (TREE_CODE (op) == MEM_REF || TREE_CODE (op) == TARGET_MEM_REF)
2673 /* Some address spaces may legitimately dereference zero. */
2674 addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (op));
2675 if (targetm.addr_space.zero_address_valid (as))
2678 return operand_equal_p (TREE_OPERAND (op, 0), (tree)data, 0);
2684 /* Return true if OP can be inferred to be non-NULL after STMT executes,
2685 either by using a pointer dereference or attributes. */
2687 infer_nonnull_range (gimple *stmt, tree op)
2689 return infer_nonnull_range_by_dereference (stmt, op)
2690 || infer_nonnull_range_by_attribute (stmt, op);
2693 /* Return true if OP can be inferred to be non-NULL after STMT
2694 executes by using a pointer dereference. */
2696 infer_nonnull_range_by_dereference (gimple *stmt, tree op)
2698 /* We can only assume that a pointer dereference will yield
2699 non-NULL if -fdelete-null-pointer-checks is enabled. */
2700 if (!flag_delete_null_pointer_checks
2701 || !POINTER_TYPE_P (TREE_TYPE (op))
2702 || gimple_code (stmt) == GIMPLE_ASM)
2705 if (walk_stmt_load_store_ops (stmt, (void *)op,
2706 check_loadstore, check_loadstore))
2712 /* Return true if OP can be inferred to be a non-NULL after STMT
2713 executes by using attributes. */
2715 infer_nonnull_range_by_attribute (gimple *stmt, tree op)
2717 /* We can only assume that a pointer dereference will yield
2718 non-NULL if -fdelete-null-pointer-checks is enabled. */
2719 if (!flag_delete_null_pointer_checks
2720 || !POINTER_TYPE_P (TREE_TYPE (op))
2721 || gimple_code (stmt) == GIMPLE_ASM)
2724 if (is_gimple_call (stmt) && !gimple_call_internal_p (stmt))
2726 tree fntype = gimple_call_fntype (stmt);
2727 tree attrs = TYPE_ATTRIBUTES (fntype);
2728 for (; attrs; attrs = TREE_CHAIN (attrs))
2730 attrs = lookup_attribute ("nonnull", attrs);
2732 /* If "nonnull" wasn't specified, we know nothing about
2734 if (attrs == NULL_TREE)
2737 /* If "nonnull" applies to all the arguments, then ARG
2738 is non-null if it's in the argument list. */
2739 if (TREE_VALUE (attrs) == NULL_TREE)
2741 for (unsigned int i = 0; i < gimple_call_num_args (stmt); i++)
2743 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt, i)))
2744 && operand_equal_p (op, gimple_call_arg (stmt, i), 0))
2750 /* Now see if op appears in the nonnull list. */
2751 for (tree t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t))
2753 unsigned int idx = TREE_INT_CST_LOW (TREE_VALUE (t)) - 1;
2754 if (idx < gimple_call_num_args (stmt))
2756 tree arg = gimple_call_arg (stmt, idx);
2757 if (operand_equal_p (op, arg, 0))
2764 /* If this function is marked as returning non-null, then we can
2765 infer OP is non-null if it is used in the return statement. */
2766 if (greturn *return_stmt = dyn_cast <greturn *> (stmt))
2767 if (gimple_return_retval (return_stmt)
2768 && operand_equal_p (gimple_return_retval (return_stmt), op, 0)
2769 && lookup_attribute ("returns_nonnull",
2770 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
2776 /* Compare two case labels. Because the front end should already have
2777 made sure that case ranges do not overlap, it is enough to only compare
2778 the CASE_LOW values of each case label. */
2781 compare_case_labels (const void *p1, const void *p2)
2783 const_tree const case1 = *(const_tree const*)p1;
2784 const_tree const case2 = *(const_tree const*)p2;
2786 /* The 'default' case label always goes first. */
2787 if (!CASE_LOW (case1))
2789 else if (!CASE_LOW (case2))
2792 return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
2795 /* Sort the case labels in LABEL_VEC in place in ascending order. */
2798 sort_case_labels (vec<tree> label_vec)
2800 label_vec.qsort (compare_case_labels);
2803 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2805 LABELS is a vector that contains all case labels to look at.
2807 INDEX_TYPE is the type of the switch index expression. Case labels
2808 in LABELS are discarded if their values are not in the value range
2809 covered by INDEX_TYPE. The remaining case label values are folded
2812 If a default case exists in LABELS, it is removed from LABELS and
2813 returned in DEFAULT_CASEP. If no default case exists, but the
2814 case labels already cover the whole range of INDEX_TYPE, a default
2815 case is returned pointing to one of the existing case labels.
2816 Otherwise DEFAULT_CASEP is set to NULL_TREE.
2818 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2819 apply and no action is taken regardless of whether a default case is
2823 preprocess_case_label_vec_for_gimple (vec<tree> labels,
2825 tree *default_casep)
2827 tree min_value, max_value;
2828 tree default_case = NULL_TREE;
2832 min_value = TYPE_MIN_VALUE (index_type);
2833 max_value = TYPE_MAX_VALUE (index_type);
2834 while (i < labels.length ())
2836 tree elt = labels[i];
2837 tree low = CASE_LOW (elt);
2838 tree high = CASE_HIGH (elt);
2839 bool remove_element = FALSE;
2843 gcc_checking_assert (TREE_CODE (low) == INTEGER_CST);
2844 gcc_checking_assert (!high || TREE_CODE (high) == INTEGER_CST);
2846 /* This is a non-default case label, i.e. it has a value.
2848 See if the case label is reachable within the range of
2849 the index type. Remove out-of-range case values. Turn
2850 case ranges into a canonical form (high > low strictly)
2851 and convert the case label values to the index type.
2853 NB: The type of gimple_switch_index() may be the promoted
2854 type, but the case labels retain the original type. */
2858 /* This is a case range. Discard empty ranges.
2859 If the bounds or the range are equal, turn this
2860 into a simple (one-value) case. */
2861 int cmp = tree_int_cst_compare (high, low);
2863 remove_element = TRUE;
2870 /* If the simple case value is unreachable, ignore it. */
2871 if ((TREE_CODE (min_value) == INTEGER_CST
2872 && tree_int_cst_compare (low, min_value) < 0)
2873 || (TREE_CODE (max_value) == INTEGER_CST
2874 && tree_int_cst_compare (low, max_value) > 0))
2875 remove_element = TRUE;
2877 low = fold_convert (index_type, low);
2881 /* If the entire case range is unreachable, ignore it. */
2882 if ((TREE_CODE (min_value) == INTEGER_CST
2883 && tree_int_cst_compare (high, min_value) < 0)
2884 || (TREE_CODE (max_value) == INTEGER_CST
2885 && tree_int_cst_compare (low, max_value) > 0))
2886 remove_element = TRUE;
2889 /* If the lower bound is less than the index type's
2890 minimum value, truncate the range bounds. */
2891 if (TREE_CODE (min_value) == INTEGER_CST
2892 && tree_int_cst_compare (low, min_value) < 0)
2894 low = fold_convert (index_type, low);
2896 /* If the upper bound is greater than the index type's
2897 maximum value, truncate the range bounds. */
2898 if (TREE_CODE (max_value) == INTEGER_CST
2899 && tree_int_cst_compare (high, max_value) > 0)
2901 high = fold_convert (index_type, high);
2903 /* We may have folded a case range to a one-value case. */
2904 if (tree_int_cst_equal (low, high))
2909 CASE_LOW (elt) = low;
2910 CASE_HIGH (elt) = high;
2914 gcc_assert (!default_case);
2916 /* The default case must be passed separately to the
2917 gimple_build_switch routine. But if DEFAULT_CASEP
2918 is NULL, we do not remove the default case (it would
2919 be completely lost). */
2921 remove_element = TRUE;
2925 labels.ordered_remove (i);
2931 if (!labels.is_empty ())
2932 sort_case_labels (labels);
2934 if (default_casep && !default_case)
2936 /* If the switch has no default label, add one, so that we jump
2937 around the switch body. If the labels already cover the whole
2938 range of the switch index_type, add the default label pointing
2939 to one of the existing labels. */
2941 && TYPE_MIN_VALUE (index_type)
2942 && TYPE_MAX_VALUE (index_type)
2943 && tree_int_cst_equal (CASE_LOW (labels[0]),
2944 TYPE_MIN_VALUE (index_type)))
2946 tree low, high = CASE_HIGH (labels[len - 1]);
2948 high = CASE_LOW (labels[len - 1]);
2949 if (tree_int_cst_equal (high, TYPE_MAX_VALUE (index_type)))
2951 for (i = 1; i < len; i++)
2953 high = CASE_LOW (labels[i]);
2954 low = CASE_HIGH (labels[i - 1]);
2956 low = CASE_LOW (labels[i - 1]);
2957 if (wi::add (low, 1) != high)
2962 tree label = CASE_LABEL (labels[0]);
2963 default_case = build_case_label (NULL_TREE, NULL_TREE,
2971 *default_casep = default_case;
2974 /* Set the location of all statements in SEQ to LOC. */
2977 gimple_seq_set_location (gimple_seq seq, location_t loc)
2979 for (gimple_stmt_iterator i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
2980 gimple_set_location (gsi_stmt (i), loc);
2983 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
2986 gimple_seq_discard (gimple_seq seq)
2988 gimple_stmt_iterator gsi;
2990 for (gsi = gsi_start (seq); !gsi_end_p (gsi); )
2992 gimple *stmt = gsi_stmt (gsi);
2993 gsi_remove (&gsi, true);
2994 release_defs (stmt);
2999 /* See if STMT now calls function that takes no parameters and if so, drop
3000 call arguments. This is used when devirtualization machinery redirects
3001 to __builtiln_unreacahble or __cxa_pure_virutal. */
3004 maybe_remove_unused_call_args (struct function *fn, gimple *stmt)
3006 tree decl = gimple_call_fndecl (stmt);
3007 if (TYPE_ARG_TYPES (TREE_TYPE (decl))
3008 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))) == void_type_node
3009 && gimple_call_num_args (stmt))
3011 gimple_set_num_ops (stmt, 3);
3012 update_stmt_fn (fn, stmt);
3016 /* Return false if STMT will likely expand to real function call. */
3019 gimple_inexpensive_call_p (gimple *stmt)
3021 if (gimple_call_internal_p (stmt))
3023 tree decl = gimple_call_fndecl (stmt);
3024 if (decl && is_inexpensive_builtin (decl))