* gcc.dg/ipa/inlinehint-4.c: Also pass --param inline-unit-growth=20.
[official-gcc.git] / gcc / gimple.c
blobc1b7229a6b79fb8ef623fcd139babd35aacc7de3
1 /* Gimple IR support functions.
3 Copyright (C) 2007-2018 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
11 version.
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
16 for more details.
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/>. */
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "backend.h"
26 #include "tree.h"
27 #include "gimple.h"
28 #include "ssa.h"
29 #include "cgraph.h"
30 #include "diagnostic.h"
31 #include "alias.h"
32 #include "fold-const.h"
33 #include "calls.h"
34 #include "stor-layout.h"
35 #include "internal-fn.h"
36 #include "tree-eh.h"
37 #include "gimple-iterator.h"
38 #include "gimple-walk.h"
39 #include "gimplify.h"
40 #include "target.h"
41 #include "builtins.h"
42 #include "selftest.h"
43 #include "gimple-pretty-print.h"
44 #include "stringpool.h"
45 #include "attribs.h"
46 #include "asan.h"
49 /* All the tuples have their operand vector (if present) at the very bottom
50 of the structure. Therefore, the offset required to find the
51 operands vector the size of the structure minus the size of the 1
52 element tree array at the end (see gimple_ops). */
53 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
54 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
55 EXPORTED_CONST size_t gimple_ops_offset_[] = {
56 #include "gsstruct.def"
58 #undef DEFGSSTRUCT
60 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
61 static const size_t gsstruct_code_size[] = {
62 #include "gsstruct.def"
64 #undef DEFGSSTRUCT
66 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
67 const char *const gimple_code_name[] = {
68 #include "gimple.def"
70 #undef DEFGSCODE
72 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
73 EXPORTED_CONST enum gimple_statement_structure_enum gss_for_code_[] = {
74 #include "gimple.def"
76 #undef DEFGSCODE
78 /* Gimple stats. */
80 uint64_t gimple_alloc_counts[(int) gimple_alloc_kind_all];
81 uint64_t gimple_alloc_sizes[(int) gimple_alloc_kind_all];
83 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
84 static const char * const gimple_alloc_kind_names[] = {
85 "assignments",
86 "phi nodes",
87 "conditionals",
88 "everything else"
91 /* Static gimple tuple members. */
92 const enum gimple_code gassign::code_;
93 const enum gimple_code gcall::code_;
94 const enum gimple_code gcond::code_;
97 /* Gimple tuple constructors.
98 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
99 be passed a NULL to start with an empty sequence. */
101 /* Set the code for statement G to CODE. */
103 static inline void
104 gimple_set_code (gimple *g, enum gimple_code code)
106 g->code = code;
109 /* Return the number of bytes needed to hold a GIMPLE statement with
110 code CODE. */
112 static inline size_t
113 gimple_size (enum gimple_code code)
115 return gsstruct_code_size[gss_for_code (code)];
118 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
119 operands. */
121 gimple *
122 gimple_alloc (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
124 size_t size;
125 gimple *stmt;
127 size = gimple_size (code);
128 if (num_ops > 0)
129 size += sizeof (tree) * (num_ops - 1);
131 if (GATHER_STATISTICS)
133 enum gimple_alloc_kind kind = gimple_alloc_kind (code);
134 gimple_alloc_counts[(int) kind]++;
135 gimple_alloc_sizes[(int) kind] += size;
138 stmt = ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT);
139 gimple_set_code (stmt, code);
140 gimple_set_num_ops (stmt, num_ops);
142 /* Do not call gimple_set_modified here as it has other side
143 effects and this tuple is still not completely built. */
144 stmt->modified = 1;
145 gimple_init_singleton (stmt);
147 return stmt;
150 /* Set SUBCODE to be the code of the expression computed by statement G. */
152 static inline void
153 gimple_set_subcode (gimple *g, unsigned subcode)
155 /* We only have 16 bits for the RHS code. Assert that we are not
156 overflowing it. */
157 gcc_assert (subcode < (1 << 16));
158 g->subcode = subcode;
163 /* Build a tuple with operands. CODE is the statement to build (which
164 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
165 for the new tuple. NUM_OPS is the number of operands to allocate. */
167 #define gimple_build_with_ops(c, s, n) \
168 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
170 static gimple *
171 gimple_build_with_ops_stat (enum gimple_code code, unsigned subcode,
172 unsigned num_ops MEM_STAT_DECL)
174 gimple *s = gimple_alloc (code, num_ops PASS_MEM_STAT);
175 gimple_set_subcode (s, subcode);
177 return s;
181 /* Build a GIMPLE_RETURN statement returning RETVAL. */
183 greturn *
184 gimple_build_return (tree retval)
186 greturn *s
187 = as_a <greturn *> (gimple_build_with_ops (GIMPLE_RETURN, ERROR_MARK,
188 2));
189 if (retval)
190 gimple_return_set_retval (s, retval);
191 return s;
194 /* Reset alias information on call S. */
196 void
197 gimple_call_reset_alias_info (gcall *s)
199 if (gimple_call_flags (s) & ECF_CONST)
200 memset (gimple_call_use_set (s), 0, sizeof (struct pt_solution));
201 else
202 pt_solution_reset (gimple_call_use_set (s));
203 if (gimple_call_flags (s) & (ECF_CONST|ECF_PURE|ECF_NOVOPS))
204 memset (gimple_call_clobber_set (s), 0, sizeof (struct pt_solution));
205 else
206 pt_solution_reset (gimple_call_clobber_set (s));
209 /* Helper for gimple_build_call, gimple_build_call_valist,
210 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
211 components of a GIMPLE_CALL statement to function FN with NARGS
212 arguments. */
214 static inline gcall *
215 gimple_build_call_1 (tree fn, unsigned nargs)
217 gcall *s
218 = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
219 nargs + 3));
220 if (TREE_CODE (fn) == FUNCTION_DECL)
221 fn = build_fold_addr_expr (fn);
222 gimple_set_op (s, 1, fn);
223 gimple_call_set_fntype (s, TREE_TYPE (TREE_TYPE (fn)));
224 gimple_call_reset_alias_info (s);
225 return s;
229 /* Build a GIMPLE_CALL statement to function FN with the arguments
230 specified in vector ARGS. */
232 gcall *
233 gimple_build_call_vec (tree fn, vec<tree> args)
235 unsigned i;
236 unsigned nargs = args.length ();
237 gcall *call = gimple_build_call_1 (fn, nargs);
239 for (i = 0; i < nargs; i++)
240 gimple_call_set_arg (call, i, args[i]);
242 return call;
246 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
247 arguments. The ... are the arguments. */
249 gcall *
250 gimple_build_call (tree fn, unsigned nargs, ...)
252 va_list ap;
253 gcall *call;
254 unsigned i;
256 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
258 call = gimple_build_call_1 (fn, nargs);
260 va_start (ap, nargs);
261 for (i = 0; i < nargs; i++)
262 gimple_call_set_arg (call, i, va_arg (ap, tree));
263 va_end (ap);
265 return call;
269 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
270 arguments. AP contains the arguments. */
272 gcall *
273 gimple_build_call_valist (tree fn, unsigned nargs, va_list ap)
275 gcall *call;
276 unsigned i;
278 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
280 call = gimple_build_call_1 (fn, nargs);
282 for (i = 0; i < nargs; i++)
283 gimple_call_set_arg (call, i, va_arg (ap, tree));
285 return call;
289 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
290 Build the basic components of a GIMPLE_CALL statement to internal
291 function FN with NARGS arguments. */
293 static inline gcall *
294 gimple_build_call_internal_1 (enum internal_fn fn, unsigned nargs)
296 gcall *s
297 = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
298 nargs + 3));
299 s->subcode |= GF_CALL_INTERNAL;
300 gimple_call_set_internal_fn (s, fn);
301 gimple_call_reset_alias_info (s);
302 return s;
306 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
307 the number of arguments. The ... are the arguments. */
309 gcall *
310 gimple_build_call_internal (enum internal_fn fn, unsigned nargs, ...)
312 va_list ap;
313 gcall *call;
314 unsigned i;
316 call = gimple_build_call_internal_1 (fn, nargs);
317 va_start (ap, nargs);
318 for (i = 0; i < nargs; i++)
319 gimple_call_set_arg (call, i, va_arg (ap, tree));
320 va_end (ap);
322 return call;
326 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
327 specified in vector ARGS. */
329 gcall *
330 gimple_build_call_internal_vec (enum internal_fn fn, vec<tree> args)
332 unsigned i, nargs;
333 gcall *call;
335 nargs = args.length ();
336 call = gimple_build_call_internal_1 (fn, nargs);
337 for (i = 0; i < nargs; i++)
338 gimple_call_set_arg (call, i, args[i]);
340 return call;
344 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
345 assumed to be in GIMPLE form already. Minimal checking is done of
346 this fact. */
348 gcall *
349 gimple_build_call_from_tree (tree t, tree fnptrtype)
351 unsigned i, nargs;
352 gcall *call;
353 tree fndecl = get_callee_fndecl (t);
355 gcc_assert (TREE_CODE (t) == CALL_EXPR);
357 nargs = call_expr_nargs (t);
358 call = gimple_build_call_1 (fndecl ? fndecl : CALL_EXPR_FN (t), nargs);
360 for (i = 0; i < nargs; i++)
361 gimple_call_set_arg (call, i, CALL_EXPR_ARG (t, i));
363 gimple_set_block (call, TREE_BLOCK (t));
364 gimple_set_location (call, EXPR_LOCATION (t));
366 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
367 gimple_call_set_chain (call, CALL_EXPR_STATIC_CHAIN (t));
368 gimple_call_set_tail (call, CALL_EXPR_TAILCALL (t));
369 gimple_call_set_must_tail (call, CALL_EXPR_MUST_TAIL_CALL (t));
370 gimple_call_set_return_slot_opt (call, CALL_EXPR_RETURN_SLOT_OPT (t));
371 if (fndecl
372 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
373 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl)))
374 gimple_call_set_alloca_for_var (call, CALL_ALLOCA_FOR_VAR_P (t));
375 else
376 gimple_call_set_from_thunk (call, CALL_FROM_THUNK_P (t));
377 gimple_call_set_va_arg_pack (call, CALL_EXPR_VA_ARG_PACK (t));
378 gimple_call_set_nothrow (call, TREE_NOTHROW (t));
379 gimple_call_set_by_descriptor (call, CALL_EXPR_BY_DESCRIPTOR (t));
380 gimple_set_no_warning (call, TREE_NO_WARNING (t));
381 gimple_call_set_with_bounds (call, CALL_WITH_BOUNDS_P (t));
383 if (fnptrtype)
385 gimple_call_set_fntype (call, TREE_TYPE (fnptrtype));
387 /* Check if it's an indirect CALL and the type has the
388 nocf_check attribute. In that case propagate the information
389 to the gimple CALL insn. */
390 if (!fndecl)
392 gcc_assert (POINTER_TYPE_P (fnptrtype));
393 tree fntype = TREE_TYPE (fnptrtype);
395 if (lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (fntype)))
396 gimple_call_set_nocf_check (call, TRUE);
400 return call;
404 /* Build a GIMPLE_ASSIGN statement.
406 LHS of the assignment.
407 RHS of the assignment which can be unary or binary. */
409 gassign *
410 gimple_build_assign (tree lhs, tree rhs MEM_STAT_DECL)
412 enum tree_code subcode;
413 tree op1, op2, op3;
415 extract_ops_from_tree (rhs, &subcode, &op1, &op2, &op3);
416 return gimple_build_assign (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
420 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
421 OP1, OP2 and OP3. */
423 static inline gassign *
424 gimple_build_assign_1 (tree lhs, enum tree_code subcode, tree op1,
425 tree op2, tree op3 MEM_STAT_DECL)
427 unsigned num_ops;
428 gassign *p;
430 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
431 code). */
432 num_ops = get_gimple_rhs_num_ops (subcode) + 1;
434 p = as_a <gassign *> (
435 gimple_build_with_ops_stat (GIMPLE_ASSIGN, (unsigned)subcode, num_ops
436 PASS_MEM_STAT));
437 gimple_assign_set_lhs (p, lhs);
438 gimple_assign_set_rhs1 (p, op1);
439 if (op2)
441 gcc_assert (num_ops > 2);
442 gimple_assign_set_rhs2 (p, op2);
445 if (op3)
447 gcc_assert (num_ops > 3);
448 gimple_assign_set_rhs3 (p, op3);
451 return p;
454 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
455 OP1, OP2 and OP3. */
457 gassign *
458 gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
459 tree op2, tree op3 MEM_STAT_DECL)
461 return gimple_build_assign_1 (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
464 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
465 OP1 and OP2. */
467 gassign *
468 gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
469 tree op2 MEM_STAT_DECL)
471 return gimple_build_assign_1 (lhs, subcode, op1, op2, NULL_TREE
472 PASS_MEM_STAT);
475 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
477 gassign *
478 gimple_build_assign (tree lhs, enum tree_code subcode, tree op1 MEM_STAT_DECL)
480 return gimple_build_assign_1 (lhs, subcode, op1, NULL_TREE, NULL_TREE
481 PASS_MEM_STAT);
485 /* Build a GIMPLE_COND statement.
487 PRED is the condition used to compare LHS and the RHS.
488 T_LABEL is the label to jump to if the condition is true.
489 F_LABEL is the label to jump to otherwise. */
491 gcond *
492 gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs,
493 tree t_label, tree f_label)
495 gcond *p;
497 gcc_assert (TREE_CODE_CLASS (pred_code) == tcc_comparison);
498 p = as_a <gcond *> (gimple_build_with_ops (GIMPLE_COND, pred_code, 4));
499 gimple_cond_set_lhs (p, lhs);
500 gimple_cond_set_rhs (p, rhs);
501 gimple_cond_set_true_label (p, t_label);
502 gimple_cond_set_false_label (p, f_label);
503 return p;
506 /* Build a GIMPLE_COND statement from the conditional expression tree
507 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
509 gcond *
510 gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
512 enum tree_code code;
513 tree lhs, rhs;
515 gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
516 return gimple_build_cond (code, lhs, rhs, t_label, f_label);
519 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
520 boolean expression tree COND. */
522 void
523 gimple_cond_set_condition_from_tree (gcond *stmt, tree cond)
525 enum tree_code code;
526 tree lhs, rhs;
528 gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
529 gimple_cond_set_condition (stmt, code, lhs, rhs);
532 /* Build a GIMPLE_LABEL statement for LABEL. */
534 glabel *
535 gimple_build_label (tree label)
537 glabel *p
538 = as_a <glabel *> (gimple_build_with_ops (GIMPLE_LABEL, ERROR_MARK, 1));
539 gimple_label_set_label (p, label);
540 return p;
543 /* Build a GIMPLE_GOTO statement to label DEST. */
545 ggoto *
546 gimple_build_goto (tree dest)
548 ggoto *p
549 = as_a <ggoto *> (gimple_build_with_ops (GIMPLE_GOTO, ERROR_MARK, 1));
550 gimple_goto_set_dest (p, dest);
551 return p;
555 /* Build a GIMPLE_NOP statement. */
557 gimple *
558 gimple_build_nop (void)
560 return gimple_alloc (GIMPLE_NOP, 0);
564 /* Build a GIMPLE_BIND statement.
565 VARS are the variables in BODY.
566 BLOCK is the containing block. */
568 gbind *
569 gimple_build_bind (tree vars, gimple_seq body, tree block)
571 gbind *p = as_a <gbind *> (gimple_alloc (GIMPLE_BIND, 0));
572 gimple_bind_set_vars (p, vars);
573 if (body)
574 gimple_bind_set_body (p, body);
575 if (block)
576 gimple_bind_set_block (p, block);
577 return p;
580 /* Helper function to set the simple fields of a asm stmt.
582 STRING is a pointer to a string that is the asm blocks assembly code.
583 NINPUT is the number of register inputs.
584 NOUTPUT is the number of register outputs.
585 NCLOBBERS is the number of clobbered registers.
588 static inline gasm *
589 gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
590 unsigned nclobbers, unsigned nlabels)
592 gasm *p;
593 int size = strlen (string);
595 /* ASMs with labels cannot have outputs. This should have been
596 enforced by the front end. */
597 gcc_assert (nlabels == 0 || noutputs == 0);
599 p = as_a <gasm *> (
600 gimple_build_with_ops (GIMPLE_ASM, ERROR_MARK,
601 ninputs + noutputs + nclobbers + nlabels));
603 p->ni = ninputs;
604 p->no = noutputs;
605 p->nc = nclobbers;
606 p->nl = nlabels;
607 p->string = ggc_alloc_string (string, size);
609 if (GATHER_STATISTICS)
610 gimple_alloc_sizes[(int) gimple_alloc_kind (GIMPLE_ASM)] += size;
612 return p;
615 /* Build a GIMPLE_ASM statement.
617 STRING is the assembly code.
618 NINPUT is the number of register inputs.
619 NOUTPUT is the number of register outputs.
620 NCLOBBERS is the number of clobbered registers.
621 INPUTS is a vector of the input register parameters.
622 OUTPUTS is a vector of the output register parameters.
623 CLOBBERS is a vector of the clobbered register parameters.
624 LABELS is a vector of destination labels. */
626 gasm *
627 gimple_build_asm_vec (const char *string, vec<tree, va_gc> *inputs,
628 vec<tree, va_gc> *outputs, vec<tree, va_gc> *clobbers,
629 vec<tree, va_gc> *labels)
631 gasm *p;
632 unsigned i;
634 p = gimple_build_asm_1 (string,
635 vec_safe_length (inputs),
636 vec_safe_length (outputs),
637 vec_safe_length (clobbers),
638 vec_safe_length (labels));
640 for (i = 0; i < vec_safe_length (inputs); i++)
641 gimple_asm_set_input_op (p, i, (*inputs)[i]);
643 for (i = 0; i < vec_safe_length (outputs); i++)
644 gimple_asm_set_output_op (p, i, (*outputs)[i]);
646 for (i = 0; i < vec_safe_length (clobbers); i++)
647 gimple_asm_set_clobber_op (p, i, (*clobbers)[i]);
649 for (i = 0; i < vec_safe_length (labels); i++)
650 gimple_asm_set_label_op (p, i, (*labels)[i]);
652 return p;
655 /* Build a GIMPLE_CATCH statement.
657 TYPES are the catch types.
658 HANDLER is the exception handler. */
660 gcatch *
661 gimple_build_catch (tree types, gimple_seq handler)
663 gcatch *p = as_a <gcatch *> (gimple_alloc (GIMPLE_CATCH, 0));
664 gimple_catch_set_types (p, types);
665 if (handler)
666 gimple_catch_set_handler (p, handler);
668 return p;
671 /* Build a GIMPLE_EH_FILTER statement.
673 TYPES are the filter's types.
674 FAILURE is the filter's failure action. */
676 geh_filter *
677 gimple_build_eh_filter (tree types, gimple_seq failure)
679 geh_filter *p = as_a <geh_filter *> (gimple_alloc (GIMPLE_EH_FILTER, 0));
680 gimple_eh_filter_set_types (p, types);
681 if (failure)
682 gimple_eh_filter_set_failure (p, failure);
684 return p;
687 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
689 geh_mnt *
690 gimple_build_eh_must_not_throw (tree decl)
692 geh_mnt *p = as_a <geh_mnt *> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW, 0));
694 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
695 gcc_assert (flags_from_decl_or_type (decl) & ECF_NORETURN);
696 gimple_eh_must_not_throw_set_fndecl (p, decl);
698 return p;
701 /* Build a GIMPLE_EH_ELSE statement. */
703 geh_else *
704 gimple_build_eh_else (gimple_seq n_body, gimple_seq e_body)
706 geh_else *p = as_a <geh_else *> (gimple_alloc (GIMPLE_EH_ELSE, 0));
707 gimple_eh_else_set_n_body (p, n_body);
708 gimple_eh_else_set_e_body (p, e_body);
709 return p;
712 /* Build a GIMPLE_TRY statement.
714 EVAL is the expression to evaluate.
715 CLEANUP is the cleanup expression.
716 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
717 whether this is a try/catch or a try/finally respectively. */
719 gtry *
720 gimple_build_try (gimple_seq eval, gimple_seq cleanup,
721 enum gimple_try_flags kind)
723 gtry *p;
725 gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
726 p = as_a <gtry *> (gimple_alloc (GIMPLE_TRY, 0));
727 gimple_set_subcode (p, kind);
728 if (eval)
729 gimple_try_set_eval (p, eval);
730 if (cleanup)
731 gimple_try_set_cleanup (p, cleanup);
733 return p;
736 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
738 CLEANUP is the cleanup expression. */
740 gimple *
741 gimple_build_wce (gimple_seq cleanup)
743 gimple *p = gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR, 0);
744 if (cleanup)
745 gimple_wce_set_cleanup (p, cleanup);
747 return p;
751 /* Build a GIMPLE_RESX statement. */
753 gresx *
754 gimple_build_resx (int region)
756 gresx *p
757 = as_a <gresx *> (gimple_build_with_ops (GIMPLE_RESX, ERROR_MARK, 0));
758 p->region = region;
759 return p;
763 /* The helper for constructing a gimple switch statement.
764 INDEX is the switch's index.
765 NLABELS is the number of labels in the switch excluding the default.
766 DEFAULT_LABEL is the default label for the switch statement. */
768 gswitch *
769 gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
771 /* nlabels + 1 default label + 1 index. */
772 gcc_checking_assert (default_label);
773 gswitch *p = as_a <gswitch *> (gimple_build_with_ops (GIMPLE_SWITCH,
774 ERROR_MARK,
775 1 + 1 + nlabels));
776 gimple_switch_set_index (p, index);
777 gimple_switch_set_default_label (p, default_label);
778 return p;
781 /* Build a GIMPLE_SWITCH statement.
783 INDEX is the switch's index.
784 DEFAULT_LABEL is the default label
785 ARGS is a vector of labels excluding the default. */
787 gswitch *
788 gimple_build_switch (tree index, tree default_label, vec<tree> args)
790 unsigned i, nlabels = args.length ();
792 gswitch *p = gimple_build_switch_nlabels (nlabels, index, default_label);
794 /* Copy the labels from the vector to the switch statement. */
795 for (i = 0; i < nlabels; i++)
796 gimple_switch_set_label (p, i + 1, args[i]);
798 return p;
801 /* Build a GIMPLE_EH_DISPATCH statement. */
803 geh_dispatch *
804 gimple_build_eh_dispatch (int region)
806 geh_dispatch *p
807 = as_a <geh_dispatch *> (
808 gimple_build_with_ops (GIMPLE_EH_DISPATCH, ERROR_MARK, 0));
809 p->region = region;
810 return p;
813 /* Build a new GIMPLE_DEBUG_BIND statement.
815 VAR is bound to VALUE; block and location are taken from STMT. */
817 gdebug *
818 gimple_build_debug_bind (tree var, tree value, gimple *stmt MEM_STAT_DECL)
820 gdebug *p
821 = as_a <gdebug *> (gimple_build_with_ops_stat (GIMPLE_DEBUG,
822 (unsigned)GIMPLE_DEBUG_BIND, 2
823 PASS_MEM_STAT));
824 gimple_debug_bind_set_var (p, var);
825 gimple_debug_bind_set_value (p, value);
826 if (stmt)
827 gimple_set_location (p, gimple_location (stmt));
829 return p;
833 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
835 VAR is bound to VALUE; block and location are taken from STMT. */
837 gdebug *
838 gimple_build_debug_source_bind (tree var, tree value,
839 gimple *stmt MEM_STAT_DECL)
841 gdebug *p
842 = as_a <gdebug *> (
843 gimple_build_with_ops_stat (GIMPLE_DEBUG,
844 (unsigned)GIMPLE_DEBUG_SOURCE_BIND, 2
845 PASS_MEM_STAT));
847 gimple_debug_source_bind_set_var (p, var);
848 gimple_debug_source_bind_set_value (p, value);
849 if (stmt)
850 gimple_set_location (p, gimple_location (stmt));
852 return p;
856 /* Build a new GIMPLE_DEBUG_BEGIN_STMT statement in BLOCK at
857 LOCATION. */
859 gdebug *
860 gimple_build_debug_begin_stmt (tree block, location_t location
861 MEM_STAT_DECL)
863 gdebug *p
864 = as_a <gdebug *> (
865 gimple_build_with_ops_stat (GIMPLE_DEBUG,
866 (unsigned)GIMPLE_DEBUG_BEGIN_STMT, 0
867 PASS_MEM_STAT));
869 gimple_set_location (p, location);
870 gimple_set_block (p, block);
871 cfun->debug_marker_count++;
873 return p;
877 /* Build a GIMPLE_OMP_CRITICAL statement.
879 BODY is the sequence of statements for which only one thread can execute.
880 NAME is optional identifier for this critical block.
881 CLAUSES are clauses for this critical block. */
883 gomp_critical *
884 gimple_build_omp_critical (gimple_seq body, tree name, tree clauses)
886 gomp_critical *p
887 = as_a <gomp_critical *> (gimple_alloc (GIMPLE_OMP_CRITICAL, 0));
888 gimple_omp_critical_set_name (p, name);
889 gimple_omp_critical_set_clauses (p, clauses);
890 if (body)
891 gimple_omp_set_body (p, body);
893 return p;
896 /* Build a GIMPLE_OMP_FOR statement.
898 BODY is sequence of statements inside the for loop.
899 KIND is the `for' variant.
900 CLAUSES, are any of the construct's clauses.
901 COLLAPSE is the collapse count.
902 PRE_BODY is the sequence of statements that are loop invariant. */
904 gomp_for *
905 gimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse,
906 gimple_seq pre_body)
908 gomp_for *p = as_a <gomp_for *> (gimple_alloc (GIMPLE_OMP_FOR, 0));
909 if (body)
910 gimple_omp_set_body (p, body);
911 gimple_omp_for_set_clauses (p, clauses);
912 gimple_omp_for_set_kind (p, kind);
913 p->collapse = collapse;
914 p->iter = ggc_cleared_vec_alloc<gimple_omp_for_iter> (collapse);
916 if (pre_body)
917 gimple_omp_for_set_pre_body (p, pre_body);
919 return p;
923 /* Build a GIMPLE_OMP_PARALLEL statement.
925 BODY is sequence of statements which are executed in parallel.
926 CLAUSES, are the OMP parallel construct's clauses.
927 CHILD_FN is the function created for the parallel threads to execute.
928 DATA_ARG are the shared data argument(s). */
930 gomp_parallel *
931 gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
932 tree data_arg)
934 gomp_parallel *p
935 = as_a <gomp_parallel *> (gimple_alloc (GIMPLE_OMP_PARALLEL, 0));
936 if (body)
937 gimple_omp_set_body (p, body);
938 gimple_omp_parallel_set_clauses (p, clauses);
939 gimple_omp_parallel_set_child_fn (p, child_fn);
940 gimple_omp_parallel_set_data_arg (p, data_arg);
942 return p;
946 /* Build a GIMPLE_OMP_TASK statement.
948 BODY is sequence of statements which are executed by the explicit task.
949 CLAUSES, are the OMP parallel construct's clauses.
950 CHILD_FN is the function created for the parallel threads to execute.
951 DATA_ARG are the shared data argument(s).
952 COPY_FN is the optional function for firstprivate initialization.
953 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
955 gomp_task *
956 gimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn,
957 tree data_arg, tree copy_fn, tree arg_size,
958 tree arg_align)
960 gomp_task *p = as_a <gomp_task *> (gimple_alloc (GIMPLE_OMP_TASK, 0));
961 if (body)
962 gimple_omp_set_body (p, body);
963 gimple_omp_task_set_clauses (p, clauses);
964 gimple_omp_task_set_child_fn (p, child_fn);
965 gimple_omp_task_set_data_arg (p, data_arg);
966 gimple_omp_task_set_copy_fn (p, copy_fn);
967 gimple_omp_task_set_arg_size (p, arg_size);
968 gimple_omp_task_set_arg_align (p, arg_align);
970 return p;
974 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
976 BODY is the sequence of statements in the section. */
978 gimple *
979 gimple_build_omp_section (gimple_seq body)
981 gimple *p = gimple_alloc (GIMPLE_OMP_SECTION, 0);
982 if (body)
983 gimple_omp_set_body (p, body);
985 return p;
989 /* Build a GIMPLE_OMP_MASTER statement.
991 BODY is the sequence of statements to be executed by just the master. */
993 gimple *
994 gimple_build_omp_master (gimple_seq body)
996 gimple *p = gimple_alloc (GIMPLE_OMP_MASTER, 0);
997 if (body)
998 gimple_omp_set_body (p, body);
1000 return p;
1003 /* Build a GIMPLE_OMP_GRID_BODY statement.
1005 BODY is the sequence of statements to be executed by the kernel. */
1007 gimple *
1008 gimple_build_omp_grid_body (gimple_seq body)
1010 gimple *p = gimple_alloc (GIMPLE_OMP_GRID_BODY, 0);
1011 if (body)
1012 gimple_omp_set_body (p, body);
1014 return p;
1017 /* Build a GIMPLE_OMP_TASKGROUP statement.
1019 BODY is the sequence of statements to be executed by the taskgroup
1020 construct. */
1022 gimple *
1023 gimple_build_omp_taskgroup (gimple_seq body)
1025 gimple *p = gimple_alloc (GIMPLE_OMP_TASKGROUP, 0);
1026 if (body)
1027 gimple_omp_set_body (p, body);
1029 return p;
1033 /* Build a GIMPLE_OMP_CONTINUE statement.
1035 CONTROL_DEF is the definition of the control variable.
1036 CONTROL_USE is the use of the control variable. */
1038 gomp_continue *
1039 gimple_build_omp_continue (tree control_def, tree control_use)
1041 gomp_continue *p
1042 = as_a <gomp_continue *> (gimple_alloc (GIMPLE_OMP_CONTINUE, 0));
1043 gimple_omp_continue_set_control_def (p, control_def);
1044 gimple_omp_continue_set_control_use (p, control_use);
1045 return p;
1048 /* Build a GIMPLE_OMP_ORDERED statement.
1050 BODY is the sequence of statements inside a loop that will executed in
1051 sequence.
1052 CLAUSES are clauses for this statement. */
1054 gomp_ordered *
1055 gimple_build_omp_ordered (gimple_seq body, tree clauses)
1057 gomp_ordered *p
1058 = as_a <gomp_ordered *> (gimple_alloc (GIMPLE_OMP_ORDERED, 0));
1059 gimple_omp_ordered_set_clauses (p, clauses);
1060 if (body)
1061 gimple_omp_set_body (p, body);
1063 return p;
1067 /* Build a GIMPLE_OMP_RETURN statement.
1068 WAIT_P is true if this is a non-waiting return. */
1070 gimple *
1071 gimple_build_omp_return (bool wait_p)
1073 gimple *p = gimple_alloc (GIMPLE_OMP_RETURN, 0);
1074 if (wait_p)
1075 gimple_omp_return_set_nowait (p);
1077 return p;
1081 /* Build a GIMPLE_OMP_SECTIONS statement.
1083 BODY is a sequence of section statements.
1084 CLAUSES are any of the OMP sections contsruct's clauses: private,
1085 firstprivate, lastprivate, reduction, and nowait. */
1087 gomp_sections *
1088 gimple_build_omp_sections (gimple_seq body, tree clauses)
1090 gomp_sections *p
1091 = as_a <gomp_sections *> (gimple_alloc (GIMPLE_OMP_SECTIONS, 0));
1092 if (body)
1093 gimple_omp_set_body (p, body);
1094 gimple_omp_sections_set_clauses (p, clauses);
1096 return p;
1100 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1102 gimple *
1103 gimple_build_omp_sections_switch (void)
1105 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH, 0);
1109 /* Build a GIMPLE_OMP_SINGLE statement.
1111 BODY is the sequence of statements that will be executed once.
1112 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1113 copyprivate, nowait. */
1115 gomp_single *
1116 gimple_build_omp_single (gimple_seq body, tree clauses)
1118 gomp_single *p
1119 = as_a <gomp_single *> (gimple_alloc (GIMPLE_OMP_SINGLE, 0));
1120 if (body)
1121 gimple_omp_set_body (p, body);
1122 gimple_omp_single_set_clauses (p, clauses);
1124 return p;
1128 /* Build a GIMPLE_OMP_TARGET statement.
1130 BODY is the sequence of statements that will be executed.
1131 KIND is the kind of the region.
1132 CLAUSES are any of the construct's clauses. */
1134 gomp_target *
1135 gimple_build_omp_target (gimple_seq body, int kind, tree clauses)
1137 gomp_target *p
1138 = as_a <gomp_target *> (gimple_alloc (GIMPLE_OMP_TARGET, 0));
1139 if (body)
1140 gimple_omp_set_body (p, body);
1141 gimple_omp_target_set_clauses (p, clauses);
1142 gimple_omp_target_set_kind (p, kind);
1144 return p;
1148 /* Build a GIMPLE_OMP_TEAMS statement.
1150 BODY is the sequence of statements that will be executed.
1151 CLAUSES are any of the OMP teams construct's clauses. */
1153 gomp_teams *
1154 gimple_build_omp_teams (gimple_seq body, tree clauses)
1156 gomp_teams *p = as_a <gomp_teams *> (gimple_alloc (GIMPLE_OMP_TEAMS, 0));
1157 if (body)
1158 gimple_omp_set_body (p, body);
1159 gimple_omp_teams_set_clauses (p, clauses);
1161 return p;
1165 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1167 gomp_atomic_load *
1168 gimple_build_omp_atomic_load (tree lhs, tree rhs)
1170 gomp_atomic_load *p
1171 = as_a <gomp_atomic_load *> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0));
1172 gimple_omp_atomic_load_set_lhs (p, lhs);
1173 gimple_omp_atomic_load_set_rhs (p, rhs);
1174 return p;
1177 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1179 VAL is the value we are storing. */
1181 gomp_atomic_store *
1182 gimple_build_omp_atomic_store (tree val)
1184 gomp_atomic_store *p
1185 = as_a <gomp_atomic_store *> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE, 0));
1186 gimple_omp_atomic_store_set_val (p, val);
1187 return p;
1190 /* Build a GIMPLE_TRANSACTION statement. */
1192 gtransaction *
1193 gimple_build_transaction (gimple_seq body)
1195 gtransaction *p
1196 = as_a <gtransaction *> (gimple_alloc (GIMPLE_TRANSACTION, 0));
1197 gimple_transaction_set_body (p, body);
1198 gimple_transaction_set_label_norm (p, 0);
1199 gimple_transaction_set_label_uninst (p, 0);
1200 gimple_transaction_set_label_over (p, 0);
1201 return p;
1204 #if defined ENABLE_GIMPLE_CHECKING
1205 /* Complain of a gimple type mismatch and die. */
1207 void
1208 gimple_check_failed (const gimple *gs, const char *file, int line,
1209 const char *function, enum gimple_code code,
1210 enum tree_code subcode)
1212 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1213 gimple_code_name[code],
1214 get_tree_code_name (subcode),
1215 gimple_code_name[gimple_code (gs)],
1216 gs->subcode > 0
1217 ? get_tree_code_name ((enum tree_code) gs->subcode)
1218 : "",
1219 function, trim_filename (file), line);
1221 #endif /* ENABLE_GIMPLE_CHECKING */
1224 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1225 *SEQ_P is NULL, a new sequence is allocated. */
1227 void
1228 gimple_seq_add_stmt (gimple_seq *seq_p, gimple *gs)
1230 gimple_stmt_iterator si;
1231 if (gs == NULL)
1232 return;
1234 si = gsi_last (*seq_p);
1235 gsi_insert_after (&si, gs, GSI_NEW_STMT);
1238 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1239 *SEQ_P is NULL, a new sequence is allocated. This function is
1240 similar to gimple_seq_add_stmt, but does not scan the operands.
1241 During gimplification, we need to manipulate statement sequences
1242 before the def/use vectors have been constructed. */
1244 void
1245 gimple_seq_add_stmt_without_update (gimple_seq *seq_p, gimple *gs)
1247 gimple_stmt_iterator si;
1249 if (gs == NULL)
1250 return;
1252 si = gsi_last (*seq_p);
1253 gsi_insert_after_without_update (&si, gs, GSI_NEW_STMT);
1256 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1257 NULL, a new sequence is allocated. */
1259 void
1260 gimple_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
1262 gimple_stmt_iterator si;
1263 if (src == NULL)
1264 return;
1266 si = gsi_last (*dst_p);
1267 gsi_insert_seq_after (&si, src, GSI_NEW_STMT);
1270 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1271 NULL, a new sequence is allocated. This function is
1272 similar to gimple_seq_add_seq, but does not scan the operands. */
1274 void
1275 gimple_seq_add_seq_without_update (gimple_seq *dst_p, gimple_seq src)
1277 gimple_stmt_iterator si;
1278 if (src == NULL)
1279 return;
1281 si = gsi_last (*dst_p);
1282 gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
1285 /* Determine whether to assign a location to the statement GS. */
1287 static bool
1288 should_carry_location_p (gimple *gs)
1290 /* Don't emit a line note for a label. We particularly don't want to
1291 emit one for the break label, since it doesn't actually correspond
1292 to the beginning of the loop/switch. */
1293 if (gimple_code (gs) == GIMPLE_LABEL)
1294 return false;
1296 return true;
1299 /* Set the location for gimple statement GS to LOCATION. */
1301 static void
1302 annotate_one_with_location (gimple *gs, location_t location)
1304 if (!gimple_has_location (gs)
1305 && !gimple_do_not_emit_location_p (gs)
1306 && should_carry_location_p (gs))
1307 gimple_set_location (gs, location);
1310 /* Set LOCATION for all the statements after iterator GSI in sequence
1311 SEQ. If GSI is pointing to the end of the sequence, start with the
1312 first statement in SEQ. */
1314 void
1315 annotate_all_with_location_after (gimple_seq seq, gimple_stmt_iterator gsi,
1316 location_t location)
1318 if (gsi_end_p (gsi))
1319 gsi = gsi_start (seq);
1320 else
1321 gsi_next (&gsi);
1323 for (; !gsi_end_p (gsi); gsi_next (&gsi))
1324 annotate_one_with_location (gsi_stmt (gsi), location);
1327 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1329 void
1330 annotate_all_with_location (gimple_seq stmt_p, location_t location)
1332 gimple_stmt_iterator i;
1334 if (gimple_seq_empty_p (stmt_p))
1335 return;
1337 for (i = gsi_start (stmt_p); !gsi_end_p (i); gsi_next (&i))
1339 gimple *gs = gsi_stmt (i);
1340 annotate_one_with_location (gs, location);
1344 /* Helper function of empty_body_p. Return true if STMT is an empty
1345 statement. */
1347 static bool
1348 empty_stmt_p (gimple *stmt)
1350 if (gimple_code (stmt) == GIMPLE_NOP)
1351 return true;
1352 if (gbind *bind_stmt = dyn_cast <gbind *> (stmt))
1353 return empty_body_p (gimple_bind_body (bind_stmt));
1354 return false;
1358 /* Return true if BODY contains nothing but empty statements. */
1360 bool
1361 empty_body_p (gimple_seq body)
1363 gimple_stmt_iterator i;
1365 if (gimple_seq_empty_p (body))
1366 return true;
1367 for (i = gsi_start (body); !gsi_end_p (i); gsi_next (&i))
1368 if (!empty_stmt_p (gsi_stmt (i))
1369 && !is_gimple_debug (gsi_stmt (i)))
1370 return false;
1372 return true;
1376 /* Perform a deep copy of sequence SRC and return the result. */
1378 gimple_seq
1379 gimple_seq_copy (gimple_seq src)
1381 gimple_stmt_iterator gsi;
1382 gimple_seq new_seq = NULL;
1383 gimple *stmt;
1385 for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi))
1387 stmt = gimple_copy (gsi_stmt (gsi));
1388 gimple_seq_add_stmt (&new_seq, stmt);
1391 return new_seq;
1396 /* Return true if calls C1 and C2 are known to go to the same function. */
1398 bool
1399 gimple_call_same_target_p (const gimple *c1, const gimple *c2)
1401 if (gimple_call_internal_p (c1))
1402 return (gimple_call_internal_p (c2)
1403 && gimple_call_internal_fn (c1) == gimple_call_internal_fn (c2)
1404 && (!gimple_call_internal_unique_p (as_a <const gcall *> (c1))
1405 || c1 == c2));
1406 else
1407 return (gimple_call_fn (c1) == gimple_call_fn (c2)
1408 || (gimple_call_fndecl (c1)
1409 && gimple_call_fndecl (c1) == gimple_call_fndecl (c2)));
1412 /* Detect flags from a GIMPLE_CALL. This is just like
1413 call_expr_flags, but for gimple tuples. */
1416 gimple_call_flags (const gimple *stmt)
1418 int flags;
1419 tree decl = gimple_call_fndecl (stmt);
1421 if (decl)
1422 flags = flags_from_decl_or_type (decl);
1423 else if (gimple_call_internal_p (stmt))
1424 flags = internal_fn_flags (gimple_call_internal_fn (stmt));
1425 else
1426 flags = flags_from_decl_or_type (gimple_call_fntype (stmt));
1428 if (stmt->subcode & GF_CALL_NOTHROW)
1429 flags |= ECF_NOTHROW;
1431 if (stmt->subcode & GF_CALL_BY_DESCRIPTOR)
1432 flags |= ECF_BY_DESCRIPTOR;
1434 return flags;
1437 /* Return the "fn spec" string for call STMT. */
1439 static const_tree
1440 gimple_call_fnspec (const gcall *stmt)
1442 tree type, attr;
1444 if (gimple_call_internal_p (stmt))
1445 return internal_fn_fnspec (gimple_call_internal_fn (stmt));
1447 type = gimple_call_fntype (stmt);
1448 if (!type)
1449 return NULL_TREE;
1451 attr = lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type));
1452 if (!attr)
1453 return NULL_TREE;
1455 return TREE_VALUE (TREE_VALUE (attr));
1458 /* Detects argument flags for argument number ARG on call STMT. */
1461 gimple_call_arg_flags (const gcall *stmt, unsigned arg)
1463 const_tree attr = gimple_call_fnspec (stmt);
1465 if (!attr || 1 + arg >= (unsigned) TREE_STRING_LENGTH (attr))
1466 return 0;
1468 switch (TREE_STRING_POINTER (attr)[1 + arg])
1470 case 'x':
1471 case 'X':
1472 return EAF_UNUSED;
1474 case 'R':
1475 return EAF_DIRECT | EAF_NOCLOBBER | EAF_NOESCAPE;
1477 case 'r':
1478 return EAF_NOCLOBBER | EAF_NOESCAPE;
1480 case 'W':
1481 return EAF_DIRECT | EAF_NOESCAPE;
1483 case 'w':
1484 return EAF_NOESCAPE;
1486 case '.':
1487 default:
1488 return 0;
1492 /* Detects return flags for the call STMT. */
1495 gimple_call_return_flags (const gcall *stmt)
1497 const_tree attr;
1499 if (gimple_call_flags (stmt) & ECF_MALLOC)
1500 return ERF_NOALIAS;
1502 attr = gimple_call_fnspec (stmt);
1503 if (!attr || TREE_STRING_LENGTH (attr) < 1)
1504 return 0;
1506 switch (TREE_STRING_POINTER (attr)[0])
1508 case '1':
1509 case '2':
1510 case '3':
1511 case '4':
1512 return ERF_RETURNS_ARG | (TREE_STRING_POINTER (attr)[0] - '1');
1514 case 'm':
1515 return ERF_NOALIAS;
1517 case '.':
1518 default:
1519 return 0;
1524 /* Return true if GS is a copy assignment. */
1526 bool
1527 gimple_assign_copy_p (gimple *gs)
1529 return (gimple_assign_single_p (gs)
1530 && is_gimple_val (gimple_op (gs, 1)));
1534 /* Return true if GS is a SSA_NAME copy assignment. */
1536 bool
1537 gimple_assign_ssa_name_copy_p (gimple *gs)
1539 return (gimple_assign_single_p (gs)
1540 && TREE_CODE (gimple_assign_lhs (gs)) == SSA_NAME
1541 && TREE_CODE (gimple_assign_rhs1 (gs)) == SSA_NAME);
1545 /* Return true if GS is an assignment with a unary RHS, but the
1546 operator has no effect on the assigned value. The logic is adapted
1547 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1548 instances in which STRIP_NOPS was previously applied to the RHS of
1549 an assignment.
1551 NOTE: In the use cases that led to the creation of this function
1552 and of gimple_assign_single_p, it is typical to test for either
1553 condition and to proceed in the same manner. In each case, the
1554 assigned value is represented by the single RHS operand of the
1555 assignment. I suspect there may be cases where gimple_assign_copy_p,
1556 gimple_assign_single_p, or equivalent logic is used where a similar
1557 treatment of unary NOPs is appropriate. */
1559 bool
1560 gimple_assign_unary_nop_p (gimple *gs)
1562 return (is_gimple_assign (gs)
1563 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
1564 || gimple_assign_rhs_code (gs) == NON_LVALUE_EXPR)
1565 && gimple_assign_rhs1 (gs) != error_mark_node
1566 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs)))
1567 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs)))));
1570 /* Set BB to be the basic block holding G. */
1572 void
1573 gimple_set_bb (gimple *stmt, basic_block bb)
1575 stmt->bb = bb;
1577 if (gimple_code (stmt) != GIMPLE_LABEL)
1578 return;
1580 /* If the statement is a label, add the label to block-to-labels map
1581 so that we can speed up edge creation for GIMPLE_GOTOs. */
1582 if (cfun->cfg)
1584 tree t;
1585 int uid;
1587 t = gimple_label_label (as_a <glabel *> (stmt));
1588 uid = LABEL_DECL_UID (t);
1589 if (uid == -1)
1591 unsigned old_len =
1592 vec_safe_length (label_to_block_map_for_fn (cfun));
1593 LABEL_DECL_UID (t) = uid = cfun->cfg->last_label_uid++;
1594 if (old_len <= (unsigned) uid)
1596 unsigned new_len = 3 * uid / 2 + 1;
1598 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun),
1599 new_len);
1603 (*label_to_block_map_for_fn (cfun))[uid] = bb;
1608 /* Modify the RHS of the assignment pointed-to by GSI using the
1609 operands in the expression tree EXPR.
1611 NOTE: The statement pointed-to by GSI may be reallocated if it
1612 did not have enough operand slots.
1614 This function is useful to convert an existing tree expression into
1615 the flat representation used for the RHS of a GIMPLE assignment.
1616 It will reallocate memory as needed to expand or shrink the number
1617 of operand slots needed to represent EXPR.
1619 NOTE: If you find yourself building a tree and then calling this
1620 function, you are most certainly doing it the slow way. It is much
1621 better to build a new assignment or to use the function
1622 gimple_assign_set_rhs_with_ops, which does not require an
1623 expression tree to be built. */
1625 void
1626 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *gsi, tree expr)
1628 enum tree_code subcode;
1629 tree op1, op2, op3;
1631 extract_ops_from_tree (expr, &subcode, &op1, &op2, &op3);
1632 gimple_assign_set_rhs_with_ops (gsi, subcode, op1, op2, op3);
1636 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1637 operands OP1, OP2 and OP3.
1639 NOTE: The statement pointed-to by GSI may be reallocated if it
1640 did not have enough operand slots. */
1642 void
1643 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
1644 tree op1, tree op2, tree op3)
1646 unsigned new_rhs_ops = get_gimple_rhs_num_ops (code);
1647 gimple *stmt = gsi_stmt (*gsi);
1649 /* If the new CODE needs more operands, allocate a new statement. */
1650 if (gimple_num_ops (stmt) < new_rhs_ops + 1)
1652 tree lhs = gimple_assign_lhs (stmt);
1653 gimple *new_stmt = gimple_alloc (gimple_code (stmt), new_rhs_ops + 1);
1654 memcpy (new_stmt, stmt, gimple_size (gimple_code (stmt)));
1655 gimple_init_singleton (new_stmt);
1656 gsi_replace (gsi, new_stmt, false);
1657 stmt = new_stmt;
1659 /* The LHS needs to be reset as this also changes the SSA name
1660 on the LHS. */
1661 gimple_assign_set_lhs (stmt, lhs);
1664 gimple_set_num_ops (stmt, new_rhs_ops + 1);
1665 gimple_set_subcode (stmt, code);
1666 gimple_assign_set_rhs1 (stmt, op1);
1667 if (new_rhs_ops > 1)
1668 gimple_assign_set_rhs2 (stmt, op2);
1669 if (new_rhs_ops > 2)
1670 gimple_assign_set_rhs3 (stmt, op3);
1674 /* Return the LHS of a statement that performs an assignment,
1675 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1676 for a call to a function that returns no value, or for a
1677 statement other than an assignment or a call. */
1679 tree
1680 gimple_get_lhs (const gimple *stmt)
1682 enum gimple_code code = gimple_code (stmt);
1684 if (code == GIMPLE_ASSIGN)
1685 return gimple_assign_lhs (stmt);
1686 else if (code == GIMPLE_CALL)
1687 return gimple_call_lhs (stmt);
1688 else
1689 return NULL_TREE;
1693 /* Set the LHS of a statement that performs an assignment,
1694 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1696 void
1697 gimple_set_lhs (gimple *stmt, tree lhs)
1699 enum gimple_code code = gimple_code (stmt);
1701 if (code == GIMPLE_ASSIGN)
1702 gimple_assign_set_lhs (stmt, lhs);
1703 else if (code == GIMPLE_CALL)
1704 gimple_call_set_lhs (stmt, lhs);
1705 else
1706 gcc_unreachable ();
1710 /* Return a deep copy of statement STMT. All the operands from STMT
1711 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1712 and VUSE operand arrays are set to empty in the new copy. The new
1713 copy isn't part of any sequence. */
1715 gimple *
1716 gimple_copy (gimple *stmt)
1718 enum gimple_code code = gimple_code (stmt);
1719 unsigned num_ops = gimple_num_ops (stmt);
1720 gimple *copy = gimple_alloc (code, num_ops);
1721 unsigned i;
1723 /* Shallow copy all the fields from STMT. */
1724 memcpy (copy, stmt, gimple_size (code));
1725 gimple_init_singleton (copy);
1727 /* If STMT has sub-statements, deep-copy them as well. */
1728 if (gimple_has_substatements (stmt))
1730 gimple_seq new_seq;
1731 tree t;
1733 switch (gimple_code (stmt))
1735 case GIMPLE_BIND:
1737 gbind *bind_stmt = as_a <gbind *> (stmt);
1738 gbind *bind_copy = as_a <gbind *> (copy);
1739 new_seq = gimple_seq_copy (gimple_bind_body (bind_stmt));
1740 gimple_bind_set_body (bind_copy, new_seq);
1741 gimple_bind_set_vars (bind_copy,
1742 unshare_expr (gimple_bind_vars (bind_stmt)));
1743 gimple_bind_set_block (bind_copy, gimple_bind_block (bind_stmt));
1745 break;
1747 case GIMPLE_CATCH:
1749 gcatch *catch_stmt = as_a <gcatch *> (stmt);
1750 gcatch *catch_copy = as_a <gcatch *> (copy);
1751 new_seq = gimple_seq_copy (gimple_catch_handler (catch_stmt));
1752 gimple_catch_set_handler (catch_copy, new_seq);
1753 t = unshare_expr (gimple_catch_types (catch_stmt));
1754 gimple_catch_set_types (catch_copy, t);
1756 break;
1758 case GIMPLE_EH_FILTER:
1760 geh_filter *eh_filter_stmt = as_a <geh_filter *> (stmt);
1761 geh_filter *eh_filter_copy = as_a <geh_filter *> (copy);
1762 new_seq
1763 = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt));
1764 gimple_eh_filter_set_failure (eh_filter_copy, new_seq);
1765 t = unshare_expr (gimple_eh_filter_types (eh_filter_stmt));
1766 gimple_eh_filter_set_types (eh_filter_copy, t);
1768 break;
1770 case GIMPLE_EH_ELSE:
1772 geh_else *eh_else_stmt = as_a <geh_else *> (stmt);
1773 geh_else *eh_else_copy = as_a <geh_else *> (copy);
1774 new_seq = gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt));
1775 gimple_eh_else_set_n_body (eh_else_copy, new_seq);
1776 new_seq = gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt));
1777 gimple_eh_else_set_e_body (eh_else_copy, new_seq);
1779 break;
1781 case GIMPLE_TRY:
1783 gtry *try_stmt = as_a <gtry *> (stmt);
1784 gtry *try_copy = as_a <gtry *> (copy);
1785 new_seq = gimple_seq_copy (gimple_try_eval (try_stmt));
1786 gimple_try_set_eval (try_copy, new_seq);
1787 new_seq = gimple_seq_copy (gimple_try_cleanup (try_stmt));
1788 gimple_try_set_cleanup (try_copy, new_seq);
1790 break;
1792 case GIMPLE_OMP_FOR:
1793 new_seq = gimple_seq_copy (gimple_omp_for_pre_body (stmt));
1794 gimple_omp_for_set_pre_body (copy, new_seq);
1795 t = unshare_expr (gimple_omp_for_clauses (stmt));
1796 gimple_omp_for_set_clauses (copy, t);
1798 gomp_for *omp_for_copy = as_a <gomp_for *> (copy);
1799 omp_for_copy->iter = ggc_vec_alloc<gimple_omp_for_iter>
1800 ( gimple_omp_for_collapse (stmt));
1802 for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
1804 gimple_omp_for_set_cond (copy, i,
1805 gimple_omp_for_cond (stmt, i));
1806 gimple_omp_for_set_index (copy, i,
1807 gimple_omp_for_index (stmt, i));
1808 t = unshare_expr (gimple_omp_for_initial (stmt, i));
1809 gimple_omp_for_set_initial (copy, i, t);
1810 t = unshare_expr (gimple_omp_for_final (stmt, i));
1811 gimple_omp_for_set_final (copy, i, t);
1812 t = unshare_expr (gimple_omp_for_incr (stmt, i));
1813 gimple_omp_for_set_incr (copy, i, t);
1815 goto copy_omp_body;
1817 case GIMPLE_OMP_PARALLEL:
1819 gomp_parallel *omp_par_stmt = as_a <gomp_parallel *> (stmt);
1820 gomp_parallel *omp_par_copy = as_a <gomp_parallel *> (copy);
1821 t = unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt));
1822 gimple_omp_parallel_set_clauses (omp_par_copy, t);
1823 t = unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt));
1824 gimple_omp_parallel_set_child_fn (omp_par_copy, t);
1825 t = unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt));
1826 gimple_omp_parallel_set_data_arg (omp_par_copy, t);
1828 goto copy_omp_body;
1830 case GIMPLE_OMP_TASK:
1831 t = unshare_expr (gimple_omp_task_clauses (stmt));
1832 gimple_omp_task_set_clauses (copy, t);
1833 t = unshare_expr (gimple_omp_task_child_fn (stmt));
1834 gimple_omp_task_set_child_fn (copy, t);
1835 t = unshare_expr (gimple_omp_task_data_arg (stmt));
1836 gimple_omp_task_set_data_arg (copy, t);
1837 t = unshare_expr (gimple_omp_task_copy_fn (stmt));
1838 gimple_omp_task_set_copy_fn (copy, t);
1839 t = unshare_expr (gimple_omp_task_arg_size (stmt));
1840 gimple_omp_task_set_arg_size (copy, t);
1841 t = unshare_expr (gimple_omp_task_arg_align (stmt));
1842 gimple_omp_task_set_arg_align (copy, t);
1843 goto copy_omp_body;
1845 case GIMPLE_OMP_CRITICAL:
1846 t = unshare_expr (gimple_omp_critical_name
1847 (as_a <gomp_critical *> (stmt)));
1848 gimple_omp_critical_set_name (as_a <gomp_critical *> (copy), t);
1849 t = unshare_expr (gimple_omp_critical_clauses
1850 (as_a <gomp_critical *> (stmt)));
1851 gimple_omp_critical_set_clauses (as_a <gomp_critical *> (copy), t);
1852 goto copy_omp_body;
1854 case GIMPLE_OMP_ORDERED:
1855 t = unshare_expr (gimple_omp_ordered_clauses
1856 (as_a <gomp_ordered *> (stmt)));
1857 gimple_omp_ordered_set_clauses (as_a <gomp_ordered *> (copy), t);
1858 goto copy_omp_body;
1860 case GIMPLE_OMP_SECTIONS:
1861 t = unshare_expr (gimple_omp_sections_clauses (stmt));
1862 gimple_omp_sections_set_clauses (copy, t);
1863 t = unshare_expr (gimple_omp_sections_control (stmt));
1864 gimple_omp_sections_set_control (copy, t);
1865 goto copy_omp_body;
1867 case GIMPLE_OMP_SINGLE:
1869 gomp_single *omp_single_copy = as_a <gomp_single *> (copy);
1870 t = unshare_expr (gimple_omp_single_clauses (stmt));
1871 gimple_omp_single_set_clauses (omp_single_copy, t);
1873 goto copy_omp_body;
1875 case GIMPLE_OMP_TARGET:
1877 gomp_target *omp_target_stmt = as_a <gomp_target *> (stmt);
1878 gomp_target *omp_target_copy = as_a <gomp_target *> (copy);
1879 t = unshare_expr (gimple_omp_target_clauses (omp_target_stmt));
1880 gimple_omp_target_set_clauses (omp_target_copy, t);
1881 t = unshare_expr (gimple_omp_target_data_arg (omp_target_stmt));
1882 gimple_omp_target_set_data_arg (omp_target_copy, t);
1884 goto copy_omp_body;
1886 case GIMPLE_OMP_TEAMS:
1888 gomp_teams *omp_teams_copy = as_a <gomp_teams *> (copy);
1889 t = unshare_expr (gimple_omp_teams_clauses (stmt));
1890 gimple_omp_teams_set_clauses (omp_teams_copy, t);
1892 /* FALLTHRU */
1894 case GIMPLE_OMP_SECTION:
1895 case GIMPLE_OMP_MASTER:
1896 case GIMPLE_OMP_TASKGROUP:
1897 case GIMPLE_OMP_GRID_BODY:
1898 copy_omp_body:
1899 new_seq = gimple_seq_copy (gimple_omp_body (stmt));
1900 gimple_omp_set_body (copy, new_seq);
1901 break;
1903 case GIMPLE_TRANSACTION:
1904 new_seq = gimple_seq_copy (gimple_transaction_body (
1905 as_a <gtransaction *> (stmt)));
1906 gimple_transaction_set_body (as_a <gtransaction *> (copy),
1907 new_seq);
1908 break;
1910 case GIMPLE_WITH_CLEANUP_EXPR:
1911 new_seq = gimple_seq_copy (gimple_wce_cleanup (stmt));
1912 gimple_wce_set_cleanup (copy, new_seq);
1913 break;
1915 default:
1916 gcc_unreachable ();
1920 /* Make copy of operands. */
1921 for (i = 0; i < num_ops; i++)
1922 gimple_set_op (copy, i, unshare_expr (gimple_op (stmt, i)));
1924 if (gimple_has_mem_ops (stmt))
1926 gimple_set_vdef (copy, gimple_vdef (stmt));
1927 gimple_set_vuse (copy, gimple_vuse (stmt));
1930 /* Clear out SSA operand vectors on COPY. */
1931 if (gimple_has_ops (stmt))
1933 gimple_set_use_ops (copy, NULL);
1935 /* SSA operands need to be updated. */
1936 gimple_set_modified (copy, true);
1939 if (gimple_debug_nonbind_marker_p (stmt))
1940 cfun->debug_marker_count++;
1942 return copy;
1946 /* Return true if statement S has side-effects. We consider a
1947 statement to have side effects if:
1949 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
1950 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
1952 bool
1953 gimple_has_side_effects (const gimple *s)
1955 if (is_gimple_debug (s))
1956 return false;
1958 /* We don't have to scan the arguments to check for
1959 volatile arguments, though, at present, we still
1960 do a scan to check for TREE_SIDE_EFFECTS. */
1961 if (gimple_has_volatile_ops (s))
1962 return true;
1964 if (gimple_code (s) == GIMPLE_ASM
1965 && gimple_asm_volatile_p (as_a <const gasm *> (s)))
1966 return true;
1968 if (is_gimple_call (s))
1970 int flags = gimple_call_flags (s);
1972 /* An infinite loop is considered a side effect. */
1973 if (!(flags & (ECF_CONST | ECF_PURE))
1974 || (flags & ECF_LOOPING_CONST_OR_PURE))
1975 return true;
1977 return false;
1980 return false;
1983 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
1984 Return true if S can trap. When INCLUDE_MEM is true, check whether
1985 the memory operations could trap. When INCLUDE_STORES is true and
1986 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
1988 bool
1989 gimple_could_trap_p_1 (gimple *s, bool include_mem, bool include_stores)
1991 tree t, div = NULL_TREE;
1992 enum tree_code op;
1994 if (include_mem)
1996 unsigned i, start = (is_gimple_assign (s) && !include_stores) ? 1 : 0;
1998 for (i = start; i < gimple_num_ops (s); i++)
1999 if (tree_could_trap_p (gimple_op (s, i)))
2000 return true;
2003 switch (gimple_code (s))
2005 case GIMPLE_ASM:
2006 return gimple_asm_volatile_p (as_a <gasm *> (s));
2008 case GIMPLE_CALL:
2009 t = gimple_call_fndecl (s);
2010 /* Assume that calls to weak functions may trap. */
2011 if (!t || !DECL_P (t) || DECL_WEAK (t))
2012 return true;
2013 return false;
2015 case GIMPLE_ASSIGN:
2016 t = gimple_expr_type (s);
2017 op = gimple_assign_rhs_code (s);
2018 if (get_gimple_rhs_class (op) == GIMPLE_BINARY_RHS)
2019 div = gimple_assign_rhs2 (s);
2020 return (operation_could_trap_p (op, FLOAT_TYPE_P (t),
2021 (INTEGRAL_TYPE_P (t)
2022 && TYPE_OVERFLOW_TRAPS (t)),
2023 div));
2025 case GIMPLE_COND:
2026 t = TREE_TYPE (gimple_cond_lhs (s));
2027 return operation_could_trap_p (gimple_cond_code (s),
2028 FLOAT_TYPE_P (t), false, NULL_TREE);
2030 default:
2031 break;
2034 return false;
2037 /* Return true if statement S can trap. */
2039 bool
2040 gimple_could_trap_p (gimple *s)
2042 return gimple_could_trap_p_1 (s, true, true);
2045 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
2047 bool
2048 gimple_assign_rhs_could_trap_p (gimple *s)
2050 gcc_assert (is_gimple_assign (s));
2051 return gimple_could_trap_p_1 (s, true, false);
2055 /* Print debugging information for gimple stmts generated. */
2057 void
2058 dump_gimple_statistics (void)
2060 int i;
2061 uint64_t total_tuples = 0, total_bytes = 0;
2063 if (! GATHER_STATISTICS)
2065 fprintf (stderr, "No GIMPLE statistics\n");
2066 return;
2069 fprintf (stderr, "\nGIMPLE statements\n");
2070 fprintf (stderr, "Kind Stmts Bytes\n");
2071 fprintf (stderr, "---------------------------------------\n");
2072 for (i = 0; i < (int) gimple_alloc_kind_all; ++i)
2074 fprintf (stderr, "%-20s %7" PRIu64 " %10" PRIu64 "\n",
2075 gimple_alloc_kind_names[i], gimple_alloc_counts[i],
2076 gimple_alloc_sizes[i]);
2077 total_tuples += gimple_alloc_counts[i];
2078 total_bytes += gimple_alloc_sizes[i];
2080 fprintf (stderr, "---------------------------------------\n");
2081 fprintf (stderr, "%-20s %7" PRIu64 " %10" PRIu64 "\n", "Total",
2082 total_tuples, total_bytes);
2083 fprintf (stderr, "---------------------------------------\n");
2087 /* Return the number of operands needed on the RHS of a GIMPLE
2088 assignment for an expression with tree code CODE. */
2090 unsigned
2091 get_gimple_rhs_num_ops (enum tree_code code)
2093 enum gimple_rhs_class rhs_class = get_gimple_rhs_class (code);
2095 if (rhs_class == GIMPLE_UNARY_RHS || rhs_class == GIMPLE_SINGLE_RHS)
2096 return 1;
2097 else if (rhs_class == GIMPLE_BINARY_RHS)
2098 return 2;
2099 else if (rhs_class == GIMPLE_TERNARY_RHS)
2100 return 3;
2101 else
2102 gcc_unreachable ();
2105 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2106 (unsigned char) \
2107 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2108 : ((TYPE) == tcc_binary \
2109 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2110 : ((TYPE) == tcc_constant \
2111 || (TYPE) == tcc_declaration \
2112 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2113 : ((SYM) == TRUTH_AND_EXPR \
2114 || (SYM) == TRUTH_OR_EXPR \
2115 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2116 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2117 : ((SYM) == COND_EXPR \
2118 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2119 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2120 || (SYM) == DOT_PROD_EXPR \
2121 || (SYM) == SAD_EXPR \
2122 || (SYM) == REALIGN_LOAD_EXPR \
2123 || (SYM) == VEC_COND_EXPR \
2124 || (SYM) == VEC_PERM_EXPR \
2125 || (SYM) == BIT_INSERT_EXPR \
2126 || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS \
2127 : ((SYM) == CONSTRUCTOR \
2128 || (SYM) == OBJ_TYPE_REF \
2129 || (SYM) == ASSERT_EXPR \
2130 || (SYM) == ADDR_EXPR \
2131 || (SYM) == WITH_SIZE_EXPR \
2132 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2133 : GIMPLE_INVALID_RHS),
2134 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2136 const unsigned char gimple_rhs_class_table[] = {
2137 #include "all-tree.def"
2140 #undef DEFTREECODE
2141 #undef END_OF_BASE_TREE_CODES
2143 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2144 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2145 we failed to create one. */
2147 tree
2148 canonicalize_cond_expr_cond (tree t)
2150 /* Strip conversions around boolean operations. */
2151 if (CONVERT_EXPR_P (t)
2152 && (truth_value_p (TREE_CODE (TREE_OPERAND (t, 0)))
2153 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0)))
2154 == BOOLEAN_TYPE))
2155 t = TREE_OPERAND (t, 0);
2157 /* For !x use x == 0. */
2158 if (TREE_CODE (t) == TRUTH_NOT_EXPR)
2160 tree top0 = TREE_OPERAND (t, 0);
2161 t = build2 (EQ_EXPR, TREE_TYPE (t),
2162 top0, build_int_cst (TREE_TYPE (top0), 0));
2164 /* For cmp ? 1 : 0 use cmp. */
2165 else if (TREE_CODE (t) == COND_EXPR
2166 && COMPARISON_CLASS_P (TREE_OPERAND (t, 0))
2167 && integer_onep (TREE_OPERAND (t, 1))
2168 && integer_zerop (TREE_OPERAND (t, 2)))
2170 tree top0 = TREE_OPERAND (t, 0);
2171 t = build2 (TREE_CODE (top0), TREE_TYPE (t),
2172 TREE_OPERAND (top0, 0), TREE_OPERAND (top0, 1));
2174 /* For x ^ y use x != y. */
2175 else if (TREE_CODE (t) == BIT_XOR_EXPR)
2176 t = build2 (NE_EXPR, TREE_TYPE (t),
2177 TREE_OPERAND (t, 0), TREE_OPERAND (t, 1));
2179 if (is_gimple_condexpr (t))
2180 return t;
2182 return NULL_TREE;
2185 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2186 the positions marked by the set ARGS_TO_SKIP. */
2188 gcall *
2189 gimple_call_copy_skip_args (gcall *stmt, bitmap args_to_skip)
2191 int i;
2192 int nargs = gimple_call_num_args (stmt);
2193 auto_vec<tree> vargs (nargs);
2194 gcall *new_stmt;
2196 for (i = 0; i < nargs; i++)
2197 if (!bitmap_bit_p (args_to_skip, i))
2198 vargs.quick_push (gimple_call_arg (stmt, i));
2200 if (gimple_call_internal_p (stmt))
2201 new_stmt = gimple_build_call_internal_vec (gimple_call_internal_fn (stmt),
2202 vargs);
2203 else
2204 new_stmt = gimple_build_call_vec (gimple_call_fn (stmt), vargs);
2206 if (gimple_call_lhs (stmt))
2207 gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
2209 gimple_set_vuse (new_stmt, gimple_vuse (stmt));
2210 gimple_set_vdef (new_stmt, gimple_vdef (stmt));
2212 if (gimple_has_location (stmt))
2213 gimple_set_location (new_stmt, gimple_location (stmt));
2214 gimple_call_copy_flags (new_stmt, stmt);
2215 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
2217 gimple_set_modified (new_stmt, true);
2219 return new_stmt;
2224 /* Return true if the field decls F1 and F2 are at the same offset.
2226 This is intended to be used on GIMPLE types only. */
2228 bool
2229 gimple_compare_field_offset (tree f1, tree f2)
2231 if (DECL_OFFSET_ALIGN (f1) == DECL_OFFSET_ALIGN (f2))
2233 tree offset1 = DECL_FIELD_OFFSET (f1);
2234 tree offset2 = DECL_FIELD_OFFSET (f2);
2235 return ((offset1 == offset2
2236 /* Once gimplification is done, self-referential offsets are
2237 instantiated as operand #2 of the COMPONENT_REF built for
2238 each access and reset. Therefore, they are not relevant
2239 anymore and fields are interchangeable provided that they
2240 represent the same access. */
2241 || (TREE_CODE (offset1) == PLACEHOLDER_EXPR
2242 && TREE_CODE (offset2) == PLACEHOLDER_EXPR
2243 && (DECL_SIZE (f1) == DECL_SIZE (f2)
2244 || (TREE_CODE (DECL_SIZE (f1)) == PLACEHOLDER_EXPR
2245 && TREE_CODE (DECL_SIZE (f2)) == PLACEHOLDER_EXPR)
2246 || operand_equal_p (DECL_SIZE (f1), DECL_SIZE (f2), 0))
2247 && DECL_ALIGN (f1) == DECL_ALIGN (f2))
2248 || operand_equal_p (offset1, offset2, 0))
2249 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1),
2250 DECL_FIELD_BIT_OFFSET (f2)));
2253 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2254 should be, so handle differing ones specially by decomposing
2255 the offset into a byte and bit offset manually. */
2256 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1))
2257 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2)))
2259 unsigned HOST_WIDE_INT byte_offset1, byte_offset2;
2260 unsigned HOST_WIDE_INT bit_offset1, bit_offset2;
2261 bit_offset1 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1));
2262 byte_offset1 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1))
2263 + bit_offset1 / BITS_PER_UNIT);
2264 bit_offset2 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2));
2265 byte_offset2 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2))
2266 + bit_offset2 / BITS_PER_UNIT);
2267 if (byte_offset1 != byte_offset2)
2268 return false;
2269 return bit_offset1 % BITS_PER_UNIT == bit_offset2 % BITS_PER_UNIT;
2272 return false;
2276 /* Return a type the same as TYPE except unsigned or
2277 signed according to UNSIGNEDP. */
2279 static tree
2280 gimple_signed_or_unsigned_type (bool unsignedp, tree type)
2282 tree type1;
2283 int i;
2285 type1 = TYPE_MAIN_VARIANT (type);
2286 if (type1 == signed_char_type_node
2287 || type1 == char_type_node
2288 || type1 == unsigned_char_type_node)
2289 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2290 if (type1 == integer_type_node || type1 == unsigned_type_node)
2291 return unsignedp ? unsigned_type_node : integer_type_node;
2292 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
2293 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2294 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
2295 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2296 if (type1 == long_long_integer_type_node
2297 || type1 == long_long_unsigned_type_node)
2298 return unsignedp
2299 ? long_long_unsigned_type_node
2300 : long_long_integer_type_node;
2302 for (i = 0; i < NUM_INT_N_ENTS; i ++)
2303 if (int_n_enabled_p[i]
2304 && (type1 == int_n_trees[i].unsigned_type
2305 || type1 == int_n_trees[i].signed_type))
2306 return unsignedp
2307 ? int_n_trees[i].unsigned_type
2308 : int_n_trees[i].signed_type;
2310 #if HOST_BITS_PER_WIDE_INT >= 64
2311 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
2312 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2313 #endif
2314 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
2315 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2316 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
2317 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2318 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
2319 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2320 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
2321 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2323 #define GIMPLE_FIXED_TYPES(NAME) \
2324 if (type1 == short_ ## NAME ## _type_node \
2325 || type1 == unsigned_short_ ## NAME ## _type_node) \
2326 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2327 : short_ ## NAME ## _type_node; \
2328 if (type1 == NAME ## _type_node \
2329 || type1 == unsigned_ ## NAME ## _type_node) \
2330 return unsignedp ? unsigned_ ## NAME ## _type_node \
2331 : NAME ## _type_node; \
2332 if (type1 == long_ ## NAME ## _type_node \
2333 || type1 == unsigned_long_ ## NAME ## _type_node) \
2334 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2335 : long_ ## NAME ## _type_node; \
2336 if (type1 == long_long_ ## NAME ## _type_node \
2337 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2338 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2339 : long_long_ ## NAME ## _type_node;
2341 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2342 if (type1 == NAME ## _type_node \
2343 || type1 == u ## NAME ## _type_node) \
2344 return unsignedp ? u ## NAME ## _type_node \
2345 : NAME ## _type_node;
2347 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2348 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2349 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2350 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2351 : sat_ ## short_ ## NAME ## _type_node; \
2352 if (type1 == sat_ ## NAME ## _type_node \
2353 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2354 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2355 : sat_ ## NAME ## _type_node; \
2356 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2357 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2358 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2359 : sat_ ## long_ ## NAME ## _type_node; \
2360 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2361 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2362 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2363 : sat_ ## long_long_ ## NAME ## _type_node;
2365 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2366 if (type1 == sat_ ## NAME ## _type_node \
2367 || type1 == sat_ ## u ## NAME ## _type_node) \
2368 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2369 : sat_ ## NAME ## _type_node;
2371 GIMPLE_FIXED_TYPES (fract);
2372 GIMPLE_FIXED_TYPES_SAT (fract);
2373 GIMPLE_FIXED_TYPES (accum);
2374 GIMPLE_FIXED_TYPES_SAT (accum);
2376 GIMPLE_FIXED_MODE_TYPES (qq);
2377 GIMPLE_FIXED_MODE_TYPES (hq);
2378 GIMPLE_FIXED_MODE_TYPES (sq);
2379 GIMPLE_FIXED_MODE_TYPES (dq);
2380 GIMPLE_FIXED_MODE_TYPES (tq);
2381 GIMPLE_FIXED_MODE_TYPES_SAT (qq);
2382 GIMPLE_FIXED_MODE_TYPES_SAT (hq);
2383 GIMPLE_FIXED_MODE_TYPES_SAT (sq);
2384 GIMPLE_FIXED_MODE_TYPES_SAT (dq);
2385 GIMPLE_FIXED_MODE_TYPES_SAT (tq);
2386 GIMPLE_FIXED_MODE_TYPES (ha);
2387 GIMPLE_FIXED_MODE_TYPES (sa);
2388 GIMPLE_FIXED_MODE_TYPES (da);
2389 GIMPLE_FIXED_MODE_TYPES (ta);
2390 GIMPLE_FIXED_MODE_TYPES_SAT (ha);
2391 GIMPLE_FIXED_MODE_TYPES_SAT (sa);
2392 GIMPLE_FIXED_MODE_TYPES_SAT (da);
2393 GIMPLE_FIXED_MODE_TYPES_SAT (ta);
2395 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2396 the precision; they have precision set to match their range, but
2397 may use a wider mode to match an ABI. If we change modes, we may
2398 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2399 the precision as well, so as to yield correct results for
2400 bit-field types. C++ does not have these separate bit-field
2401 types, and producing a signed or unsigned variant of an
2402 ENUMERAL_TYPE may cause other problems as well. */
2403 if (!INTEGRAL_TYPE_P (type)
2404 || TYPE_UNSIGNED (type) == unsignedp)
2405 return type;
2407 #define TYPE_OK(node) \
2408 (TYPE_MODE (type) == TYPE_MODE (node) \
2409 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2410 if (TYPE_OK (signed_char_type_node))
2411 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2412 if (TYPE_OK (integer_type_node))
2413 return unsignedp ? unsigned_type_node : integer_type_node;
2414 if (TYPE_OK (short_integer_type_node))
2415 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2416 if (TYPE_OK (long_integer_type_node))
2417 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2418 if (TYPE_OK (long_long_integer_type_node))
2419 return (unsignedp
2420 ? long_long_unsigned_type_node
2421 : long_long_integer_type_node);
2423 for (i = 0; i < NUM_INT_N_ENTS; i ++)
2424 if (int_n_enabled_p[i]
2425 && TYPE_MODE (type) == int_n_data[i].m
2426 && TYPE_PRECISION (type) == int_n_data[i].bitsize)
2427 return unsignedp
2428 ? int_n_trees[i].unsigned_type
2429 : int_n_trees[i].signed_type;
2431 #if HOST_BITS_PER_WIDE_INT >= 64
2432 if (TYPE_OK (intTI_type_node))
2433 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2434 #endif
2435 if (TYPE_OK (intDI_type_node))
2436 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2437 if (TYPE_OK (intSI_type_node))
2438 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2439 if (TYPE_OK (intHI_type_node))
2440 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2441 if (TYPE_OK (intQI_type_node))
2442 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2444 #undef GIMPLE_FIXED_TYPES
2445 #undef GIMPLE_FIXED_MODE_TYPES
2446 #undef GIMPLE_FIXED_TYPES_SAT
2447 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2448 #undef TYPE_OK
2450 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2454 /* Return an unsigned type the same as TYPE in other respects. */
2456 tree
2457 gimple_unsigned_type (tree type)
2459 return gimple_signed_or_unsigned_type (true, type);
2463 /* Return a signed type the same as TYPE in other respects. */
2465 tree
2466 gimple_signed_type (tree type)
2468 return gimple_signed_or_unsigned_type (false, type);
2472 /* Return the typed-based alias set for T, which may be an expression
2473 or a type. Return -1 if we don't do anything special. */
2475 alias_set_type
2476 gimple_get_alias_set (tree t)
2478 /* That's all the expressions we handle specially. */
2479 if (!TYPE_P (t))
2480 return -1;
2482 /* For convenience, follow the C standard when dealing with
2483 character types. Any object may be accessed via an lvalue that
2484 has character type. */
2485 if (t == char_type_node
2486 || t == signed_char_type_node
2487 || t == unsigned_char_type_node)
2488 return 0;
2490 /* Allow aliasing between signed and unsigned variants of the same
2491 type. We treat the signed variant as canonical. */
2492 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2494 tree t1 = gimple_signed_type (t);
2496 /* t1 == t can happen for boolean nodes which are always unsigned. */
2497 if (t1 != t)
2498 return get_alias_set (t1);
2501 return -1;
2505 /* Helper for gimple_ior_addresses_taken_1. */
2507 static bool
2508 gimple_ior_addresses_taken_1 (gimple *, tree addr, tree, void *data)
2510 bitmap addresses_taken = (bitmap)data;
2511 addr = get_base_address (addr);
2512 if (addr
2513 && DECL_P (addr))
2515 bitmap_set_bit (addresses_taken, DECL_UID (addr));
2516 return true;
2518 return false;
2521 /* Set the bit for the uid of all decls that have their address taken
2522 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2523 were any in this stmt. */
2525 bool
2526 gimple_ior_addresses_taken (bitmap addresses_taken, gimple *stmt)
2528 return walk_stmt_load_store_addr_ops (stmt, addresses_taken, NULL, NULL,
2529 gimple_ior_addresses_taken_1);
2533 /* Return true when STMTs arguments and return value match those of FNDECL,
2534 a decl of a builtin function. */
2536 bool
2537 gimple_builtin_call_types_compatible_p (const gimple *stmt, tree fndecl)
2539 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN);
2541 tree ret = gimple_call_lhs (stmt);
2542 if (ret
2543 && !useless_type_conversion_p (TREE_TYPE (ret),
2544 TREE_TYPE (TREE_TYPE (fndecl))))
2545 return false;
2547 tree targs = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2548 unsigned nargs = gimple_call_num_args (stmt);
2549 for (unsigned i = 0; i < nargs; ++i)
2551 /* Variadic args follow. */
2552 if (!targs)
2553 return true;
2554 tree arg = gimple_call_arg (stmt, i);
2555 tree type = TREE_VALUE (targs);
2556 if (!useless_type_conversion_p (type, TREE_TYPE (arg))
2557 /* char/short integral arguments are promoted to int
2558 by several frontends if targetm.calls.promote_prototypes
2559 is true. Allow such promotion too. */
2560 && !(INTEGRAL_TYPE_P (type)
2561 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
2562 && targetm.calls.promote_prototypes (TREE_TYPE (fndecl))
2563 && useless_type_conversion_p (integer_type_node,
2564 TREE_TYPE (arg))))
2565 return false;
2566 targs = TREE_CHAIN (targs);
2568 if (targs && !VOID_TYPE_P (TREE_VALUE (targs)))
2569 return false;
2570 return true;
2573 /* Return true when STMT is builtins call. */
2575 bool
2576 gimple_call_builtin_p (const gimple *stmt)
2578 tree fndecl;
2579 if (is_gimple_call (stmt)
2580 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2581 && DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN)
2582 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2583 return false;
2586 /* Return true when STMT is builtins call to CLASS. */
2588 bool
2589 gimple_call_builtin_p (const gimple *stmt, enum built_in_class klass)
2591 tree fndecl;
2592 if (is_gimple_call (stmt)
2593 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2594 && DECL_BUILT_IN_CLASS (fndecl) == klass)
2595 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2596 return false;
2599 /* Return true when STMT is builtins call to CODE of CLASS. */
2601 bool
2602 gimple_call_builtin_p (const gimple *stmt, enum built_in_function code)
2604 tree fndecl;
2605 if (is_gimple_call (stmt)
2606 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2607 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
2608 && DECL_FUNCTION_CODE (fndecl) == code)
2609 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2610 return false;
2613 /* If CALL is a call to a combined_fn (i.e. an internal function or
2614 a normal built-in function), return its code, otherwise return
2615 CFN_LAST. */
2617 combined_fn
2618 gimple_call_combined_fn (const gimple *stmt)
2620 if (const gcall *call = dyn_cast <const gcall *> (stmt))
2622 if (gimple_call_internal_p (call))
2623 return as_combined_fn (gimple_call_internal_fn (call));
2625 tree fndecl = gimple_call_fndecl (stmt);
2626 if (fndecl
2627 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
2628 && gimple_builtin_call_types_compatible_p (stmt, fndecl))
2629 return as_combined_fn (DECL_FUNCTION_CODE (fndecl));
2631 return CFN_LAST;
2634 /* Return true if STMT clobbers memory. STMT is required to be a
2635 GIMPLE_ASM. */
2637 bool
2638 gimple_asm_clobbers_memory_p (const gasm *stmt)
2640 unsigned i;
2642 for (i = 0; i < gimple_asm_nclobbers (stmt); i++)
2644 tree op = gimple_asm_clobber_op (stmt, i);
2645 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op)), "memory") == 0)
2646 return true;
2649 /* Non-empty basic ASM implicitly clobbers memory. */
2650 if (gimple_asm_input_p (stmt) && strlen (gimple_asm_string (stmt)) != 0)
2651 return true;
2653 return false;
2656 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2658 void
2659 dump_decl_set (FILE *file, bitmap set)
2661 if (set)
2663 bitmap_iterator bi;
2664 unsigned i;
2666 fprintf (file, "{ ");
2668 EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi)
2670 fprintf (file, "D.%u", i);
2671 fprintf (file, " ");
2674 fprintf (file, "}");
2676 else
2677 fprintf (file, "NIL");
2680 /* Return true when CALL is a call stmt that definitely doesn't
2681 free any memory or makes it unavailable otherwise. */
2682 bool
2683 nonfreeing_call_p (gimple *call)
2685 if (gimple_call_builtin_p (call, BUILT_IN_NORMAL)
2686 && gimple_call_flags (call) & ECF_LEAF)
2687 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call)))
2689 /* Just in case these become ECF_LEAF in the future. */
2690 case BUILT_IN_FREE:
2691 case BUILT_IN_TM_FREE:
2692 case BUILT_IN_REALLOC:
2693 case BUILT_IN_STACK_RESTORE:
2694 return false;
2695 default:
2696 return true;
2698 else if (gimple_call_internal_p (call))
2699 switch (gimple_call_internal_fn (call))
2701 case IFN_ABNORMAL_DISPATCHER:
2702 return true;
2703 case IFN_ASAN_MARK:
2704 return tree_to_uhwi (gimple_call_arg (call, 0)) == ASAN_MARK_UNPOISON;
2705 default:
2706 if (gimple_call_flags (call) & ECF_LEAF)
2707 return true;
2708 return false;
2711 tree fndecl = gimple_call_fndecl (call);
2712 if (!fndecl)
2713 return false;
2714 struct cgraph_node *n = cgraph_node::get (fndecl);
2715 if (!n)
2716 return false;
2717 enum availability availability;
2718 n = n->function_symbol (&availability);
2719 if (!n || availability <= AVAIL_INTERPOSABLE)
2720 return false;
2721 return n->nonfreeing_fn;
2724 /* Return true when CALL is a call stmt that definitely need not
2725 be considered to be a memory barrier. */
2726 bool
2727 nonbarrier_call_p (gimple *call)
2729 if (gimple_call_flags (call) & (ECF_PURE | ECF_CONST))
2730 return true;
2731 /* Should extend this to have a nonbarrier_fn flag, just as above in
2732 the nonfreeing case. */
2733 return false;
2736 /* Callback for walk_stmt_load_store_ops.
2738 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2739 otherwise.
2741 This routine only makes a superficial check for a dereference. Thus
2742 it must only be used if it is safe to return a false negative. */
2743 static bool
2744 check_loadstore (gimple *, tree op, tree, void *data)
2746 if (TREE_CODE (op) == MEM_REF || TREE_CODE (op) == TARGET_MEM_REF)
2748 /* Some address spaces may legitimately dereference zero. */
2749 addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (op));
2750 if (targetm.addr_space.zero_address_valid (as))
2751 return false;
2753 return operand_equal_p (TREE_OPERAND (op, 0), (tree)data, 0);
2755 return false;
2759 /* Return true if OP can be inferred to be non-NULL after STMT executes,
2760 either by using a pointer dereference or attributes. */
2761 bool
2762 infer_nonnull_range (gimple *stmt, tree op)
2764 return infer_nonnull_range_by_dereference (stmt, op)
2765 || infer_nonnull_range_by_attribute (stmt, op);
2768 /* Return true if OP can be inferred to be non-NULL after STMT
2769 executes by using a pointer dereference. */
2770 bool
2771 infer_nonnull_range_by_dereference (gimple *stmt, tree op)
2773 /* We can only assume that a pointer dereference will yield
2774 non-NULL if -fdelete-null-pointer-checks is enabled. */
2775 if (!flag_delete_null_pointer_checks
2776 || !POINTER_TYPE_P (TREE_TYPE (op))
2777 || gimple_code (stmt) == GIMPLE_ASM)
2778 return false;
2780 if (walk_stmt_load_store_ops (stmt, (void *)op,
2781 check_loadstore, check_loadstore))
2782 return true;
2784 return false;
2787 /* Return true if OP can be inferred to be a non-NULL after STMT
2788 executes by using attributes. */
2789 bool
2790 infer_nonnull_range_by_attribute (gimple *stmt, tree op)
2792 /* We can only assume that a pointer dereference will yield
2793 non-NULL if -fdelete-null-pointer-checks is enabled. */
2794 if (!flag_delete_null_pointer_checks
2795 || !POINTER_TYPE_P (TREE_TYPE (op))
2796 || gimple_code (stmt) == GIMPLE_ASM)
2797 return false;
2799 if (is_gimple_call (stmt) && !gimple_call_internal_p (stmt))
2801 tree fntype = gimple_call_fntype (stmt);
2802 tree attrs = TYPE_ATTRIBUTES (fntype);
2803 for (; attrs; attrs = TREE_CHAIN (attrs))
2805 attrs = lookup_attribute ("nonnull", attrs);
2807 /* If "nonnull" wasn't specified, we know nothing about
2808 the argument. */
2809 if (attrs == NULL_TREE)
2810 return false;
2812 /* If "nonnull" applies to all the arguments, then ARG
2813 is non-null if it's in the argument list. */
2814 if (TREE_VALUE (attrs) == NULL_TREE)
2816 for (unsigned int i = 0; i < gimple_call_num_args (stmt); i++)
2818 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt, i)))
2819 && operand_equal_p (op, gimple_call_arg (stmt, i), 0))
2820 return true;
2822 return false;
2825 /* Now see if op appears in the nonnull list. */
2826 for (tree t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t))
2828 unsigned int idx = TREE_INT_CST_LOW (TREE_VALUE (t)) - 1;
2829 if (idx < gimple_call_num_args (stmt))
2831 tree arg = gimple_call_arg (stmt, idx);
2832 if (operand_equal_p (op, arg, 0))
2833 return true;
2839 /* If this function is marked as returning non-null, then we can
2840 infer OP is non-null if it is used in the return statement. */
2841 if (greturn *return_stmt = dyn_cast <greturn *> (stmt))
2842 if (gimple_return_retval (return_stmt)
2843 && operand_equal_p (gimple_return_retval (return_stmt), op, 0)
2844 && lookup_attribute ("returns_nonnull",
2845 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
2846 return true;
2848 return false;
2851 /* Compare two case labels. Because the front end should already have
2852 made sure that case ranges do not overlap, it is enough to only compare
2853 the CASE_LOW values of each case label. */
2855 static int
2856 compare_case_labels (const void *p1, const void *p2)
2858 const_tree const case1 = *(const_tree const*)p1;
2859 const_tree const case2 = *(const_tree const*)p2;
2861 /* The 'default' case label always goes first. */
2862 if (!CASE_LOW (case1))
2863 return -1;
2864 else if (!CASE_LOW (case2))
2865 return 1;
2866 else
2867 return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
2870 /* Sort the case labels in LABEL_VEC in place in ascending order. */
2872 void
2873 sort_case_labels (vec<tree> label_vec)
2875 label_vec.qsort (compare_case_labels);
2878 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2880 LABELS is a vector that contains all case labels to look at.
2882 INDEX_TYPE is the type of the switch index expression. Case labels
2883 in LABELS are discarded if their values are not in the value range
2884 covered by INDEX_TYPE. The remaining case label values are folded
2885 to INDEX_TYPE.
2887 If a default case exists in LABELS, it is removed from LABELS and
2888 returned in DEFAULT_CASEP. If no default case exists, but the
2889 case labels already cover the whole range of INDEX_TYPE, a default
2890 case is returned pointing to one of the existing case labels.
2891 Otherwise DEFAULT_CASEP is set to NULL_TREE.
2893 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2894 apply and no action is taken regardless of whether a default case is
2895 found or not. */
2897 void
2898 preprocess_case_label_vec_for_gimple (vec<tree> labels,
2899 tree index_type,
2900 tree *default_casep)
2902 tree min_value, max_value;
2903 tree default_case = NULL_TREE;
2904 size_t i, len;
2906 i = 0;
2907 min_value = TYPE_MIN_VALUE (index_type);
2908 max_value = TYPE_MAX_VALUE (index_type);
2909 while (i < labels.length ())
2911 tree elt = labels[i];
2912 tree low = CASE_LOW (elt);
2913 tree high = CASE_HIGH (elt);
2914 bool remove_element = FALSE;
2916 if (low)
2918 gcc_checking_assert (TREE_CODE (low) == INTEGER_CST);
2919 gcc_checking_assert (!high || TREE_CODE (high) == INTEGER_CST);
2921 /* This is a non-default case label, i.e. it has a value.
2923 See if the case label is reachable within the range of
2924 the index type. Remove out-of-range case values. Turn
2925 case ranges into a canonical form (high > low strictly)
2926 and convert the case label values to the index type.
2928 NB: The type of gimple_switch_index() may be the promoted
2929 type, but the case labels retain the original type. */
2931 if (high)
2933 /* This is a case range. Discard empty ranges.
2934 If the bounds or the range are equal, turn this
2935 into a simple (one-value) case. */
2936 int cmp = tree_int_cst_compare (high, low);
2937 if (cmp < 0)
2938 remove_element = TRUE;
2939 else if (cmp == 0)
2940 high = NULL_TREE;
2943 if (! high)
2945 /* If the simple case value is unreachable, ignore it. */
2946 if ((TREE_CODE (min_value) == INTEGER_CST
2947 && tree_int_cst_compare (low, min_value) < 0)
2948 || (TREE_CODE (max_value) == INTEGER_CST
2949 && tree_int_cst_compare (low, max_value) > 0))
2950 remove_element = TRUE;
2951 else
2952 low = fold_convert (index_type, low);
2954 else
2956 /* If the entire case range is unreachable, ignore it. */
2957 if ((TREE_CODE (min_value) == INTEGER_CST
2958 && tree_int_cst_compare (high, min_value) < 0)
2959 || (TREE_CODE (max_value) == INTEGER_CST
2960 && tree_int_cst_compare (low, max_value) > 0))
2961 remove_element = TRUE;
2962 else
2964 /* If the lower bound is less than the index type's
2965 minimum value, truncate the range bounds. */
2966 if (TREE_CODE (min_value) == INTEGER_CST
2967 && tree_int_cst_compare (low, min_value) < 0)
2968 low = min_value;
2969 low = fold_convert (index_type, low);
2971 /* If the upper bound is greater than the index type's
2972 maximum value, truncate the range bounds. */
2973 if (TREE_CODE (max_value) == INTEGER_CST
2974 && tree_int_cst_compare (high, max_value) > 0)
2975 high = max_value;
2976 high = fold_convert (index_type, high);
2978 /* We may have folded a case range to a one-value case. */
2979 if (tree_int_cst_equal (low, high))
2980 high = NULL_TREE;
2984 CASE_LOW (elt) = low;
2985 CASE_HIGH (elt) = high;
2987 else
2989 gcc_assert (!default_case);
2990 default_case = elt;
2991 /* The default case must be passed separately to the
2992 gimple_build_switch routine. But if DEFAULT_CASEP
2993 is NULL, we do not remove the default case (it would
2994 be completely lost). */
2995 if (default_casep)
2996 remove_element = TRUE;
2999 if (remove_element)
3000 labels.ordered_remove (i);
3001 else
3002 i++;
3004 len = i;
3006 if (!labels.is_empty ())
3007 sort_case_labels (labels);
3009 if (default_casep && !default_case)
3011 /* If the switch has no default label, add one, so that we jump
3012 around the switch body. If the labels already cover the whole
3013 range of the switch index_type, add the default label pointing
3014 to one of the existing labels. */
3015 if (len
3016 && TYPE_MIN_VALUE (index_type)
3017 && TYPE_MAX_VALUE (index_type)
3018 && tree_int_cst_equal (CASE_LOW (labels[0]),
3019 TYPE_MIN_VALUE (index_type)))
3021 tree low, high = CASE_HIGH (labels[len - 1]);
3022 if (!high)
3023 high = CASE_LOW (labels[len - 1]);
3024 if (tree_int_cst_equal (high, TYPE_MAX_VALUE (index_type)))
3026 tree widest_label = labels[0];
3027 for (i = 1; i < len; i++)
3029 high = CASE_LOW (labels[i]);
3030 low = CASE_HIGH (labels[i - 1]);
3031 if (!low)
3032 low = CASE_LOW (labels[i - 1]);
3034 if (CASE_HIGH (labels[i]) != NULL_TREE
3035 && (CASE_HIGH (widest_label) == NULL_TREE
3036 || (wi::gtu_p
3037 (wi::to_wide (CASE_HIGH (labels[i]))
3038 - wi::to_wide (CASE_LOW (labels[i])),
3039 wi::to_wide (CASE_HIGH (widest_label))
3040 - wi::to_wide (CASE_LOW (widest_label))))))
3041 widest_label = labels[i];
3043 if (wi::to_wide (low) + 1 != wi::to_wide (high))
3044 break;
3046 if (i == len)
3048 /* Designate the label with the widest range to be the
3049 default label. */
3050 tree label = CASE_LABEL (widest_label);
3051 default_case = build_case_label (NULL_TREE, NULL_TREE,
3052 label);
3058 if (default_casep)
3059 *default_casep = default_case;
3062 /* Set the location of all statements in SEQ to LOC. */
3064 void
3065 gimple_seq_set_location (gimple_seq seq, location_t loc)
3067 for (gimple_stmt_iterator i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
3068 gimple_set_location (gsi_stmt (i), loc);
3071 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
3073 void
3074 gimple_seq_discard (gimple_seq seq)
3076 gimple_stmt_iterator gsi;
3078 for (gsi = gsi_start (seq); !gsi_end_p (gsi); )
3080 gimple *stmt = gsi_stmt (gsi);
3081 gsi_remove (&gsi, true);
3082 release_defs (stmt);
3083 ggc_free (stmt);
3087 /* See if STMT now calls function that takes no parameters and if so, drop
3088 call arguments. This is used when devirtualization machinery redirects
3089 to __builtin_unreachable or __cxa_pure_virtual. */
3091 void
3092 maybe_remove_unused_call_args (struct function *fn, gimple *stmt)
3094 tree decl = gimple_call_fndecl (stmt);
3095 if (TYPE_ARG_TYPES (TREE_TYPE (decl))
3096 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))) == void_type_node
3097 && gimple_call_num_args (stmt))
3099 gimple_set_num_ops (stmt, 3);
3100 update_stmt_fn (fn, stmt);
3104 /* Return false if STMT will likely expand to real function call. */
3106 bool
3107 gimple_inexpensive_call_p (gcall *stmt)
3109 if (gimple_call_internal_p (stmt))
3110 return true;
3111 tree decl = gimple_call_fndecl (stmt);
3112 if (decl && is_inexpensive_builtin (decl))
3113 return true;
3114 return false;
3117 #if CHECKING_P
3119 namespace selftest {
3121 /* Selftests for core gimple structures. */
3123 /* Verify that STMT is pretty-printed as EXPECTED.
3124 Helper function for selftests. */
3126 static void
3127 verify_gimple_pp (const char *expected, gimple *stmt)
3129 pretty_printer pp;
3130 pp_gimple_stmt_1 (&pp, stmt, 0 /* spc */, 0 /* flags */);
3131 ASSERT_STREQ (expected, pp_formatted_text (&pp));
3134 /* Build a GIMPLE_ASSIGN equivalent to
3135 tmp = 5;
3136 and verify various properties of it. */
3138 static void
3139 test_assign_single ()
3141 tree type = integer_type_node;
3142 tree lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3143 get_identifier ("tmp"),
3144 type);
3145 tree rhs = build_int_cst (type, 5);
3146 gassign *stmt = gimple_build_assign (lhs, rhs);
3147 verify_gimple_pp ("tmp = 5;", stmt);
3149 ASSERT_TRUE (is_gimple_assign (stmt));
3150 ASSERT_EQ (lhs, gimple_assign_lhs (stmt));
3151 ASSERT_EQ (lhs, gimple_get_lhs (stmt));
3152 ASSERT_EQ (rhs, gimple_assign_rhs1 (stmt));
3153 ASSERT_EQ (NULL, gimple_assign_rhs2 (stmt));
3154 ASSERT_EQ (NULL, gimple_assign_rhs3 (stmt));
3155 ASSERT_TRUE (gimple_assign_single_p (stmt));
3156 ASSERT_EQ (INTEGER_CST, gimple_assign_rhs_code (stmt));
3159 /* Build a GIMPLE_ASSIGN equivalent to
3160 tmp = a * b;
3161 and verify various properties of it. */
3163 static void
3164 test_assign_binop ()
3166 tree type = integer_type_node;
3167 tree lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3168 get_identifier ("tmp"),
3169 type);
3170 tree a = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3171 get_identifier ("a"),
3172 type);
3173 tree b = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3174 get_identifier ("b"),
3175 type);
3176 gassign *stmt = gimple_build_assign (lhs, MULT_EXPR, a, b);
3177 verify_gimple_pp ("tmp = a * b;", stmt);
3179 ASSERT_TRUE (is_gimple_assign (stmt));
3180 ASSERT_EQ (lhs, gimple_assign_lhs (stmt));
3181 ASSERT_EQ (lhs, gimple_get_lhs (stmt));
3182 ASSERT_EQ (a, gimple_assign_rhs1 (stmt));
3183 ASSERT_EQ (b, gimple_assign_rhs2 (stmt));
3184 ASSERT_EQ (NULL, gimple_assign_rhs3 (stmt));
3185 ASSERT_FALSE (gimple_assign_single_p (stmt));
3186 ASSERT_EQ (MULT_EXPR, gimple_assign_rhs_code (stmt));
3189 /* Build a GIMPLE_NOP and verify various properties of it. */
3191 static void
3192 test_nop_stmt ()
3194 gimple *stmt = gimple_build_nop ();
3195 verify_gimple_pp ("GIMPLE_NOP", stmt);
3196 ASSERT_EQ (GIMPLE_NOP, gimple_code (stmt));
3197 ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3198 ASSERT_FALSE (gimple_assign_single_p (stmt));
3201 /* Build a GIMPLE_RETURN equivalent to
3202 return 7;
3203 and verify various properties of it. */
3205 static void
3206 test_return_stmt ()
3208 tree type = integer_type_node;
3209 tree val = build_int_cst (type, 7);
3210 greturn *stmt = gimple_build_return (val);
3211 verify_gimple_pp ("return 7;", stmt);
3213 ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt));
3214 ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3215 ASSERT_EQ (val, gimple_return_retval (stmt));
3216 ASSERT_FALSE (gimple_assign_single_p (stmt));
3219 /* Build a GIMPLE_RETURN equivalent to
3220 return;
3221 and verify various properties of it. */
3223 static void
3224 test_return_without_value ()
3226 greturn *stmt = gimple_build_return (NULL);
3227 verify_gimple_pp ("return;", stmt);
3229 ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt));
3230 ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3231 ASSERT_EQ (NULL, gimple_return_retval (stmt));
3232 ASSERT_FALSE (gimple_assign_single_p (stmt));
3235 /* Run all of the selftests within this file. */
3237 void
3238 gimple_c_tests ()
3240 test_assign_single ();
3241 test_assign_binop ();
3242 test_nop_stmt ();
3243 test_return_stmt ();
3244 test_return_without_value ();
3247 } // namespace selftest
3250 #endif /* CHECKING_P */