1 /* Gimple IR support functions.
3 Copyright (C) 2007-2015 Free Software Foundation, Inc.
4 Contributed by Aldy Hernandez <aldyh@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
30 #include "fold-const.h"
33 #include "stor-layout.h"
34 #include "hard-reg-set.h"
37 #include "dominance.h"
39 #include "basic-block.h"
40 #include "tree-ssa-alias.h"
41 #include "internal-fn.h"
43 #include "gimple-expr.h"
45 #include "gimple-iterator.h"
46 #include "gimple-walk.h"
49 #include "diagnostic.h"
50 #include "value-prof.h"
54 #include "langhooks.h"
56 #include "stringpool.h"
57 #include "tree-ssanames.h"
58 #include "lto-streamer.h"
60 #include "gimple-ssa.h"
63 /* All the tuples have their operand vector (if present) at the very bottom
64 of the structure. Therefore, the offset required to find the
65 operands vector the size of the structure minus the size of the 1
66 element tree array at the end (see gimple_ops). */
67 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
68 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
69 EXPORTED_CONST size_t gimple_ops_offset_[] = {
70 #include "gsstruct.def"
74 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
75 static const size_t gsstruct_code_size[] = {
76 #include "gsstruct.def"
80 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
81 const char *const gimple_code_name[] = {
86 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
87 EXPORTED_CONST enum gimple_statement_structure_enum gss_for_code_[] = {
94 int gimple_alloc_counts[(int) gimple_alloc_kind_all];
95 int gimple_alloc_sizes[(int) gimple_alloc_kind_all];
97 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
98 static const char * const gimple_alloc_kind_names[] = {
105 /* Gimple tuple constructors.
106 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
107 be passed a NULL to start with an empty sequence. */
109 /* Set the code for statement G to CODE. */
112 gimple_set_code (gimple g, enum gimple_code code)
117 /* Return the number of bytes needed to hold a GIMPLE statement with
121 gimple_size (enum gimple_code code)
123 return gsstruct_code_size[gss_for_code (code)];
126 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
130 gimple_alloc_stat (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
135 size = gimple_size (code);
137 size += sizeof (tree) * (num_ops - 1);
139 if (GATHER_STATISTICS)
141 enum gimple_alloc_kind kind = gimple_alloc_kind (code);
142 gimple_alloc_counts[(int) kind]++;
143 gimple_alloc_sizes[(int) kind] += size;
146 stmt = ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT);
147 gimple_set_code (stmt, code);
148 gimple_set_num_ops (stmt, num_ops);
150 /* Do not call gimple_set_modified here as it has other side
151 effects and this tuple is still not completely built. */
153 gimple_init_singleton (stmt);
158 /* Set SUBCODE to be the code of the expression computed by statement G. */
161 gimple_set_subcode (gimple g, unsigned subcode)
163 /* We only have 16 bits for the RHS code. Assert that we are not
165 gcc_assert (subcode < (1 << 16));
166 g->subcode = subcode;
171 /* Build a tuple with operands. CODE is the statement to build (which
172 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
173 for the new tuple. NUM_OPS is the number of operands to allocate. */
175 #define gimple_build_with_ops(c, s, n) \
176 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
179 gimple_build_with_ops_stat (enum gimple_code code, unsigned subcode,
180 unsigned num_ops MEM_STAT_DECL)
182 gimple s = gimple_alloc_stat (code, num_ops PASS_MEM_STAT);
183 gimple_set_subcode (s, subcode);
189 /* Build a GIMPLE_RETURN statement returning RETVAL. */
192 gimple_build_return (tree retval)
195 = as_a <greturn *> (gimple_build_with_ops (GIMPLE_RETURN, ERROR_MARK,
198 gimple_return_set_retval (s, retval);
202 /* Reset alias information on call S. */
205 gimple_call_reset_alias_info (gcall *s)
207 if (gimple_call_flags (s) & ECF_CONST)
208 memset (gimple_call_use_set (s), 0, sizeof (struct pt_solution));
210 pt_solution_reset (gimple_call_use_set (s));
211 if (gimple_call_flags (s) & (ECF_CONST|ECF_PURE|ECF_NOVOPS))
212 memset (gimple_call_clobber_set (s), 0, sizeof (struct pt_solution));
214 pt_solution_reset (gimple_call_clobber_set (s));
217 /* Helper for gimple_build_call, gimple_build_call_valist,
218 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
219 components of a GIMPLE_CALL statement to function FN with NARGS
222 static inline gcall *
223 gimple_build_call_1 (tree fn, unsigned nargs)
226 = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
228 if (TREE_CODE (fn) == FUNCTION_DECL)
229 fn = build_fold_addr_expr (fn);
230 gimple_set_op (s, 1, fn);
231 gimple_call_set_fntype (s, TREE_TYPE (TREE_TYPE (fn)));
232 gimple_call_reset_alias_info (s);
237 /* Build a GIMPLE_CALL statement to function FN with the arguments
238 specified in vector ARGS. */
241 gimple_build_call_vec (tree fn, vec<tree> args)
244 unsigned nargs = args.length ();
245 gcall *call = gimple_build_call_1 (fn, nargs);
247 for (i = 0; i < nargs; i++)
248 gimple_call_set_arg (call, i, args[i]);
254 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
255 arguments. The ... are the arguments. */
258 gimple_build_call (tree fn, unsigned nargs, ...)
264 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
266 call = gimple_build_call_1 (fn, nargs);
268 va_start (ap, nargs);
269 for (i = 0; i < nargs; i++)
270 gimple_call_set_arg (call, i, va_arg (ap, tree));
277 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
278 arguments. AP contains the arguments. */
281 gimple_build_call_valist (tree fn, unsigned nargs, va_list ap)
286 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
288 call = gimple_build_call_1 (fn, nargs);
290 for (i = 0; i < nargs; i++)
291 gimple_call_set_arg (call, i, va_arg (ap, tree));
297 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
298 Build the basic components of a GIMPLE_CALL statement to internal
299 function FN with NARGS arguments. */
301 static inline gcall *
302 gimple_build_call_internal_1 (enum internal_fn fn, unsigned nargs)
305 = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
307 s->subcode |= GF_CALL_INTERNAL;
308 gimple_call_set_internal_fn (s, fn);
309 gimple_call_reset_alias_info (s);
314 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
315 the number of arguments. The ... are the arguments. */
318 gimple_build_call_internal (enum internal_fn fn, unsigned nargs, ...)
324 call = gimple_build_call_internal_1 (fn, nargs);
325 va_start (ap, nargs);
326 for (i = 0; i < nargs; i++)
327 gimple_call_set_arg (call, i, va_arg (ap, tree));
334 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
335 specified in vector ARGS. */
338 gimple_build_call_internal_vec (enum internal_fn fn, vec<tree> args)
343 nargs = args.length ();
344 call = gimple_build_call_internal_1 (fn, nargs);
345 for (i = 0; i < nargs; i++)
346 gimple_call_set_arg (call, i, args[i]);
352 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
353 assumed to be in GIMPLE form already. Minimal checking is done of
357 gimple_build_call_from_tree (tree t)
361 tree fndecl = get_callee_fndecl (t);
363 gcc_assert (TREE_CODE (t) == CALL_EXPR);
365 nargs = call_expr_nargs (t);
366 call = gimple_build_call_1 (fndecl ? fndecl : CALL_EXPR_FN (t), nargs);
368 for (i = 0; i < nargs; i++)
369 gimple_call_set_arg (call, i, CALL_EXPR_ARG (t, i));
371 gimple_set_block (call, TREE_BLOCK (t));
373 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
374 gimple_call_set_chain (call, CALL_EXPR_STATIC_CHAIN (t));
375 gimple_call_set_tail (call, CALL_EXPR_TAILCALL (t));
376 gimple_call_set_return_slot_opt (call, CALL_EXPR_RETURN_SLOT_OPT (t));
378 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
379 && (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_ALLOCA
380 || DECL_FUNCTION_CODE (fndecl) == BUILT_IN_ALLOCA_WITH_ALIGN))
381 gimple_call_set_alloca_for_var (call, CALL_ALLOCA_FOR_VAR_P (t));
383 gimple_call_set_from_thunk (call, CALL_FROM_THUNK_P (t));
384 gimple_call_set_va_arg_pack (call, CALL_EXPR_VA_ARG_PACK (t));
385 gimple_call_set_nothrow (call, TREE_NOTHROW (t));
386 gimple_set_no_warning (call, TREE_NO_WARNING (t));
387 gimple_call_set_with_bounds (call, CALL_WITH_BOUNDS_P (t));
393 /* Build a GIMPLE_ASSIGN statement.
395 LHS of the assignment.
396 RHS of the assignment which can be unary or binary. */
399 gimple_build_assign (tree lhs, tree rhs MEM_STAT_DECL)
401 enum tree_code subcode;
404 extract_ops_from_tree_1 (rhs, &subcode, &op1, &op2, &op3);
405 return gimple_build_assign (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
409 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
412 static inline gassign *
413 gimple_build_assign_1 (tree lhs, enum tree_code subcode, tree op1,
414 tree op2, tree op3 MEM_STAT_DECL)
419 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
421 num_ops = get_gimple_rhs_num_ops (subcode) + 1;
423 p = as_a <gassign *> (
424 gimple_build_with_ops_stat (GIMPLE_ASSIGN, (unsigned)subcode, num_ops
426 gimple_assign_set_lhs (p, lhs);
427 gimple_assign_set_rhs1 (p, op1);
430 gcc_assert (num_ops > 2);
431 gimple_assign_set_rhs2 (p, op2);
436 gcc_assert (num_ops > 3);
437 gimple_assign_set_rhs3 (p, op3);
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, tree op3 MEM_STAT_DECL)
450 return gimple_build_assign_1 (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
453 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
457 gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
458 tree op2 MEM_STAT_DECL)
460 return gimple_build_assign_1 (lhs, subcode, op1, op2, NULL_TREE
464 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
467 gimple_build_assign (tree lhs, enum tree_code subcode, tree op1 MEM_STAT_DECL)
469 return gimple_build_assign_1 (lhs, subcode, op1, NULL_TREE, NULL_TREE
474 /* Build a GIMPLE_COND statement.
476 PRED is the condition used to compare LHS and the RHS.
477 T_LABEL is the label to jump to if the condition is true.
478 F_LABEL is the label to jump to otherwise. */
481 gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs,
482 tree t_label, tree f_label)
486 gcc_assert (TREE_CODE_CLASS (pred_code) == tcc_comparison);
487 p = as_a <gcond *> (gimple_build_with_ops (GIMPLE_COND, pred_code, 4));
488 gimple_cond_set_lhs (p, lhs);
489 gimple_cond_set_rhs (p, rhs);
490 gimple_cond_set_true_label (p, t_label);
491 gimple_cond_set_false_label (p, f_label);
495 /* Build a GIMPLE_COND statement from the conditional expression tree
496 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
499 gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
504 gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
505 return gimple_build_cond (code, lhs, rhs, t_label, f_label);
508 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
509 boolean expression tree COND. */
512 gimple_cond_set_condition_from_tree (gcond *stmt, tree cond)
517 gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
518 gimple_cond_set_condition (stmt, code, lhs, rhs);
521 /* Build a GIMPLE_LABEL statement for LABEL. */
524 gimple_build_label (tree label)
527 = as_a <glabel *> (gimple_build_with_ops (GIMPLE_LABEL, ERROR_MARK, 1));
528 gimple_label_set_label (p, label);
532 /* Build a GIMPLE_GOTO statement to label DEST. */
535 gimple_build_goto (tree dest)
538 = as_a <ggoto *> (gimple_build_with_ops (GIMPLE_GOTO, ERROR_MARK, 1));
539 gimple_goto_set_dest (p, dest);
544 /* Build a GIMPLE_NOP statement. */
547 gimple_build_nop (void)
549 return gimple_alloc (GIMPLE_NOP, 0);
553 /* Build a GIMPLE_BIND statement.
554 VARS are the variables in BODY.
555 BLOCK is the containing block. */
558 gimple_build_bind (tree vars, gimple_seq body, tree block)
560 gbind *p = as_a <gbind *> (gimple_alloc (GIMPLE_BIND, 0));
561 gimple_bind_set_vars (p, vars);
563 gimple_bind_set_body (p, body);
565 gimple_bind_set_block (p, block);
569 /* Helper function to set the simple fields of a asm stmt.
571 STRING is a pointer to a string that is the asm blocks assembly code.
572 NINPUT is the number of register inputs.
573 NOUTPUT is the number of register outputs.
574 NCLOBBERS is the number of clobbered registers.
578 gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
579 unsigned nclobbers, unsigned nlabels)
582 int size = strlen (string);
584 /* ASMs with labels cannot have outputs. This should have been
585 enforced by the front end. */
586 gcc_assert (nlabels == 0 || noutputs == 0);
589 gimple_build_with_ops (GIMPLE_ASM, ERROR_MARK,
590 ninputs + noutputs + nclobbers + nlabels));
596 p->string = ggc_alloc_string (string, size);
598 if (GATHER_STATISTICS)
599 gimple_alloc_sizes[(int) gimple_alloc_kind (GIMPLE_ASM)] += size;
604 /* Build a GIMPLE_ASM statement.
606 STRING is the assembly code.
607 NINPUT is the number of register inputs.
608 NOUTPUT is the number of register outputs.
609 NCLOBBERS is the number of clobbered registers.
610 INPUTS is a vector of the input register parameters.
611 OUTPUTS is a vector of the output register parameters.
612 CLOBBERS is a vector of the clobbered register parameters.
613 LABELS is a vector of destination labels. */
616 gimple_build_asm_vec (const char *string, vec<tree, va_gc> *inputs,
617 vec<tree, va_gc> *outputs, vec<tree, va_gc> *clobbers,
618 vec<tree, va_gc> *labels)
623 p = gimple_build_asm_1 (string,
624 vec_safe_length (inputs),
625 vec_safe_length (outputs),
626 vec_safe_length (clobbers),
627 vec_safe_length (labels));
629 for (i = 0; i < vec_safe_length (inputs); i++)
630 gimple_asm_set_input_op (p, i, (*inputs)[i]);
632 for (i = 0; i < vec_safe_length (outputs); i++)
633 gimple_asm_set_output_op (p, i, (*outputs)[i]);
635 for (i = 0; i < vec_safe_length (clobbers); i++)
636 gimple_asm_set_clobber_op (p, i, (*clobbers)[i]);
638 for (i = 0; i < vec_safe_length (labels); i++)
639 gimple_asm_set_label_op (p, i, (*labels)[i]);
644 /* Build a GIMPLE_CATCH statement.
646 TYPES are the catch types.
647 HANDLER is the exception handler. */
650 gimple_build_catch (tree types, gimple_seq handler)
652 gcatch *p = as_a <gcatch *> (gimple_alloc (GIMPLE_CATCH, 0));
653 gimple_catch_set_types (p, types);
655 gimple_catch_set_handler (p, handler);
660 /* Build a GIMPLE_EH_FILTER statement.
662 TYPES are the filter's types.
663 FAILURE is the filter's failure action. */
666 gimple_build_eh_filter (tree types, gimple_seq failure)
668 geh_filter *p = as_a <geh_filter *> (gimple_alloc (GIMPLE_EH_FILTER, 0));
669 gimple_eh_filter_set_types (p, types);
671 gimple_eh_filter_set_failure (p, failure);
676 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
679 gimple_build_eh_must_not_throw (tree decl)
681 geh_mnt *p = as_a <geh_mnt *> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW, 0));
683 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
684 gcc_assert (flags_from_decl_or_type (decl) & ECF_NORETURN);
685 gimple_eh_must_not_throw_set_fndecl (p, decl);
690 /* Build a GIMPLE_EH_ELSE statement. */
693 gimple_build_eh_else (gimple_seq n_body, gimple_seq e_body)
695 geh_else *p = as_a <geh_else *> (gimple_alloc (GIMPLE_EH_ELSE, 0));
696 gimple_eh_else_set_n_body (p, n_body);
697 gimple_eh_else_set_e_body (p, e_body);
701 /* Build a GIMPLE_TRY statement.
703 EVAL is the expression to evaluate.
704 CLEANUP is the cleanup expression.
705 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
706 whether this is a try/catch or a try/finally respectively. */
709 gimple_build_try (gimple_seq eval, gimple_seq cleanup,
710 enum gimple_try_flags kind)
714 gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
715 p = as_a <gtry *> (gimple_alloc (GIMPLE_TRY, 0));
716 gimple_set_subcode (p, kind);
718 gimple_try_set_eval (p, eval);
720 gimple_try_set_cleanup (p, cleanup);
725 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
727 CLEANUP is the cleanup expression. */
730 gimple_build_wce (gimple_seq cleanup)
732 gimple p = gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR, 0);
734 gimple_wce_set_cleanup (p, cleanup);
740 /* Build a GIMPLE_RESX statement. */
743 gimple_build_resx (int region)
746 = as_a <gresx *> (gimple_build_with_ops (GIMPLE_RESX, ERROR_MARK, 0));
752 /* The helper for constructing a gimple switch statement.
753 INDEX is the switch's index.
754 NLABELS is the number of labels in the switch excluding the default.
755 DEFAULT_LABEL is the default label for the switch statement. */
758 gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
760 /* nlabels + 1 default label + 1 index. */
761 gcc_checking_assert (default_label);
762 gswitch *p = as_a <gswitch *> (gimple_build_with_ops (GIMPLE_SWITCH,
765 gimple_switch_set_index (p, index);
766 gimple_switch_set_default_label (p, default_label);
770 /* Build a GIMPLE_SWITCH statement.
772 INDEX is the switch's index.
773 DEFAULT_LABEL is the default label
774 ARGS is a vector of labels excluding the default. */
777 gimple_build_switch (tree index, tree default_label, vec<tree> args)
779 unsigned i, nlabels = args.length ();
781 gswitch *p = gimple_build_switch_nlabels (nlabels, index, default_label);
783 /* Copy the labels from the vector to the switch statement. */
784 for (i = 0; i < nlabels; i++)
785 gimple_switch_set_label (p, i + 1, args[i]);
790 /* Build a GIMPLE_EH_DISPATCH statement. */
793 gimple_build_eh_dispatch (int region)
796 = as_a <geh_dispatch *> (
797 gimple_build_with_ops (GIMPLE_EH_DISPATCH, ERROR_MARK, 0));
802 /* Build a new GIMPLE_DEBUG_BIND statement.
804 VAR is bound to VALUE; block and location are taken from STMT. */
807 gimple_build_debug_bind_stat (tree var, tree value, gimple stmt MEM_STAT_DECL)
810 = as_a <gdebug *> (gimple_build_with_ops_stat (GIMPLE_DEBUG,
811 (unsigned)GIMPLE_DEBUG_BIND, 2
813 gimple_debug_bind_set_var (p, var);
814 gimple_debug_bind_set_value (p, value);
816 gimple_set_location (p, gimple_location (stmt));
822 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
824 VAR is bound to VALUE; block and location are taken from STMT. */
827 gimple_build_debug_source_bind_stat (tree var, tree value,
828 gimple stmt MEM_STAT_DECL)
832 gimple_build_with_ops_stat (GIMPLE_DEBUG,
833 (unsigned)GIMPLE_DEBUG_SOURCE_BIND, 2
836 gimple_debug_source_bind_set_var (p, var);
837 gimple_debug_source_bind_set_value (p, value);
839 gimple_set_location (p, gimple_location (stmt));
845 /* Build a GIMPLE_OMP_CRITICAL statement.
847 BODY is the sequence of statements for which only one thread can execute.
848 NAME is optional identifier for this critical block. */
851 gimple_build_omp_critical (gimple_seq body, tree name)
854 = as_a <gomp_critical *> (gimple_alloc (GIMPLE_OMP_CRITICAL, 0));
855 gimple_omp_critical_set_name (p, name);
857 gimple_omp_set_body (p, body);
862 /* Build a GIMPLE_OMP_FOR statement.
864 BODY is sequence of statements inside the for loop.
865 KIND is the `for' variant.
866 CLAUSES, are any of the construct's clauses.
867 COLLAPSE is the collapse count.
868 PRE_BODY is the sequence of statements that are loop invariant. */
871 gimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse,
874 gomp_for *p = as_a <gomp_for *> (gimple_alloc (GIMPLE_OMP_FOR, 0));
876 gimple_omp_set_body (p, body);
877 gimple_omp_for_set_clauses (p, clauses);
878 gimple_omp_for_set_kind (p, kind);
879 p->collapse = collapse;
880 p->iter = ggc_cleared_vec_alloc<gimple_omp_for_iter> (collapse);
883 gimple_omp_for_set_pre_body (p, pre_body);
889 /* Build a GIMPLE_OMP_PARALLEL statement.
891 BODY is sequence of statements which are executed in parallel.
892 CLAUSES, are the OMP parallel construct's clauses.
893 CHILD_FN is the function created for the parallel threads to execute.
894 DATA_ARG are the shared data argument(s). */
897 gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
901 = as_a <gomp_parallel *> (gimple_alloc (GIMPLE_OMP_PARALLEL, 0));
903 gimple_omp_set_body (p, body);
904 gimple_omp_parallel_set_clauses (p, clauses);
905 gimple_omp_parallel_set_child_fn (p, child_fn);
906 gimple_omp_parallel_set_data_arg (p, data_arg);
912 /* Build a GIMPLE_OMP_TASK statement.
914 BODY is sequence of statements which are executed by the explicit task.
915 CLAUSES, are the OMP parallel construct's clauses.
916 CHILD_FN is the function created for the parallel threads to execute.
917 DATA_ARG are the shared data argument(s).
918 COPY_FN is the optional function for firstprivate initialization.
919 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
922 gimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn,
923 tree data_arg, tree copy_fn, tree arg_size,
926 gomp_task *p = as_a <gomp_task *> (gimple_alloc (GIMPLE_OMP_TASK, 0));
928 gimple_omp_set_body (p, body);
929 gimple_omp_task_set_clauses (p, clauses);
930 gimple_omp_task_set_child_fn (p, child_fn);
931 gimple_omp_task_set_data_arg (p, data_arg);
932 gimple_omp_task_set_copy_fn (p, copy_fn);
933 gimple_omp_task_set_arg_size (p, arg_size);
934 gimple_omp_task_set_arg_align (p, arg_align);
940 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
942 BODY is the sequence of statements in the section. */
945 gimple_build_omp_section (gimple_seq body)
947 gimple p = gimple_alloc (GIMPLE_OMP_SECTION, 0);
949 gimple_omp_set_body (p, body);
955 /* Build a GIMPLE_OMP_MASTER statement.
957 BODY is the sequence of statements to be executed by just the master. */
960 gimple_build_omp_master (gimple_seq body)
962 gimple p = gimple_alloc (GIMPLE_OMP_MASTER, 0);
964 gimple_omp_set_body (p, body);
970 /* Build a GIMPLE_OMP_TASKGROUP statement.
972 BODY is the sequence of statements to be executed by the taskgroup
976 gimple_build_omp_taskgroup (gimple_seq body)
978 gimple p = gimple_alloc (GIMPLE_OMP_TASKGROUP, 0);
980 gimple_omp_set_body (p, body);
986 /* Build a GIMPLE_OMP_CONTINUE statement.
988 CONTROL_DEF is the definition of the control variable.
989 CONTROL_USE is the use of the control variable. */
992 gimple_build_omp_continue (tree control_def, tree control_use)
995 = as_a <gomp_continue *> (gimple_alloc (GIMPLE_OMP_CONTINUE, 0));
996 gimple_omp_continue_set_control_def (p, control_def);
997 gimple_omp_continue_set_control_use (p, control_use);
1001 /* Build a GIMPLE_OMP_ORDERED statement.
1003 BODY is the sequence of statements inside a loop that will executed in
1007 gimple_build_omp_ordered (gimple_seq body)
1009 gimple p = gimple_alloc (GIMPLE_OMP_ORDERED, 0);
1011 gimple_omp_set_body (p, body);
1017 /* Build a GIMPLE_OMP_RETURN statement.
1018 WAIT_P is true if this is a non-waiting return. */
1021 gimple_build_omp_return (bool wait_p)
1023 gimple p = gimple_alloc (GIMPLE_OMP_RETURN, 0);
1025 gimple_omp_return_set_nowait (p);
1031 /* Build a GIMPLE_OMP_SECTIONS statement.
1033 BODY is a sequence of section statements.
1034 CLAUSES are any of the OMP sections contsruct's clauses: private,
1035 firstprivate, lastprivate, reduction, and nowait. */
1038 gimple_build_omp_sections (gimple_seq body, tree clauses)
1041 = as_a <gomp_sections *> (gimple_alloc (GIMPLE_OMP_SECTIONS, 0));
1043 gimple_omp_set_body (p, body);
1044 gimple_omp_sections_set_clauses (p, clauses);
1050 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1053 gimple_build_omp_sections_switch (void)
1055 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH, 0);
1059 /* Build a GIMPLE_OMP_SINGLE statement.
1061 BODY is the sequence of statements that will be executed once.
1062 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1063 copyprivate, nowait. */
1066 gimple_build_omp_single (gimple_seq body, tree clauses)
1069 = as_a <gomp_single *> (gimple_alloc (GIMPLE_OMP_SINGLE, 0));
1071 gimple_omp_set_body (p, body);
1072 gimple_omp_single_set_clauses (p, clauses);
1078 /* Build a GIMPLE_OMP_TARGET statement.
1080 BODY is the sequence of statements that will be executed.
1081 KIND is the kind of the region.
1082 CLAUSES are any of the construct's clauses. */
1085 gimple_build_omp_target (gimple_seq body, int kind, tree clauses)
1088 = as_a <gomp_target *> (gimple_alloc (GIMPLE_OMP_TARGET, 0));
1090 gimple_omp_set_body (p, body);
1091 gimple_omp_target_set_clauses (p, clauses);
1092 gimple_omp_target_set_kind (p, kind);
1098 /* Build a GIMPLE_OMP_TEAMS statement.
1100 BODY is the sequence of statements that will be executed.
1101 CLAUSES are any of the OMP teams construct's clauses. */
1104 gimple_build_omp_teams (gimple_seq body, tree clauses)
1106 gomp_teams *p = as_a <gomp_teams *> (gimple_alloc (GIMPLE_OMP_TEAMS, 0));
1108 gimple_omp_set_body (p, body);
1109 gimple_omp_teams_set_clauses (p, clauses);
1115 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1118 gimple_build_omp_atomic_load (tree lhs, tree rhs)
1121 = as_a <gomp_atomic_load *> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0));
1122 gimple_omp_atomic_load_set_lhs (p, lhs);
1123 gimple_omp_atomic_load_set_rhs (p, rhs);
1127 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1129 VAL is the value we are storing. */
1132 gimple_build_omp_atomic_store (tree val)
1134 gomp_atomic_store *p
1135 = as_a <gomp_atomic_store *> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE, 0));
1136 gimple_omp_atomic_store_set_val (p, val);
1140 /* Build a GIMPLE_TRANSACTION statement. */
1143 gimple_build_transaction (gimple_seq body, tree label)
1146 = as_a <gtransaction *> (gimple_alloc (GIMPLE_TRANSACTION, 0));
1147 gimple_transaction_set_body (p, body);
1148 gimple_transaction_set_label (p, label);
1152 /* Build a GIMPLE_PREDICT statement. PREDICT is one of the predictors from
1153 predict.def, OUTCOME is NOT_TAKEN or TAKEN. */
1156 gimple_build_predict (enum br_predictor predictor, enum prediction outcome)
1158 gimple p = gimple_alloc (GIMPLE_PREDICT, 0);
1159 /* Ensure all the predictors fit into the lower bits of the subcode. */
1160 gcc_assert ((int) END_PREDICTORS <= GF_PREDICT_TAKEN);
1161 gimple_predict_set_predictor (p, predictor);
1162 gimple_predict_set_outcome (p, outcome);
1166 #if defined ENABLE_GIMPLE_CHECKING
1167 /* Complain of a gimple type mismatch and die. */
1170 gimple_check_failed (const_gimple gs, const char *file, int line,
1171 const char *function, enum gimple_code code,
1172 enum tree_code subcode)
1174 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1175 gimple_code_name[code],
1176 get_tree_code_name (subcode),
1177 gimple_code_name[gimple_code (gs)],
1179 ? get_tree_code_name ((enum tree_code) gs->subcode)
1181 function, trim_filename (file), line);
1183 #endif /* ENABLE_GIMPLE_CHECKING */
1186 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1187 *SEQ_P is NULL, a new sequence is allocated. */
1190 gimple_seq_add_stmt (gimple_seq *seq_p, gimple gs)
1192 gimple_stmt_iterator si;
1196 si = gsi_last (*seq_p);
1197 gsi_insert_after (&si, gs, GSI_NEW_STMT);
1200 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1201 *SEQ_P is NULL, a new sequence is allocated. This function is
1202 similar to gimple_seq_add_stmt, but does not scan the operands.
1203 During gimplification, we need to manipulate statement sequences
1204 before the def/use vectors have been constructed. */
1207 gimple_seq_add_stmt_without_update (gimple_seq *seq_p, gimple gs)
1209 gimple_stmt_iterator si;
1214 si = gsi_last (*seq_p);
1215 gsi_insert_after_without_update (&si, gs, GSI_NEW_STMT);
1218 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1219 NULL, a new sequence is allocated. */
1222 gimple_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
1224 gimple_stmt_iterator si;
1228 si = gsi_last (*dst_p);
1229 gsi_insert_seq_after (&si, src, GSI_NEW_STMT);
1232 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1233 NULL, a new sequence is allocated. This function is
1234 similar to gimple_seq_add_seq, but does not scan the operands. */
1237 gimple_seq_add_seq_without_update (gimple_seq *dst_p, gimple_seq src)
1239 gimple_stmt_iterator si;
1243 si = gsi_last (*dst_p);
1244 gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
1247 /* Determine whether to assign a location to the statement GS. */
1250 should_carry_location_p (gimple gs)
1252 /* Don't emit a line note for a label. We particularly don't want to
1253 emit one for the break label, since it doesn't actually correspond
1254 to the beginning of the loop/switch. */
1255 if (gimple_code (gs) == GIMPLE_LABEL)
1261 /* Set the location for gimple statement GS to LOCATION. */
1264 annotate_one_with_location (gimple gs, location_t location)
1266 if (!gimple_has_location (gs)
1267 && !gimple_do_not_emit_location_p (gs)
1268 && should_carry_location_p (gs))
1269 gimple_set_location (gs, location);
1272 /* Set LOCATION for all the statements after iterator GSI in sequence
1273 SEQ. If GSI is pointing to the end of the sequence, start with the
1274 first statement in SEQ. */
1277 annotate_all_with_location_after (gimple_seq seq, gimple_stmt_iterator gsi,
1278 location_t location)
1280 if (gsi_end_p (gsi))
1281 gsi = gsi_start (seq);
1285 for (; !gsi_end_p (gsi); gsi_next (&gsi))
1286 annotate_one_with_location (gsi_stmt (gsi), location);
1289 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1292 annotate_all_with_location (gimple_seq stmt_p, location_t location)
1294 gimple_stmt_iterator i;
1296 if (gimple_seq_empty_p (stmt_p))
1299 for (i = gsi_start (stmt_p); !gsi_end_p (i); gsi_next (&i))
1301 gimple gs = gsi_stmt (i);
1302 annotate_one_with_location (gs, location);
1306 /* Helper function of empty_body_p. Return true if STMT is an empty
1310 empty_stmt_p (gimple stmt)
1312 if (gimple_code (stmt) == GIMPLE_NOP)
1314 if (gbind *bind_stmt = dyn_cast <gbind *> (stmt))
1315 return empty_body_p (gimple_bind_body (bind_stmt));
1320 /* Return true if BODY contains nothing but empty statements. */
1323 empty_body_p (gimple_seq body)
1325 gimple_stmt_iterator i;
1327 if (gimple_seq_empty_p (body))
1329 for (i = gsi_start (body); !gsi_end_p (i); gsi_next (&i))
1330 if (!empty_stmt_p (gsi_stmt (i))
1331 && !is_gimple_debug (gsi_stmt (i)))
1338 /* Perform a deep copy of sequence SRC and return the result. */
1341 gimple_seq_copy (gimple_seq src)
1343 gimple_stmt_iterator gsi;
1344 gimple_seq new_seq = NULL;
1347 for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi))
1349 stmt = gimple_copy (gsi_stmt (gsi));
1350 gimple_seq_add_stmt (&new_seq, stmt);
1358 /* Return true if calls C1 and C2 are known to go to the same function. */
1361 gimple_call_same_target_p (const_gimple c1, const_gimple c2)
1363 if (gimple_call_internal_p (c1))
1364 return (gimple_call_internal_p (c2)
1365 && gimple_call_internal_fn (c1) == gimple_call_internal_fn (c2));
1367 return (gimple_call_fn (c1) == gimple_call_fn (c2)
1368 || (gimple_call_fndecl (c1)
1369 && gimple_call_fndecl (c1) == gimple_call_fndecl (c2)));
1372 /* Detect flags from a GIMPLE_CALL. This is just like
1373 call_expr_flags, but for gimple tuples. */
1376 gimple_call_flags (const_gimple stmt)
1379 tree decl = gimple_call_fndecl (stmt);
1382 flags = flags_from_decl_or_type (decl);
1383 else if (gimple_call_internal_p (stmt))
1384 flags = internal_fn_flags (gimple_call_internal_fn (stmt));
1386 flags = flags_from_decl_or_type (gimple_call_fntype (stmt));
1388 if (stmt->subcode & GF_CALL_NOTHROW)
1389 flags |= ECF_NOTHROW;
1394 /* Return the "fn spec" string for call STMT. */
1397 gimple_call_fnspec (const gcall *stmt)
1401 if (gimple_call_internal_p (stmt))
1402 return internal_fn_fnspec (gimple_call_internal_fn (stmt));
1404 type = gimple_call_fntype (stmt);
1408 attr = lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type));
1412 return TREE_VALUE (TREE_VALUE (attr));
1415 /* Detects argument flags for argument number ARG on call STMT. */
1418 gimple_call_arg_flags (const gcall *stmt, unsigned arg)
1420 const_tree attr = gimple_call_fnspec (stmt);
1422 if (!attr || 1 + arg >= (unsigned) TREE_STRING_LENGTH (attr))
1425 switch (TREE_STRING_POINTER (attr)[1 + arg])
1432 return EAF_DIRECT | EAF_NOCLOBBER | EAF_NOESCAPE;
1435 return EAF_NOCLOBBER | EAF_NOESCAPE;
1438 return EAF_DIRECT | EAF_NOESCAPE;
1441 return EAF_NOESCAPE;
1449 /* Detects return flags for the call STMT. */
1452 gimple_call_return_flags (const gcall *stmt)
1456 if (gimple_call_flags (stmt) & ECF_MALLOC)
1459 attr = gimple_call_fnspec (stmt);
1460 if (!attr || TREE_STRING_LENGTH (attr) < 1)
1463 switch (TREE_STRING_POINTER (attr)[0])
1469 return ERF_RETURNS_ARG | (TREE_STRING_POINTER (attr)[0] - '1');
1481 /* Return true if GS is a copy assignment. */
1484 gimple_assign_copy_p (gimple gs)
1486 return (gimple_assign_single_p (gs)
1487 && is_gimple_val (gimple_op (gs, 1)));
1491 /* Return true if GS is a SSA_NAME copy assignment. */
1494 gimple_assign_ssa_name_copy_p (gimple gs)
1496 return (gimple_assign_single_p (gs)
1497 && TREE_CODE (gimple_assign_lhs (gs)) == SSA_NAME
1498 && TREE_CODE (gimple_assign_rhs1 (gs)) == SSA_NAME);
1502 /* Return true if GS is an assignment with a unary RHS, but the
1503 operator has no effect on the assigned value. The logic is adapted
1504 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1505 instances in which STRIP_NOPS was previously applied to the RHS of
1508 NOTE: In the use cases that led to the creation of this function
1509 and of gimple_assign_single_p, it is typical to test for either
1510 condition and to proceed in the same manner. In each case, the
1511 assigned value is represented by the single RHS operand of the
1512 assignment. I suspect there may be cases where gimple_assign_copy_p,
1513 gimple_assign_single_p, or equivalent logic is used where a similar
1514 treatment of unary NOPs is appropriate. */
1517 gimple_assign_unary_nop_p (gimple gs)
1519 return (is_gimple_assign (gs)
1520 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
1521 || gimple_assign_rhs_code (gs) == NON_LVALUE_EXPR)
1522 && gimple_assign_rhs1 (gs) != error_mark_node
1523 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs)))
1524 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs)))));
1527 /* Set BB to be the basic block holding G. */
1530 gimple_set_bb (gimple stmt, basic_block bb)
1534 if (gimple_code (stmt) != GIMPLE_LABEL)
1537 /* If the statement is a label, add the label to block-to-labels map
1538 so that we can speed up edge creation for GIMPLE_GOTOs. */
1544 t = gimple_label_label (as_a <glabel *> (stmt));
1545 uid = LABEL_DECL_UID (t);
1549 vec_safe_length (label_to_block_map_for_fn (cfun));
1550 LABEL_DECL_UID (t) = uid = cfun->cfg->last_label_uid++;
1551 if (old_len <= (unsigned) uid)
1553 unsigned new_len = 3 * uid / 2 + 1;
1555 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun),
1560 (*label_to_block_map_for_fn (cfun))[uid] = bb;
1565 /* Modify the RHS of the assignment pointed-to by GSI using the
1566 operands in the expression tree EXPR.
1568 NOTE: The statement pointed-to by GSI may be reallocated if it
1569 did not have enough operand slots.
1571 This function is useful to convert an existing tree expression into
1572 the flat representation used for the RHS of a GIMPLE assignment.
1573 It will reallocate memory as needed to expand or shrink the number
1574 of operand slots needed to represent EXPR.
1576 NOTE: If you find yourself building a tree and then calling this
1577 function, you are most certainly doing it the slow way. It is much
1578 better to build a new assignment or to use the function
1579 gimple_assign_set_rhs_with_ops, which does not require an
1580 expression tree to be built. */
1583 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *gsi, tree expr)
1585 enum tree_code subcode;
1588 extract_ops_from_tree_1 (expr, &subcode, &op1, &op2, &op3);
1589 gimple_assign_set_rhs_with_ops (gsi, subcode, op1, op2, op3);
1593 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1594 operands OP1, OP2 and OP3.
1596 NOTE: The statement pointed-to by GSI may be reallocated if it
1597 did not have enough operand slots. */
1600 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
1601 tree op1, tree op2, tree op3)
1603 unsigned new_rhs_ops = get_gimple_rhs_num_ops (code);
1604 gimple stmt = gsi_stmt (*gsi);
1606 /* If the new CODE needs more operands, allocate a new statement. */
1607 if (gimple_num_ops (stmt) < new_rhs_ops + 1)
1609 tree lhs = gimple_assign_lhs (stmt);
1610 gimple new_stmt = gimple_alloc (gimple_code (stmt), new_rhs_ops + 1);
1611 memcpy (new_stmt, stmt, gimple_size (gimple_code (stmt)));
1612 gimple_init_singleton (new_stmt);
1613 gsi_replace (gsi, new_stmt, true);
1616 /* The LHS needs to be reset as this also changes the SSA name
1618 gimple_assign_set_lhs (stmt, lhs);
1621 gimple_set_num_ops (stmt, new_rhs_ops + 1);
1622 gimple_set_subcode (stmt, code);
1623 gimple_assign_set_rhs1 (stmt, op1);
1624 if (new_rhs_ops > 1)
1625 gimple_assign_set_rhs2 (stmt, op2);
1626 if (new_rhs_ops > 2)
1627 gimple_assign_set_rhs3 (stmt, op3);
1631 /* Return the LHS of a statement that performs an assignment,
1632 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1633 for a call to a function that returns no value, or for a
1634 statement other than an assignment or a call. */
1637 gimple_get_lhs (const_gimple stmt)
1639 enum gimple_code code = gimple_code (stmt);
1641 if (code == GIMPLE_ASSIGN)
1642 return gimple_assign_lhs (stmt);
1643 else if (code == GIMPLE_CALL)
1644 return gimple_call_lhs (stmt);
1650 /* Set the LHS of a statement that performs an assignment,
1651 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1654 gimple_set_lhs (gimple stmt, tree lhs)
1656 enum gimple_code code = gimple_code (stmt);
1658 if (code == GIMPLE_ASSIGN)
1659 gimple_assign_set_lhs (stmt, lhs);
1660 else if (code == GIMPLE_CALL)
1661 gimple_call_set_lhs (stmt, lhs);
1667 /* Return a deep copy of statement STMT. All the operands from STMT
1668 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1669 and VUSE operand arrays are set to empty in the new copy. The new
1670 copy isn't part of any sequence. */
1673 gimple_copy (gimple stmt)
1675 enum gimple_code code = gimple_code (stmt);
1676 unsigned num_ops = gimple_num_ops (stmt);
1677 gimple copy = gimple_alloc (code, num_ops);
1680 /* Shallow copy all the fields from STMT. */
1681 memcpy (copy, stmt, gimple_size (code));
1682 gimple_init_singleton (copy);
1684 /* If STMT has sub-statements, deep-copy them as well. */
1685 if (gimple_has_substatements (stmt))
1690 switch (gimple_code (stmt))
1694 gbind *bind_stmt = as_a <gbind *> (stmt);
1695 gbind *bind_copy = as_a <gbind *> (copy);
1696 new_seq = gimple_seq_copy (gimple_bind_body (bind_stmt));
1697 gimple_bind_set_body (bind_copy, new_seq);
1698 gimple_bind_set_vars (bind_copy,
1699 unshare_expr (gimple_bind_vars (bind_stmt)));
1700 gimple_bind_set_block (bind_copy, gimple_bind_block (bind_stmt));
1706 gcatch *catch_stmt = as_a <gcatch *> (stmt);
1707 gcatch *catch_copy = as_a <gcatch *> (copy);
1708 new_seq = gimple_seq_copy (gimple_catch_handler (catch_stmt));
1709 gimple_catch_set_handler (catch_copy, new_seq);
1710 t = unshare_expr (gimple_catch_types (catch_stmt));
1711 gimple_catch_set_types (catch_copy, t);
1715 case GIMPLE_EH_FILTER:
1717 geh_filter *eh_filter_stmt = as_a <geh_filter *> (stmt);
1718 geh_filter *eh_filter_copy = as_a <geh_filter *> (copy);
1720 = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt));
1721 gimple_eh_filter_set_failure (eh_filter_copy, new_seq);
1722 t = unshare_expr (gimple_eh_filter_types (eh_filter_stmt));
1723 gimple_eh_filter_set_types (eh_filter_copy, t);
1727 case GIMPLE_EH_ELSE:
1729 geh_else *eh_else_stmt = as_a <geh_else *> (stmt);
1730 geh_else *eh_else_copy = as_a <geh_else *> (copy);
1731 new_seq = gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt));
1732 gimple_eh_else_set_n_body (eh_else_copy, new_seq);
1733 new_seq = gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt));
1734 gimple_eh_else_set_e_body (eh_else_copy, new_seq);
1740 gtry *try_stmt = as_a <gtry *> (stmt);
1741 gtry *try_copy = as_a <gtry *> (copy);
1742 new_seq = gimple_seq_copy (gimple_try_eval (try_stmt));
1743 gimple_try_set_eval (try_copy, new_seq);
1744 new_seq = gimple_seq_copy (gimple_try_cleanup (try_stmt));
1745 gimple_try_set_cleanup (try_copy, new_seq);
1749 case GIMPLE_OMP_FOR:
1750 new_seq = gimple_seq_copy (gimple_omp_for_pre_body (stmt));
1751 gimple_omp_for_set_pre_body (copy, new_seq);
1752 t = unshare_expr (gimple_omp_for_clauses (stmt));
1753 gimple_omp_for_set_clauses (copy, t);
1755 gomp_for *omp_for_copy = as_a <gomp_for *> (copy);
1756 omp_for_copy->iter = ggc_vec_alloc<gimple_omp_for_iter>
1757 ( gimple_omp_for_collapse (stmt));
1759 for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
1761 gimple_omp_for_set_cond (copy, i,
1762 gimple_omp_for_cond (stmt, i));
1763 gimple_omp_for_set_index (copy, i,
1764 gimple_omp_for_index (stmt, i));
1765 t = unshare_expr (gimple_omp_for_initial (stmt, i));
1766 gimple_omp_for_set_initial (copy, i, t);
1767 t = unshare_expr (gimple_omp_for_final (stmt, i));
1768 gimple_omp_for_set_final (copy, i, t);
1769 t = unshare_expr (gimple_omp_for_incr (stmt, i));
1770 gimple_omp_for_set_incr (copy, i, t);
1774 case GIMPLE_OMP_PARALLEL:
1776 gomp_parallel *omp_par_stmt = as_a <gomp_parallel *> (stmt);
1777 gomp_parallel *omp_par_copy = as_a <gomp_parallel *> (copy);
1778 t = unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt));
1779 gimple_omp_parallel_set_clauses (omp_par_copy, t);
1780 t = unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt));
1781 gimple_omp_parallel_set_child_fn (omp_par_copy, t);
1782 t = unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt));
1783 gimple_omp_parallel_set_data_arg (omp_par_copy, t);
1787 case GIMPLE_OMP_TASK:
1788 t = unshare_expr (gimple_omp_task_clauses (stmt));
1789 gimple_omp_task_set_clauses (copy, t);
1790 t = unshare_expr (gimple_omp_task_child_fn (stmt));
1791 gimple_omp_task_set_child_fn (copy, t);
1792 t = unshare_expr (gimple_omp_task_data_arg (stmt));
1793 gimple_omp_task_set_data_arg (copy, t);
1794 t = unshare_expr (gimple_omp_task_copy_fn (stmt));
1795 gimple_omp_task_set_copy_fn (copy, t);
1796 t = unshare_expr (gimple_omp_task_arg_size (stmt));
1797 gimple_omp_task_set_arg_size (copy, t);
1798 t = unshare_expr (gimple_omp_task_arg_align (stmt));
1799 gimple_omp_task_set_arg_align (copy, t);
1802 case GIMPLE_OMP_CRITICAL:
1803 t = unshare_expr (gimple_omp_critical_name (
1804 as_a <gomp_critical *> (stmt)));
1805 gimple_omp_critical_set_name (as_a <gomp_critical *> (copy), t);
1808 case GIMPLE_OMP_SECTIONS:
1809 t = unshare_expr (gimple_omp_sections_clauses (stmt));
1810 gimple_omp_sections_set_clauses (copy, t);
1811 t = unshare_expr (gimple_omp_sections_control (stmt));
1812 gimple_omp_sections_set_control (copy, t);
1815 case GIMPLE_OMP_SINGLE:
1816 case GIMPLE_OMP_TARGET:
1817 case GIMPLE_OMP_TEAMS:
1818 case GIMPLE_OMP_SECTION:
1819 case GIMPLE_OMP_MASTER:
1820 case GIMPLE_OMP_TASKGROUP:
1821 case GIMPLE_OMP_ORDERED:
1823 new_seq = gimple_seq_copy (gimple_omp_body (stmt));
1824 gimple_omp_set_body (copy, new_seq);
1827 case GIMPLE_TRANSACTION:
1828 new_seq = gimple_seq_copy (gimple_transaction_body (
1829 as_a <gtransaction *> (stmt)));
1830 gimple_transaction_set_body (as_a <gtransaction *> (copy),
1834 case GIMPLE_WITH_CLEANUP_EXPR:
1835 new_seq = gimple_seq_copy (gimple_wce_cleanup (stmt));
1836 gimple_wce_set_cleanup (copy, new_seq);
1844 /* Make copy of operands. */
1845 for (i = 0; i < num_ops; i++)
1846 gimple_set_op (copy, i, unshare_expr (gimple_op (stmt, i)));
1848 if (gimple_has_mem_ops (stmt))
1850 gimple_set_vdef (copy, gimple_vdef (stmt));
1851 gimple_set_vuse (copy, gimple_vuse (stmt));
1854 /* Clear out SSA operand vectors on COPY. */
1855 if (gimple_has_ops (stmt))
1857 gimple_set_use_ops (copy, NULL);
1859 /* SSA operands need to be updated. */
1860 gimple_set_modified (copy, true);
1867 /* Return true if statement S has side-effects. We consider a
1868 statement to have side effects if:
1870 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
1871 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
1874 gimple_has_side_effects (const_gimple s)
1876 if (is_gimple_debug (s))
1879 /* We don't have to scan the arguments to check for
1880 volatile arguments, though, at present, we still
1881 do a scan to check for TREE_SIDE_EFFECTS. */
1882 if (gimple_has_volatile_ops (s))
1885 if (gimple_code (s) == GIMPLE_ASM
1886 && gimple_asm_volatile_p (as_a <const gasm *> (s)))
1889 if (is_gimple_call (s))
1891 int flags = gimple_call_flags (s);
1893 /* An infinite loop is considered a side effect. */
1894 if (!(flags & (ECF_CONST | ECF_PURE))
1895 || (flags & ECF_LOOPING_CONST_OR_PURE))
1904 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
1905 Return true if S can trap. When INCLUDE_MEM is true, check whether
1906 the memory operations could trap. When INCLUDE_STORES is true and
1907 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
1910 gimple_could_trap_p_1 (gimple s, bool include_mem, bool include_stores)
1912 tree t, div = NULL_TREE;
1917 unsigned i, start = (is_gimple_assign (s) && !include_stores) ? 1 : 0;
1919 for (i = start; i < gimple_num_ops (s); i++)
1920 if (tree_could_trap_p (gimple_op (s, i)))
1924 switch (gimple_code (s))
1927 return gimple_asm_volatile_p (as_a <gasm *> (s));
1930 t = gimple_call_fndecl (s);
1931 /* Assume that calls to weak functions may trap. */
1932 if (!t || !DECL_P (t) || DECL_WEAK (t))
1937 t = gimple_expr_type (s);
1938 op = gimple_assign_rhs_code (s);
1939 if (get_gimple_rhs_class (op) == GIMPLE_BINARY_RHS)
1940 div = gimple_assign_rhs2 (s);
1941 return (operation_could_trap_p (op, FLOAT_TYPE_P (t),
1942 (INTEGRAL_TYPE_P (t)
1943 && TYPE_OVERFLOW_TRAPS (t)),
1953 /* Return true if statement S can trap. */
1956 gimple_could_trap_p (gimple s)
1958 return gimple_could_trap_p_1 (s, true, true);
1961 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
1964 gimple_assign_rhs_could_trap_p (gimple s)
1966 gcc_assert (is_gimple_assign (s));
1967 return gimple_could_trap_p_1 (s, true, false);
1971 /* Print debugging information for gimple stmts generated. */
1974 dump_gimple_statistics (void)
1976 int i, total_tuples = 0, total_bytes = 0;
1978 if (! GATHER_STATISTICS)
1980 fprintf (stderr, "No gimple statistics\n");
1984 fprintf (stderr, "\nGIMPLE statements\n");
1985 fprintf (stderr, "Kind Stmts Bytes\n");
1986 fprintf (stderr, "---------------------------------------\n");
1987 for (i = 0; i < (int) gimple_alloc_kind_all; ++i)
1989 fprintf (stderr, "%-20s %7d %10d\n", gimple_alloc_kind_names[i],
1990 gimple_alloc_counts[i], gimple_alloc_sizes[i]);
1991 total_tuples += gimple_alloc_counts[i];
1992 total_bytes += gimple_alloc_sizes[i];
1994 fprintf (stderr, "---------------------------------------\n");
1995 fprintf (stderr, "%-20s %7d %10d\n", "Total", total_tuples, total_bytes);
1996 fprintf (stderr, "---------------------------------------\n");
2000 /* Return the number of operands needed on the RHS of a GIMPLE
2001 assignment for an expression with tree code CODE. */
2004 get_gimple_rhs_num_ops (enum tree_code code)
2006 enum gimple_rhs_class rhs_class = get_gimple_rhs_class (code);
2008 if (rhs_class == GIMPLE_UNARY_RHS || rhs_class == GIMPLE_SINGLE_RHS)
2010 else if (rhs_class == GIMPLE_BINARY_RHS)
2012 else if (rhs_class == GIMPLE_TERNARY_RHS)
2018 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2020 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2021 : ((TYPE) == tcc_binary \
2022 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2023 : ((TYPE) == tcc_constant \
2024 || (TYPE) == tcc_declaration \
2025 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2026 : ((SYM) == TRUTH_AND_EXPR \
2027 || (SYM) == TRUTH_OR_EXPR \
2028 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2029 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2030 : ((SYM) == COND_EXPR \
2031 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2032 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2033 || (SYM) == DOT_PROD_EXPR \
2034 || (SYM) == SAD_EXPR \
2035 || (SYM) == REALIGN_LOAD_EXPR \
2036 || (SYM) == VEC_COND_EXPR \
2037 || (SYM) == VEC_PERM_EXPR \
2038 || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS \
2039 : ((SYM) == CONSTRUCTOR \
2040 || (SYM) == OBJ_TYPE_REF \
2041 || (SYM) == ASSERT_EXPR \
2042 || (SYM) == ADDR_EXPR \
2043 || (SYM) == WITH_SIZE_EXPR \
2044 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2045 : GIMPLE_INVALID_RHS),
2046 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2048 const unsigned char gimple_rhs_class_table[] = {
2049 #include "all-tree.def"
2053 #undef END_OF_BASE_TREE_CODES
2055 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2056 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2057 we failed to create one. */
2060 canonicalize_cond_expr_cond (tree t)
2062 /* Strip conversions around boolean operations. */
2063 if (CONVERT_EXPR_P (t)
2064 && (truth_value_p (TREE_CODE (TREE_OPERAND (t, 0)))
2065 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0)))
2067 t = TREE_OPERAND (t, 0);
2069 /* For !x use x == 0. */
2070 if (TREE_CODE (t) == TRUTH_NOT_EXPR)
2072 tree top0 = TREE_OPERAND (t, 0);
2073 t = build2 (EQ_EXPR, TREE_TYPE (t),
2074 top0, build_int_cst (TREE_TYPE (top0), 0));
2076 /* For cmp ? 1 : 0 use cmp. */
2077 else if (TREE_CODE (t) == COND_EXPR
2078 && COMPARISON_CLASS_P (TREE_OPERAND (t, 0))
2079 && integer_onep (TREE_OPERAND (t, 1))
2080 && integer_zerop (TREE_OPERAND (t, 2)))
2082 tree top0 = TREE_OPERAND (t, 0);
2083 t = build2 (TREE_CODE (top0), TREE_TYPE (t),
2084 TREE_OPERAND (top0, 0), TREE_OPERAND (top0, 1));
2086 /* For x ^ y use x != y. */
2087 else if (TREE_CODE (t) == BIT_XOR_EXPR)
2088 t = build2 (NE_EXPR, TREE_TYPE (t),
2089 TREE_OPERAND (t, 0), TREE_OPERAND (t, 1));
2091 if (is_gimple_condexpr (t))
2097 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2098 the positions marked by the set ARGS_TO_SKIP. */
2101 gimple_call_copy_skip_args (gcall *stmt, bitmap args_to_skip)
2104 int nargs = gimple_call_num_args (stmt);
2105 auto_vec<tree> vargs (nargs);
2108 for (i = 0; i < nargs; i++)
2109 if (!bitmap_bit_p (args_to_skip, i))
2110 vargs.quick_push (gimple_call_arg (stmt, i));
2112 if (gimple_call_internal_p (stmt))
2113 new_stmt = gimple_build_call_internal_vec (gimple_call_internal_fn (stmt),
2116 new_stmt = gimple_build_call_vec (gimple_call_fn (stmt), vargs);
2118 if (gimple_call_lhs (stmt))
2119 gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
2121 gimple_set_vuse (new_stmt, gimple_vuse (stmt));
2122 gimple_set_vdef (new_stmt, gimple_vdef (stmt));
2124 if (gimple_has_location (stmt))
2125 gimple_set_location (new_stmt, gimple_location (stmt));
2126 gimple_call_copy_flags (new_stmt, stmt);
2127 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
2129 gimple_set_modified (new_stmt, true);
2136 /* Return true if the field decls F1 and F2 are at the same offset.
2138 This is intended to be used on GIMPLE types only. */
2141 gimple_compare_field_offset (tree f1, tree f2)
2143 if (DECL_OFFSET_ALIGN (f1) == DECL_OFFSET_ALIGN (f2))
2145 tree offset1 = DECL_FIELD_OFFSET (f1);
2146 tree offset2 = DECL_FIELD_OFFSET (f2);
2147 return ((offset1 == offset2
2148 /* Once gimplification is done, self-referential offsets are
2149 instantiated as operand #2 of the COMPONENT_REF built for
2150 each access and reset. Therefore, they are not relevant
2151 anymore and fields are interchangeable provided that they
2152 represent the same access. */
2153 || (TREE_CODE (offset1) == PLACEHOLDER_EXPR
2154 && TREE_CODE (offset2) == PLACEHOLDER_EXPR
2155 && (DECL_SIZE (f1) == DECL_SIZE (f2)
2156 || (TREE_CODE (DECL_SIZE (f1)) == PLACEHOLDER_EXPR
2157 && TREE_CODE (DECL_SIZE (f2)) == PLACEHOLDER_EXPR)
2158 || operand_equal_p (DECL_SIZE (f1), DECL_SIZE (f2), 0))
2159 && DECL_ALIGN (f1) == DECL_ALIGN (f2))
2160 || operand_equal_p (offset1, offset2, 0))
2161 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1),
2162 DECL_FIELD_BIT_OFFSET (f2)));
2165 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2166 should be, so handle differing ones specially by decomposing
2167 the offset into a byte and bit offset manually. */
2168 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1))
2169 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2)))
2171 unsigned HOST_WIDE_INT byte_offset1, byte_offset2;
2172 unsigned HOST_WIDE_INT bit_offset1, bit_offset2;
2173 bit_offset1 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1));
2174 byte_offset1 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1))
2175 + bit_offset1 / BITS_PER_UNIT);
2176 bit_offset2 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2));
2177 byte_offset2 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2))
2178 + bit_offset2 / BITS_PER_UNIT);
2179 if (byte_offset1 != byte_offset2)
2181 return bit_offset1 % BITS_PER_UNIT == bit_offset2 % BITS_PER_UNIT;
2188 /* Return a type the same as TYPE except unsigned or
2189 signed according to UNSIGNEDP. */
2192 gimple_signed_or_unsigned_type (bool unsignedp, tree type)
2197 type1 = TYPE_MAIN_VARIANT (type);
2198 if (type1 == signed_char_type_node
2199 || type1 == char_type_node
2200 || type1 == unsigned_char_type_node)
2201 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2202 if (type1 == integer_type_node || type1 == unsigned_type_node)
2203 return unsignedp ? unsigned_type_node : integer_type_node;
2204 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
2205 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2206 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
2207 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2208 if (type1 == long_long_integer_type_node
2209 || type1 == long_long_unsigned_type_node)
2211 ? long_long_unsigned_type_node
2212 : long_long_integer_type_node;
2214 for (i = 0; i < NUM_INT_N_ENTS; i ++)
2215 if (int_n_enabled_p[i]
2216 && (type1 == int_n_trees[i].unsigned_type
2217 || type1 == int_n_trees[i].signed_type))
2219 ? int_n_trees[i].unsigned_type
2220 : int_n_trees[i].signed_type;
2222 #if HOST_BITS_PER_WIDE_INT >= 64
2223 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
2224 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2226 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
2227 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2228 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
2229 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2230 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
2231 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2232 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
2233 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2235 #define GIMPLE_FIXED_TYPES(NAME) \
2236 if (type1 == short_ ## NAME ## _type_node \
2237 || type1 == unsigned_short_ ## NAME ## _type_node) \
2238 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2239 : short_ ## NAME ## _type_node; \
2240 if (type1 == NAME ## _type_node \
2241 || type1 == unsigned_ ## NAME ## _type_node) \
2242 return unsignedp ? unsigned_ ## NAME ## _type_node \
2243 : NAME ## _type_node; \
2244 if (type1 == long_ ## NAME ## _type_node \
2245 || type1 == unsigned_long_ ## NAME ## _type_node) \
2246 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2247 : long_ ## NAME ## _type_node; \
2248 if (type1 == long_long_ ## NAME ## _type_node \
2249 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2250 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2251 : long_long_ ## NAME ## _type_node;
2253 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2254 if (type1 == NAME ## _type_node \
2255 || type1 == u ## NAME ## _type_node) \
2256 return unsignedp ? u ## NAME ## _type_node \
2257 : NAME ## _type_node;
2259 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2260 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2261 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2262 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2263 : sat_ ## short_ ## NAME ## _type_node; \
2264 if (type1 == sat_ ## NAME ## _type_node \
2265 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2266 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2267 : sat_ ## NAME ## _type_node; \
2268 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2269 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2270 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2271 : sat_ ## long_ ## NAME ## _type_node; \
2272 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2273 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2274 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2275 : sat_ ## long_long_ ## NAME ## _type_node;
2277 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2278 if (type1 == sat_ ## NAME ## _type_node \
2279 || type1 == sat_ ## u ## NAME ## _type_node) \
2280 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2281 : sat_ ## NAME ## _type_node;
2283 GIMPLE_FIXED_TYPES (fract);
2284 GIMPLE_FIXED_TYPES_SAT (fract);
2285 GIMPLE_FIXED_TYPES (accum);
2286 GIMPLE_FIXED_TYPES_SAT (accum);
2288 GIMPLE_FIXED_MODE_TYPES (qq);
2289 GIMPLE_FIXED_MODE_TYPES (hq);
2290 GIMPLE_FIXED_MODE_TYPES (sq);
2291 GIMPLE_FIXED_MODE_TYPES (dq);
2292 GIMPLE_FIXED_MODE_TYPES (tq);
2293 GIMPLE_FIXED_MODE_TYPES_SAT (qq);
2294 GIMPLE_FIXED_MODE_TYPES_SAT (hq);
2295 GIMPLE_FIXED_MODE_TYPES_SAT (sq);
2296 GIMPLE_FIXED_MODE_TYPES_SAT (dq);
2297 GIMPLE_FIXED_MODE_TYPES_SAT (tq);
2298 GIMPLE_FIXED_MODE_TYPES (ha);
2299 GIMPLE_FIXED_MODE_TYPES (sa);
2300 GIMPLE_FIXED_MODE_TYPES (da);
2301 GIMPLE_FIXED_MODE_TYPES (ta);
2302 GIMPLE_FIXED_MODE_TYPES_SAT (ha);
2303 GIMPLE_FIXED_MODE_TYPES_SAT (sa);
2304 GIMPLE_FIXED_MODE_TYPES_SAT (da);
2305 GIMPLE_FIXED_MODE_TYPES_SAT (ta);
2307 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2308 the precision; they have precision set to match their range, but
2309 may use a wider mode to match an ABI. If we change modes, we may
2310 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2311 the precision as well, so as to yield correct results for
2312 bit-field types. C++ does not have these separate bit-field
2313 types, and producing a signed or unsigned variant of an
2314 ENUMERAL_TYPE may cause other problems as well. */
2315 if (!INTEGRAL_TYPE_P (type)
2316 || TYPE_UNSIGNED (type) == unsignedp)
2319 #define TYPE_OK(node) \
2320 (TYPE_MODE (type) == TYPE_MODE (node) \
2321 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2322 if (TYPE_OK (signed_char_type_node))
2323 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2324 if (TYPE_OK (integer_type_node))
2325 return unsignedp ? unsigned_type_node : integer_type_node;
2326 if (TYPE_OK (short_integer_type_node))
2327 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2328 if (TYPE_OK (long_integer_type_node))
2329 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2330 if (TYPE_OK (long_long_integer_type_node))
2332 ? long_long_unsigned_type_node
2333 : long_long_integer_type_node);
2335 for (i = 0; i < NUM_INT_N_ENTS; i ++)
2336 if (int_n_enabled_p[i]
2337 && TYPE_MODE (type) == int_n_data[i].m
2338 && TYPE_PRECISION (type) == int_n_data[i].bitsize)
2340 ? int_n_trees[i].unsigned_type
2341 : int_n_trees[i].signed_type;
2343 #if HOST_BITS_PER_WIDE_INT >= 64
2344 if (TYPE_OK (intTI_type_node))
2345 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2347 if (TYPE_OK (intDI_type_node))
2348 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2349 if (TYPE_OK (intSI_type_node))
2350 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2351 if (TYPE_OK (intHI_type_node))
2352 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2353 if (TYPE_OK (intQI_type_node))
2354 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2356 #undef GIMPLE_FIXED_TYPES
2357 #undef GIMPLE_FIXED_MODE_TYPES
2358 #undef GIMPLE_FIXED_TYPES_SAT
2359 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2362 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2366 /* Return an unsigned type the same as TYPE in other respects. */
2369 gimple_unsigned_type (tree type)
2371 return gimple_signed_or_unsigned_type (true, type);
2375 /* Return a signed type the same as TYPE in other respects. */
2378 gimple_signed_type (tree type)
2380 return gimple_signed_or_unsigned_type (false, type);
2384 /* Return the typed-based alias set for T, which may be an expression
2385 or a type. Return -1 if we don't do anything special. */
2388 gimple_get_alias_set (tree t)
2392 /* Permit type-punning when accessing a union, provided the access
2393 is directly through the union. For example, this code does not
2394 permit taking the address of a union member and then storing
2395 through it. Even the type-punning allowed here is a GCC
2396 extension, albeit a common and useful one; the C standard says
2397 that such accesses have implementation-defined behavior. */
2399 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2400 u = TREE_OPERAND (u, 0))
2401 if (TREE_CODE (u) == COMPONENT_REF
2402 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2405 /* That's all the expressions we handle specially. */
2409 /* For convenience, follow the C standard when dealing with
2410 character types. Any object may be accessed via an lvalue that
2411 has character type. */
2412 if (t == char_type_node
2413 || t == signed_char_type_node
2414 || t == unsigned_char_type_node)
2417 /* Allow aliasing between signed and unsigned variants of the same
2418 type. We treat the signed variant as canonical. */
2419 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2421 tree t1 = gimple_signed_type (t);
2423 /* t1 == t can happen for boolean nodes which are always unsigned. */
2425 return get_alias_set (t1);
2432 /* Helper for gimple_ior_addresses_taken_1. */
2435 gimple_ior_addresses_taken_1 (gimple, tree addr, tree, void *data)
2437 bitmap addresses_taken = (bitmap)data;
2438 addr = get_base_address (addr);
2442 bitmap_set_bit (addresses_taken, DECL_UID (addr));
2448 /* Set the bit for the uid of all decls that have their address taken
2449 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2450 were any in this stmt. */
2453 gimple_ior_addresses_taken (bitmap addresses_taken, gimple stmt)
2455 return walk_stmt_load_store_addr_ops (stmt, addresses_taken, NULL, NULL,
2456 gimple_ior_addresses_taken_1);
2460 /* Return true if TYPE1 and TYPE2 are compatible enough for builtin
2464 validate_type (tree type1, tree type2)
2466 if (INTEGRAL_TYPE_P (type1)
2467 && INTEGRAL_TYPE_P (type2))
2469 else if (POINTER_TYPE_P (type1)
2470 && POINTER_TYPE_P (type2))
2472 else if (TREE_CODE (type1)
2473 != TREE_CODE (type2))
2478 /* Return true when STMTs arguments and return value match those of FNDECL,
2479 a decl of a builtin function. */
2482 gimple_builtin_call_types_compatible_p (const_gimple stmt, tree fndecl)
2484 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN);
2486 tree ret = gimple_call_lhs (stmt);
2488 && !validate_type (TREE_TYPE (ret), TREE_TYPE (TREE_TYPE (fndecl))))
2491 tree targs = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2492 unsigned nargs = gimple_call_num_args (stmt);
2493 for (unsigned i = 0; i < nargs; ++i)
2495 /* Variadic args follow. */
2498 tree arg = gimple_call_arg (stmt, i);
2499 if (!validate_type (TREE_TYPE (arg), TREE_VALUE (targs)))
2501 targs = TREE_CHAIN (targs);
2503 if (targs && !VOID_TYPE_P (TREE_VALUE (targs)))
2508 /* Return true when STMT is builtins call. */
2511 gimple_call_builtin_p (const_gimple stmt)
2514 if (is_gimple_call (stmt)
2515 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2516 && DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN)
2517 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2521 /* Return true when STMT is builtins call to CLASS. */
2524 gimple_call_builtin_p (const_gimple stmt, enum built_in_class klass)
2527 if (is_gimple_call (stmt)
2528 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2529 && DECL_BUILT_IN_CLASS (fndecl) == klass)
2530 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2534 /* Return true when STMT is builtins call to CODE of CLASS. */
2537 gimple_call_builtin_p (const_gimple stmt, enum built_in_function code)
2540 if (is_gimple_call (stmt)
2541 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2542 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
2543 && DECL_FUNCTION_CODE (fndecl) == code)
2544 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2548 /* Return true if STMT clobbers memory. STMT is required to be a
2552 gimple_asm_clobbers_memory_p (const gasm *stmt)
2556 for (i = 0; i < gimple_asm_nclobbers (stmt); i++)
2558 tree op = gimple_asm_clobber_op (stmt, i);
2559 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op)), "memory") == 0)
2566 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2569 dump_decl_set (FILE *file, bitmap set)
2576 fprintf (file, "{ ");
2578 EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi)
2580 fprintf (file, "D.%u", i);
2581 fprintf (file, " ");
2584 fprintf (file, "}");
2587 fprintf (file, "NIL");
2590 /* Return true when CALL is a call stmt that definitely doesn't
2591 free any memory or makes it unavailable otherwise. */
2593 nonfreeing_call_p (gimple call)
2595 if (gimple_call_builtin_p (call, BUILT_IN_NORMAL)
2596 && gimple_call_flags (call) & ECF_LEAF)
2597 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call)))
2599 /* Just in case these become ECF_LEAF in the future. */
2601 case BUILT_IN_TM_FREE:
2602 case BUILT_IN_REALLOC:
2603 case BUILT_IN_STACK_RESTORE:
2608 else if (gimple_call_internal_p (call))
2609 switch (gimple_call_internal_fn (call))
2611 case IFN_ABNORMAL_DISPATCHER:
2614 if (gimple_call_flags (call) & ECF_LEAF)
2619 tree fndecl = gimple_call_fndecl (call);
2622 struct cgraph_node *n = cgraph_node::get (fndecl);
2625 enum availability availability;
2626 n = n->function_symbol (&availability);
2627 if (!n || availability <= AVAIL_INTERPOSABLE)
2629 return n->nonfreeing_fn;
2632 /* Callback for walk_stmt_load_store_ops.
2634 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2637 This routine only makes a superficial check for a dereference. Thus
2638 it must only be used if it is safe to return a false negative. */
2640 check_loadstore (gimple, tree op, tree, void *data)
2642 if ((TREE_CODE (op) == MEM_REF || TREE_CODE (op) == TARGET_MEM_REF)
2643 && operand_equal_p (TREE_OPERAND (op, 0), (tree)data, 0))
2648 /* If OP can be inferred to be non-NULL after STMT executes, return true.
2650 DEREFERENCE is TRUE if we can use a pointer dereference to infer a
2651 non-NULL range, FALSE otherwise.
2653 ATTRIBUTE is TRUE if we can use attributes to infer a non-NULL range
2654 for function arguments and return values. FALSE otherwise. */
2657 infer_nonnull_range (gimple stmt, tree op, bool dereference, bool attribute)
2659 /* We can only assume that a pointer dereference will yield
2660 non-NULL if -fdelete-null-pointer-checks is enabled. */
2661 if (!flag_delete_null_pointer_checks
2662 || !POINTER_TYPE_P (TREE_TYPE (op))
2663 || gimple_code (stmt) == GIMPLE_ASM)
2667 && walk_stmt_load_store_ops (stmt, (void *)op,
2668 check_loadstore, check_loadstore))
2672 && is_gimple_call (stmt) && !gimple_call_internal_p (stmt))
2674 tree fntype = gimple_call_fntype (stmt);
2675 tree attrs = TYPE_ATTRIBUTES (fntype);
2676 for (; attrs; attrs = TREE_CHAIN (attrs))
2678 attrs = lookup_attribute ("nonnull", attrs);
2680 /* If "nonnull" wasn't specified, we know nothing about
2682 if (attrs == NULL_TREE)
2685 /* If "nonnull" applies to all the arguments, then ARG
2686 is non-null if it's in the argument list. */
2687 if (TREE_VALUE (attrs) == NULL_TREE)
2689 for (unsigned int i = 0; i < gimple_call_num_args (stmt); i++)
2691 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt, i)))
2692 && operand_equal_p (op, gimple_call_arg (stmt, i), 0))
2698 /* Now see if op appears in the nonnull list. */
2699 for (tree t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t))
2701 int idx = TREE_INT_CST_LOW (TREE_VALUE (t)) - 1;
2702 tree arg = gimple_call_arg (stmt, idx);
2703 if (operand_equal_p (op, arg, 0))
2709 /* If this function is marked as returning non-null, then we can
2710 infer OP is non-null if it is used in the return statement. */
2712 if (greturn *return_stmt = dyn_cast <greturn *> (stmt))
2713 if (gimple_return_retval (return_stmt)
2714 && operand_equal_p (gimple_return_retval (return_stmt), op, 0)
2715 && lookup_attribute ("returns_nonnull",
2716 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
2722 /* Compare two case labels. Because the front end should already have
2723 made sure that case ranges do not overlap, it is enough to only compare
2724 the CASE_LOW values of each case label. */
2727 compare_case_labels (const void *p1, const void *p2)
2729 const_tree const case1 = *(const_tree const*)p1;
2730 const_tree const case2 = *(const_tree const*)p2;
2732 /* The 'default' case label always goes first. */
2733 if (!CASE_LOW (case1))
2735 else if (!CASE_LOW (case2))
2738 return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
2741 /* Sort the case labels in LABEL_VEC in place in ascending order. */
2744 sort_case_labels (vec<tree> label_vec)
2746 label_vec.qsort (compare_case_labels);
2749 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2751 LABELS is a vector that contains all case labels to look at.
2753 INDEX_TYPE is the type of the switch index expression. Case labels
2754 in LABELS are discarded if their values are not in the value range
2755 covered by INDEX_TYPE. The remaining case label values are folded
2758 If a default case exists in LABELS, it is removed from LABELS and
2759 returned in DEFAULT_CASEP. If no default case exists, but the
2760 case labels already cover the whole range of INDEX_TYPE, a default
2761 case is returned pointing to one of the existing case labels.
2762 Otherwise DEFAULT_CASEP is set to NULL_TREE.
2764 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2765 apply and no action is taken regardless of whether a default case is
2769 preprocess_case_label_vec_for_gimple (vec<tree> labels,
2771 tree *default_casep)
2773 tree min_value, max_value;
2774 tree default_case = NULL_TREE;
2778 min_value = TYPE_MIN_VALUE (index_type);
2779 max_value = TYPE_MAX_VALUE (index_type);
2780 while (i < labels.length ())
2782 tree elt = labels[i];
2783 tree low = CASE_LOW (elt);
2784 tree high = CASE_HIGH (elt);
2785 bool remove_element = FALSE;
2789 gcc_checking_assert (TREE_CODE (low) == INTEGER_CST);
2790 gcc_checking_assert (!high || TREE_CODE (high) == INTEGER_CST);
2792 /* This is a non-default case label, i.e. it has a value.
2794 See if the case label is reachable within the range of
2795 the index type. Remove out-of-range case values. Turn
2796 case ranges into a canonical form (high > low strictly)
2797 and convert the case label values to the index type.
2799 NB: The type of gimple_switch_index() may be the promoted
2800 type, but the case labels retain the original type. */
2804 /* This is a case range. Discard empty ranges.
2805 If the bounds or the range are equal, turn this
2806 into a simple (one-value) case. */
2807 int cmp = tree_int_cst_compare (high, low);
2809 remove_element = TRUE;
2816 /* If the simple case value is unreachable, ignore it. */
2817 if ((TREE_CODE (min_value) == INTEGER_CST
2818 && tree_int_cst_compare (low, min_value) < 0)
2819 || (TREE_CODE (max_value) == INTEGER_CST
2820 && tree_int_cst_compare (low, max_value) > 0))
2821 remove_element = TRUE;
2823 low = fold_convert (index_type, low);
2827 /* If the entire case range is unreachable, ignore it. */
2828 if ((TREE_CODE (min_value) == INTEGER_CST
2829 && tree_int_cst_compare (high, min_value) < 0)
2830 || (TREE_CODE (max_value) == INTEGER_CST
2831 && tree_int_cst_compare (low, max_value) > 0))
2832 remove_element = TRUE;
2835 /* If the lower bound is less than the index type's
2836 minimum value, truncate the range bounds. */
2837 if (TREE_CODE (min_value) == INTEGER_CST
2838 && tree_int_cst_compare (low, min_value) < 0)
2840 low = fold_convert (index_type, low);
2842 /* If the upper bound is greater than the index type's
2843 maximum value, truncate the range bounds. */
2844 if (TREE_CODE (max_value) == INTEGER_CST
2845 && tree_int_cst_compare (high, max_value) > 0)
2847 high = fold_convert (index_type, high);
2849 /* We may have folded a case range to a one-value case. */
2850 if (tree_int_cst_equal (low, high))
2855 CASE_LOW (elt) = low;
2856 CASE_HIGH (elt) = high;
2860 gcc_assert (!default_case);
2862 /* The default case must be passed separately to the
2863 gimple_build_switch routine. But if DEFAULT_CASEP
2864 is NULL, we do not remove the default case (it would
2865 be completely lost). */
2867 remove_element = TRUE;
2871 labels.ordered_remove (i);
2877 if (!labels.is_empty ())
2878 sort_case_labels (labels);
2880 if (default_casep && !default_case)
2882 /* If the switch has no default label, add one, so that we jump
2883 around the switch body. If the labels already cover the whole
2884 range of the switch index_type, add the default label pointing
2885 to one of the existing labels. */
2887 && TYPE_MIN_VALUE (index_type)
2888 && TYPE_MAX_VALUE (index_type)
2889 && tree_int_cst_equal (CASE_LOW (labels[0]),
2890 TYPE_MIN_VALUE (index_type)))
2892 tree low, high = CASE_HIGH (labels[len - 1]);
2894 high = CASE_LOW (labels[len - 1]);
2895 if (tree_int_cst_equal (high, TYPE_MAX_VALUE (index_type)))
2897 for (i = 1; i < len; i++)
2899 high = CASE_LOW (labels[i]);
2900 low = CASE_HIGH (labels[i - 1]);
2902 low = CASE_LOW (labels[i - 1]);
2903 if (wi::add (low, 1) != high)
2908 tree label = CASE_LABEL (labels[0]);
2909 default_case = build_case_label (NULL_TREE, NULL_TREE,
2917 *default_casep = default_case;
2920 /* Set the location of all statements in SEQ to LOC. */
2923 gimple_seq_set_location (gimple_seq seq, location_t loc)
2925 for (gimple_stmt_iterator i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
2926 gimple_set_location (gsi_stmt (i), loc);
2929 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
2932 gimple_seq_discard (gimple_seq seq)
2934 gimple_stmt_iterator gsi;
2936 for (gsi = gsi_start (seq); !gsi_end_p (gsi); )
2938 gimple stmt = gsi_stmt (gsi);
2939 gsi_remove (&gsi, true);
2940 release_defs (stmt);
2945 /* See if STMT now calls function that takes no parameters and if so, drop
2946 call arguments. This is used when devirtualization machinery redirects
2947 to __builtiln_unreacahble or __cxa_pure_virutal. */
2950 maybe_remove_unused_call_args (struct function *fn, gimple stmt)
2952 tree decl = gimple_call_fndecl (stmt);
2953 if (TYPE_ARG_TYPES (TREE_TYPE (decl))
2954 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))) == void_type_node
2955 && gimple_call_num_args (stmt))
2957 gimple_set_num_ops (stmt, 3);
2958 update_stmt_fn (fn, stmt);