PR middle-end/82875
[official-gcc.git] / gcc / gimple.c
blobc986a73200461d183bffbfc892dc05a0573275ae
1 /* Gimple IR support functions.
3 Copyright (C) 2007-2017 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 int gimple_alloc_counts[(int) gimple_alloc_kind_all];
81 int 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 GIMPLE_OMP_CRITICAL statement.
858 BODY is the sequence of statements for which only one thread can execute.
859 NAME is optional identifier for this critical block.
860 CLAUSES are clauses for this critical block. */
862 gomp_critical *
863 gimple_build_omp_critical (gimple_seq body, tree name, tree clauses)
865 gomp_critical *p
866 = as_a <gomp_critical *> (gimple_alloc (GIMPLE_OMP_CRITICAL, 0));
867 gimple_omp_critical_set_name (p, name);
868 gimple_omp_critical_set_clauses (p, clauses);
869 if (body)
870 gimple_omp_set_body (p, body);
872 return p;
875 /* Build a GIMPLE_OMP_FOR statement.
877 BODY is sequence of statements inside the for loop.
878 KIND is the `for' variant.
879 CLAUSES, are any of the construct's clauses.
880 COLLAPSE is the collapse count.
881 PRE_BODY is the sequence of statements that are loop invariant. */
883 gomp_for *
884 gimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse,
885 gimple_seq pre_body)
887 gomp_for *p = as_a <gomp_for *> (gimple_alloc (GIMPLE_OMP_FOR, 0));
888 if (body)
889 gimple_omp_set_body (p, body);
890 gimple_omp_for_set_clauses (p, clauses);
891 gimple_omp_for_set_kind (p, kind);
892 p->collapse = collapse;
893 p->iter = ggc_cleared_vec_alloc<gimple_omp_for_iter> (collapse);
895 if (pre_body)
896 gimple_omp_for_set_pre_body (p, pre_body);
898 return p;
902 /* Build a GIMPLE_OMP_PARALLEL statement.
904 BODY is sequence of statements which are executed in parallel.
905 CLAUSES, are the OMP parallel construct's clauses.
906 CHILD_FN is the function created for the parallel threads to execute.
907 DATA_ARG are the shared data argument(s). */
909 gomp_parallel *
910 gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
911 tree data_arg)
913 gomp_parallel *p
914 = as_a <gomp_parallel *> (gimple_alloc (GIMPLE_OMP_PARALLEL, 0));
915 if (body)
916 gimple_omp_set_body (p, body);
917 gimple_omp_parallel_set_clauses (p, clauses);
918 gimple_omp_parallel_set_child_fn (p, child_fn);
919 gimple_omp_parallel_set_data_arg (p, data_arg);
921 return p;
925 /* Build a GIMPLE_OMP_TASK statement.
927 BODY is sequence of statements which are executed by the explicit task.
928 CLAUSES, are the OMP parallel construct's clauses.
929 CHILD_FN is the function created for the parallel threads to execute.
930 DATA_ARG are the shared data argument(s).
931 COPY_FN is the optional function for firstprivate initialization.
932 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
934 gomp_task *
935 gimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn,
936 tree data_arg, tree copy_fn, tree arg_size,
937 tree arg_align)
939 gomp_task *p = as_a <gomp_task *> (gimple_alloc (GIMPLE_OMP_TASK, 0));
940 if (body)
941 gimple_omp_set_body (p, body);
942 gimple_omp_task_set_clauses (p, clauses);
943 gimple_omp_task_set_child_fn (p, child_fn);
944 gimple_omp_task_set_data_arg (p, data_arg);
945 gimple_omp_task_set_copy_fn (p, copy_fn);
946 gimple_omp_task_set_arg_size (p, arg_size);
947 gimple_omp_task_set_arg_align (p, arg_align);
949 return p;
953 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
955 BODY is the sequence of statements in the section. */
957 gimple *
958 gimple_build_omp_section (gimple_seq body)
960 gimple *p = gimple_alloc (GIMPLE_OMP_SECTION, 0);
961 if (body)
962 gimple_omp_set_body (p, body);
964 return p;
968 /* Build a GIMPLE_OMP_MASTER statement.
970 BODY is the sequence of statements to be executed by just the master. */
972 gimple *
973 gimple_build_omp_master (gimple_seq body)
975 gimple *p = gimple_alloc (GIMPLE_OMP_MASTER, 0);
976 if (body)
977 gimple_omp_set_body (p, body);
979 return p;
982 /* Build a GIMPLE_OMP_GRID_BODY statement.
984 BODY is the sequence of statements to be executed by the kernel. */
986 gimple *
987 gimple_build_omp_grid_body (gimple_seq body)
989 gimple *p = gimple_alloc (GIMPLE_OMP_GRID_BODY, 0);
990 if (body)
991 gimple_omp_set_body (p, body);
993 return p;
996 /* Build a GIMPLE_OMP_TASKGROUP statement.
998 BODY is the sequence of statements to be executed by the taskgroup
999 construct. */
1001 gimple *
1002 gimple_build_omp_taskgroup (gimple_seq body)
1004 gimple *p = gimple_alloc (GIMPLE_OMP_TASKGROUP, 0);
1005 if (body)
1006 gimple_omp_set_body (p, body);
1008 return p;
1012 /* Build a GIMPLE_OMP_CONTINUE statement.
1014 CONTROL_DEF is the definition of the control variable.
1015 CONTROL_USE is the use of the control variable. */
1017 gomp_continue *
1018 gimple_build_omp_continue (tree control_def, tree control_use)
1020 gomp_continue *p
1021 = as_a <gomp_continue *> (gimple_alloc (GIMPLE_OMP_CONTINUE, 0));
1022 gimple_omp_continue_set_control_def (p, control_def);
1023 gimple_omp_continue_set_control_use (p, control_use);
1024 return p;
1027 /* Build a GIMPLE_OMP_ORDERED statement.
1029 BODY is the sequence of statements inside a loop that will executed in
1030 sequence.
1031 CLAUSES are clauses for this statement. */
1033 gomp_ordered *
1034 gimple_build_omp_ordered (gimple_seq body, tree clauses)
1036 gomp_ordered *p
1037 = as_a <gomp_ordered *> (gimple_alloc (GIMPLE_OMP_ORDERED, 0));
1038 gimple_omp_ordered_set_clauses (p, clauses);
1039 if (body)
1040 gimple_omp_set_body (p, body);
1042 return p;
1046 /* Build a GIMPLE_OMP_RETURN statement.
1047 WAIT_P is true if this is a non-waiting return. */
1049 gimple *
1050 gimple_build_omp_return (bool wait_p)
1052 gimple *p = gimple_alloc (GIMPLE_OMP_RETURN, 0);
1053 if (wait_p)
1054 gimple_omp_return_set_nowait (p);
1056 return p;
1060 /* Build a GIMPLE_OMP_SECTIONS statement.
1062 BODY is a sequence of section statements.
1063 CLAUSES are any of the OMP sections contsruct's clauses: private,
1064 firstprivate, lastprivate, reduction, and nowait. */
1066 gomp_sections *
1067 gimple_build_omp_sections (gimple_seq body, tree clauses)
1069 gomp_sections *p
1070 = as_a <gomp_sections *> (gimple_alloc (GIMPLE_OMP_SECTIONS, 0));
1071 if (body)
1072 gimple_omp_set_body (p, body);
1073 gimple_omp_sections_set_clauses (p, clauses);
1075 return p;
1079 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1081 gimple *
1082 gimple_build_omp_sections_switch (void)
1084 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH, 0);
1088 /* Build a GIMPLE_OMP_SINGLE statement.
1090 BODY is the sequence of statements that will be executed once.
1091 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1092 copyprivate, nowait. */
1094 gomp_single *
1095 gimple_build_omp_single (gimple_seq body, tree clauses)
1097 gomp_single *p
1098 = as_a <gomp_single *> (gimple_alloc (GIMPLE_OMP_SINGLE, 0));
1099 if (body)
1100 gimple_omp_set_body (p, body);
1101 gimple_omp_single_set_clauses (p, clauses);
1103 return p;
1107 /* Build a GIMPLE_OMP_TARGET statement.
1109 BODY is the sequence of statements that will be executed.
1110 KIND is the kind of the region.
1111 CLAUSES are any of the construct's clauses. */
1113 gomp_target *
1114 gimple_build_omp_target (gimple_seq body, int kind, tree clauses)
1116 gomp_target *p
1117 = as_a <gomp_target *> (gimple_alloc (GIMPLE_OMP_TARGET, 0));
1118 if (body)
1119 gimple_omp_set_body (p, body);
1120 gimple_omp_target_set_clauses (p, clauses);
1121 gimple_omp_target_set_kind (p, kind);
1123 return p;
1127 /* Build a GIMPLE_OMP_TEAMS statement.
1129 BODY is the sequence of statements that will be executed.
1130 CLAUSES are any of the OMP teams construct's clauses. */
1132 gomp_teams *
1133 gimple_build_omp_teams (gimple_seq body, tree clauses)
1135 gomp_teams *p = as_a <gomp_teams *> (gimple_alloc (GIMPLE_OMP_TEAMS, 0));
1136 if (body)
1137 gimple_omp_set_body (p, body);
1138 gimple_omp_teams_set_clauses (p, clauses);
1140 return p;
1144 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1146 gomp_atomic_load *
1147 gimple_build_omp_atomic_load (tree lhs, tree rhs)
1149 gomp_atomic_load *p
1150 = as_a <gomp_atomic_load *> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0));
1151 gimple_omp_atomic_load_set_lhs (p, lhs);
1152 gimple_omp_atomic_load_set_rhs (p, rhs);
1153 return p;
1156 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1158 VAL is the value we are storing. */
1160 gomp_atomic_store *
1161 gimple_build_omp_atomic_store (tree val)
1163 gomp_atomic_store *p
1164 = as_a <gomp_atomic_store *> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE, 0));
1165 gimple_omp_atomic_store_set_val (p, val);
1166 return p;
1169 /* Build a GIMPLE_TRANSACTION statement. */
1171 gtransaction *
1172 gimple_build_transaction (gimple_seq body)
1174 gtransaction *p
1175 = as_a <gtransaction *> (gimple_alloc (GIMPLE_TRANSACTION, 0));
1176 gimple_transaction_set_body (p, body);
1177 gimple_transaction_set_label_norm (p, 0);
1178 gimple_transaction_set_label_uninst (p, 0);
1179 gimple_transaction_set_label_over (p, 0);
1180 return p;
1183 #if defined ENABLE_GIMPLE_CHECKING
1184 /* Complain of a gimple type mismatch and die. */
1186 void
1187 gimple_check_failed (const gimple *gs, const char *file, int line,
1188 const char *function, enum gimple_code code,
1189 enum tree_code subcode)
1191 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1192 gimple_code_name[code],
1193 get_tree_code_name (subcode),
1194 gimple_code_name[gimple_code (gs)],
1195 gs->subcode > 0
1196 ? get_tree_code_name ((enum tree_code) gs->subcode)
1197 : "",
1198 function, trim_filename (file), line);
1200 #endif /* ENABLE_GIMPLE_CHECKING */
1203 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1204 *SEQ_P is NULL, a new sequence is allocated. */
1206 void
1207 gimple_seq_add_stmt (gimple_seq *seq_p, gimple *gs)
1209 gimple_stmt_iterator si;
1210 if (gs == NULL)
1211 return;
1213 si = gsi_last (*seq_p);
1214 gsi_insert_after (&si, gs, GSI_NEW_STMT);
1217 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1218 *SEQ_P is NULL, a new sequence is allocated. This function is
1219 similar to gimple_seq_add_stmt, but does not scan the operands.
1220 During gimplification, we need to manipulate statement sequences
1221 before the def/use vectors have been constructed. */
1223 void
1224 gimple_seq_add_stmt_without_update (gimple_seq *seq_p, gimple *gs)
1226 gimple_stmt_iterator si;
1228 if (gs == NULL)
1229 return;
1231 si = gsi_last (*seq_p);
1232 gsi_insert_after_without_update (&si, gs, GSI_NEW_STMT);
1235 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1236 NULL, a new sequence is allocated. */
1238 void
1239 gimple_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
1241 gimple_stmt_iterator si;
1242 if (src == NULL)
1243 return;
1245 si = gsi_last (*dst_p);
1246 gsi_insert_seq_after (&si, src, GSI_NEW_STMT);
1249 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1250 NULL, a new sequence is allocated. This function is
1251 similar to gimple_seq_add_seq, but does not scan the operands. */
1253 void
1254 gimple_seq_add_seq_without_update (gimple_seq *dst_p, gimple_seq src)
1256 gimple_stmt_iterator si;
1257 if (src == NULL)
1258 return;
1260 si = gsi_last (*dst_p);
1261 gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
1264 /* Determine whether to assign a location to the statement GS. */
1266 static bool
1267 should_carry_location_p (gimple *gs)
1269 /* Don't emit a line note for a label. We particularly don't want to
1270 emit one for the break label, since it doesn't actually correspond
1271 to the beginning of the loop/switch. */
1272 if (gimple_code (gs) == GIMPLE_LABEL)
1273 return false;
1275 return true;
1278 /* Set the location for gimple statement GS to LOCATION. */
1280 static void
1281 annotate_one_with_location (gimple *gs, location_t location)
1283 if (!gimple_has_location (gs)
1284 && !gimple_do_not_emit_location_p (gs)
1285 && should_carry_location_p (gs))
1286 gimple_set_location (gs, location);
1289 /* Set LOCATION for all the statements after iterator GSI in sequence
1290 SEQ. If GSI is pointing to the end of the sequence, start with the
1291 first statement in SEQ. */
1293 void
1294 annotate_all_with_location_after (gimple_seq seq, gimple_stmt_iterator gsi,
1295 location_t location)
1297 if (gsi_end_p (gsi))
1298 gsi = gsi_start (seq);
1299 else
1300 gsi_next (&gsi);
1302 for (; !gsi_end_p (gsi); gsi_next (&gsi))
1303 annotate_one_with_location (gsi_stmt (gsi), location);
1306 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1308 void
1309 annotate_all_with_location (gimple_seq stmt_p, location_t location)
1311 gimple_stmt_iterator i;
1313 if (gimple_seq_empty_p (stmt_p))
1314 return;
1316 for (i = gsi_start (stmt_p); !gsi_end_p (i); gsi_next (&i))
1318 gimple *gs = gsi_stmt (i);
1319 annotate_one_with_location (gs, location);
1323 /* Helper function of empty_body_p. Return true if STMT is an empty
1324 statement. */
1326 static bool
1327 empty_stmt_p (gimple *stmt)
1329 if (gimple_code (stmt) == GIMPLE_NOP)
1330 return true;
1331 if (gbind *bind_stmt = dyn_cast <gbind *> (stmt))
1332 return empty_body_p (gimple_bind_body (bind_stmt));
1333 return false;
1337 /* Return true if BODY contains nothing but empty statements. */
1339 bool
1340 empty_body_p (gimple_seq body)
1342 gimple_stmt_iterator i;
1344 if (gimple_seq_empty_p (body))
1345 return true;
1346 for (i = gsi_start (body); !gsi_end_p (i); gsi_next (&i))
1347 if (!empty_stmt_p (gsi_stmt (i))
1348 && !is_gimple_debug (gsi_stmt (i)))
1349 return false;
1351 return true;
1355 /* Perform a deep copy of sequence SRC and return the result. */
1357 gimple_seq
1358 gimple_seq_copy (gimple_seq src)
1360 gimple_stmt_iterator gsi;
1361 gimple_seq new_seq = NULL;
1362 gimple *stmt;
1364 for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi))
1366 stmt = gimple_copy (gsi_stmt (gsi));
1367 gimple_seq_add_stmt (&new_seq, stmt);
1370 return new_seq;
1375 /* Return true if calls C1 and C2 are known to go to the same function. */
1377 bool
1378 gimple_call_same_target_p (const gimple *c1, const gimple *c2)
1380 if (gimple_call_internal_p (c1))
1381 return (gimple_call_internal_p (c2)
1382 && gimple_call_internal_fn (c1) == gimple_call_internal_fn (c2)
1383 && (!gimple_call_internal_unique_p (as_a <const gcall *> (c1))
1384 || c1 == c2));
1385 else
1386 return (gimple_call_fn (c1) == gimple_call_fn (c2)
1387 || (gimple_call_fndecl (c1)
1388 && gimple_call_fndecl (c1) == gimple_call_fndecl (c2)));
1391 /* Detect flags from a GIMPLE_CALL. This is just like
1392 call_expr_flags, but for gimple tuples. */
1395 gimple_call_flags (const gimple *stmt)
1397 int flags;
1398 tree decl = gimple_call_fndecl (stmt);
1400 if (decl)
1401 flags = flags_from_decl_or_type (decl);
1402 else if (gimple_call_internal_p (stmt))
1403 flags = internal_fn_flags (gimple_call_internal_fn (stmt));
1404 else
1405 flags = flags_from_decl_or_type (gimple_call_fntype (stmt));
1407 if (stmt->subcode & GF_CALL_NOTHROW)
1408 flags |= ECF_NOTHROW;
1410 if (stmt->subcode & GF_CALL_BY_DESCRIPTOR)
1411 flags |= ECF_BY_DESCRIPTOR;
1413 return flags;
1416 /* Return the "fn spec" string for call STMT. */
1418 static const_tree
1419 gimple_call_fnspec (const gcall *stmt)
1421 tree type, attr;
1423 if (gimple_call_internal_p (stmt))
1424 return internal_fn_fnspec (gimple_call_internal_fn (stmt));
1426 type = gimple_call_fntype (stmt);
1427 if (!type)
1428 return NULL_TREE;
1430 attr = lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type));
1431 if (!attr)
1432 return NULL_TREE;
1434 return TREE_VALUE (TREE_VALUE (attr));
1437 /* Detects argument flags for argument number ARG on call STMT. */
1440 gimple_call_arg_flags (const gcall *stmt, unsigned arg)
1442 const_tree attr = gimple_call_fnspec (stmt);
1444 if (!attr || 1 + arg >= (unsigned) TREE_STRING_LENGTH (attr))
1445 return 0;
1447 switch (TREE_STRING_POINTER (attr)[1 + arg])
1449 case 'x':
1450 case 'X':
1451 return EAF_UNUSED;
1453 case 'R':
1454 return EAF_DIRECT | EAF_NOCLOBBER | EAF_NOESCAPE;
1456 case 'r':
1457 return EAF_NOCLOBBER | EAF_NOESCAPE;
1459 case 'W':
1460 return EAF_DIRECT | EAF_NOESCAPE;
1462 case 'w':
1463 return EAF_NOESCAPE;
1465 case '.':
1466 default:
1467 return 0;
1471 /* Detects return flags for the call STMT. */
1474 gimple_call_return_flags (const gcall *stmt)
1476 const_tree attr;
1478 if (gimple_call_flags (stmt) & ECF_MALLOC)
1479 return ERF_NOALIAS;
1481 attr = gimple_call_fnspec (stmt);
1482 if (!attr || TREE_STRING_LENGTH (attr) < 1)
1483 return 0;
1485 switch (TREE_STRING_POINTER (attr)[0])
1487 case '1':
1488 case '2':
1489 case '3':
1490 case '4':
1491 return ERF_RETURNS_ARG | (TREE_STRING_POINTER (attr)[0] - '1');
1493 case 'm':
1494 return ERF_NOALIAS;
1496 case '.':
1497 default:
1498 return 0;
1503 /* Return true if GS is a copy assignment. */
1505 bool
1506 gimple_assign_copy_p (gimple *gs)
1508 return (gimple_assign_single_p (gs)
1509 && is_gimple_val (gimple_op (gs, 1)));
1513 /* Return true if GS is a SSA_NAME copy assignment. */
1515 bool
1516 gimple_assign_ssa_name_copy_p (gimple *gs)
1518 return (gimple_assign_single_p (gs)
1519 && TREE_CODE (gimple_assign_lhs (gs)) == SSA_NAME
1520 && TREE_CODE (gimple_assign_rhs1 (gs)) == SSA_NAME);
1524 /* Return true if GS is an assignment with a unary RHS, but the
1525 operator has no effect on the assigned value. The logic is adapted
1526 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1527 instances in which STRIP_NOPS was previously applied to the RHS of
1528 an assignment.
1530 NOTE: In the use cases that led to the creation of this function
1531 and of gimple_assign_single_p, it is typical to test for either
1532 condition and to proceed in the same manner. In each case, the
1533 assigned value is represented by the single RHS operand of the
1534 assignment. I suspect there may be cases where gimple_assign_copy_p,
1535 gimple_assign_single_p, or equivalent logic is used where a similar
1536 treatment of unary NOPs is appropriate. */
1538 bool
1539 gimple_assign_unary_nop_p (gimple *gs)
1541 return (is_gimple_assign (gs)
1542 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
1543 || gimple_assign_rhs_code (gs) == NON_LVALUE_EXPR)
1544 && gimple_assign_rhs1 (gs) != error_mark_node
1545 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs)))
1546 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs)))));
1549 /* Set BB to be the basic block holding G. */
1551 void
1552 gimple_set_bb (gimple *stmt, basic_block bb)
1554 stmt->bb = bb;
1556 if (gimple_code (stmt) != GIMPLE_LABEL)
1557 return;
1559 /* If the statement is a label, add the label to block-to-labels map
1560 so that we can speed up edge creation for GIMPLE_GOTOs. */
1561 if (cfun->cfg)
1563 tree t;
1564 int uid;
1566 t = gimple_label_label (as_a <glabel *> (stmt));
1567 uid = LABEL_DECL_UID (t);
1568 if (uid == -1)
1570 unsigned old_len =
1571 vec_safe_length (label_to_block_map_for_fn (cfun));
1572 LABEL_DECL_UID (t) = uid = cfun->cfg->last_label_uid++;
1573 if (old_len <= (unsigned) uid)
1575 unsigned new_len = 3 * uid / 2 + 1;
1577 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun),
1578 new_len);
1582 (*label_to_block_map_for_fn (cfun))[uid] = bb;
1587 /* Modify the RHS of the assignment pointed-to by GSI using the
1588 operands in the expression tree EXPR.
1590 NOTE: The statement pointed-to by GSI may be reallocated if it
1591 did not have enough operand slots.
1593 This function is useful to convert an existing tree expression into
1594 the flat representation used for the RHS of a GIMPLE assignment.
1595 It will reallocate memory as needed to expand or shrink the number
1596 of operand slots needed to represent EXPR.
1598 NOTE: If you find yourself building a tree and then calling this
1599 function, you are most certainly doing it the slow way. It is much
1600 better to build a new assignment or to use the function
1601 gimple_assign_set_rhs_with_ops, which does not require an
1602 expression tree to be built. */
1604 void
1605 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *gsi, tree expr)
1607 enum tree_code subcode;
1608 tree op1, op2, op3;
1610 extract_ops_from_tree (expr, &subcode, &op1, &op2, &op3);
1611 gimple_assign_set_rhs_with_ops (gsi, subcode, op1, op2, op3);
1615 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1616 operands OP1, OP2 and OP3.
1618 NOTE: The statement pointed-to by GSI may be reallocated if it
1619 did not have enough operand slots. */
1621 void
1622 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
1623 tree op1, tree op2, tree op3)
1625 unsigned new_rhs_ops = get_gimple_rhs_num_ops (code);
1626 gimple *stmt = gsi_stmt (*gsi);
1628 /* If the new CODE needs more operands, allocate a new statement. */
1629 if (gimple_num_ops (stmt) < new_rhs_ops + 1)
1631 tree lhs = gimple_assign_lhs (stmt);
1632 gimple *new_stmt = gimple_alloc (gimple_code (stmt), new_rhs_ops + 1);
1633 memcpy (new_stmt, stmt, gimple_size (gimple_code (stmt)));
1634 gimple_init_singleton (new_stmt);
1635 gsi_replace (gsi, new_stmt, false);
1636 stmt = new_stmt;
1638 /* The LHS needs to be reset as this also changes the SSA name
1639 on the LHS. */
1640 gimple_assign_set_lhs (stmt, lhs);
1643 gimple_set_num_ops (stmt, new_rhs_ops + 1);
1644 gimple_set_subcode (stmt, code);
1645 gimple_assign_set_rhs1 (stmt, op1);
1646 if (new_rhs_ops > 1)
1647 gimple_assign_set_rhs2 (stmt, op2);
1648 if (new_rhs_ops > 2)
1649 gimple_assign_set_rhs3 (stmt, op3);
1653 /* Return the LHS of a statement that performs an assignment,
1654 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1655 for a call to a function that returns no value, or for a
1656 statement other than an assignment or a call. */
1658 tree
1659 gimple_get_lhs (const gimple *stmt)
1661 enum gimple_code code = gimple_code (stmt);
1663 if (code == GIMPLE_ASSIGN)
1664 return gimple_assign_lhs (stmt);
1665 else if (code == GIMPLE_CALL)
1666 return gimple_call_lhs (stmt);
1667 else
1668 return NULL_TREE;
1672 /* Set the LHS of a statement that performs an assignment,
1673 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1675 void
1676 gimple_set_lhs (gimple *stmt, tree lhs)
1678 enum gimple_code code = gimple_code (stmt);
1680 if (code == GIMPLE_ASSIGN)
1681 gimple_assign_set_lhs (stmt, lhs);
1682 else if (code == GIMPLE_CALL)
1683 gimple_call_set_lhs (stmt, lhs);
1684 else
1685 gcc_unreachable ();
1689 /* Return a deep copy of statement STMT. All the operands from STMT
1690 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1691 and VUSE operand arrays are set to empty in the new copy. The new
1692 copy isn't part of any sequence. */
1694 gimple *
1695 gimple_copy (gimple *stmt)
1697 enum gimple_code code = gimple_code (stmt);
1698 unsigned num_ops = gimple_num_ops (stmt);
1699 gimple *copy = gimple_alloc (code, num_ops);
1700 unsigned i;
1702 /* Shallow copy all the fields from STMT. */
1703 memcpy (copy, stmt, gimple_size (code));
1704 gimple_init_singleton (copy);
1706 /* If STMT has sub-statements, deep-copy them as well. */
1707 if (gimple_has_substatements (stmt))
1709 gimple_seq new_seq;
1710 tree t;
1712 switch (gimple_code (stmt))
1714 case GIMPLE_BIND:
1716 gbind *bind_stmt = as_a <gbind *> (stmt);
1717 gbind *bind_copy = as_a <gbind *> (copy);
1718 new_seq = gimple_seq_copy (gimple_bind_body (bind_stmt));
1719 gimple_bind_set_body (bind_copy, new_seq);
1720 gimple_bind_set_vars (bind_copy,
1721 unshare_expr (gimple_bind_vars (bind_stmt)));
1722 gimple_bind_set_block (bind_copy, gimple_bind_block (bind_stmt));
1724 break;
1726 case GIMPLE_CATCH:
1728 gcatch *catch_stmt = as_a <gcatch *> (stmt);
1729 gcatch *catch_copy = as_a <gcatch *> (copy);
1730 new_seq = gimple_seq_copy (gimple_catch_handler (catch_stmt));
1731 gimple_catch_set_handler (catch_copy, new_seq);
1732 t = unshare_expr (gimple_catch_types (catch_stmt));
1733 gimple_catch_set_types (catch_copy, t);
1735 break;
1737 case GIMPLE_EH_FILTER:
1739 geh_filter *eh_filter_stmt = as_a <geh_filter *> (stmt);
1740 geh_filter *eh_filter_copy = as_a <geh_filter *> (copy);
1741 new_seq
1742 = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt));
1743 gimple_eh_filter_set_failure (eh_filter_copy, new_seq);
1744 t = unshare_expr (gimple_eh_filter_types (eh_filter_stmt));
1745 gimple_eh_filter_set_types (eh_filter_copy, t);
1747 break;
1749 case GIMPLE_EH_ELSE:
1751 geh_else *eh_else_stmt = as_a <geh_else *> (stmt);
1752 geh_else *eh_else_copy = as_a <geh_else *> (copy);
1753 new_seq = gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt));
1754 gimple_eh_else_set_n_body (eh_else_copy, new_seq);
1755 new_seq = gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt));
1756 gimple_eh_else_set_e_body (eh_else_copy, new_seq);
1758 break;
1760 case GIMPLE_TRY:
1762 gtry *try_stmt = as_a <gtry *> (stmt);
1763 gtry *try_copy = as_a <gtry *> (copy);
1764 new_seq = gimple_seq_copy (gimple_try_eval (try_stmt));
1765 gimple_try_set_eval (try_copy, new_seq);
1766 new_seq = gimple_seq_copy (gimple_try_cleanup (try_stmt));
1767 gimple_try_set_cleanup (try_copy, new_seq);
1769 break;
1771 case GIMPLE_OMP_FOR:
1772 new_seq = gimple_seq_copy (gimple_omp_for_pre_body (stmt));
1773 gimple_omp_for_set_pre_body (copy, new_seq);
1774 t = unshare_expr (gimple_omp_for_clauses (stmt));
1775 gimple_omp_for_set_clauses (copy, t);
1777 gomp_for *omp_for_copy = as_a <gomp_for *> (copy);
1778 omp_for_copy->iter = ggc_vec_alloc<gimple_omp_for_iter>
1779 ( gimple_omp_for_collapse (stmt));
1781 for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
1783 gimple_omp_for_set_cond (copy, i,
1784 gimple_omp_for_cond (stmt, i));
1785 gimple_omp_for_set_index (copy, i,
1786 gimple_omp_for_index (stmt, i));
1787 t = unshare_expr (gimple_omp_for_initial (stmt, i));
1788 gimple_omp_for_set_initial (copy, i, t);
1789 t = unshare_expr (gimple_omp_for_final (stmt, i));
1790 gimple_omp_for_set_final (copy, i, t);
1791 t = unshare_expr (gimple_omp_for_incr (stmt, i));
1792 gimple_omp_for_set_incr (copy, i, t);
1794 goto copy_omp_body;
1796 case GIMPLE_OMP_PARALLEL:
1798 gomp_parallel *omp_par_stmt = as_a <gomp_parallel *> (stmt);
1799 gomp_parallel *omp_par_copy = as_a <gomp_parallel *> (copy);
1800 t = unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt));
1801 gimple_omp_parallel_set_clauses (omp_par_copy, t);
1802 t = unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt));
1803 gimple_omp_parallel_set_child_fn (omp_par_copy, t);
1804 t = unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt));
1805 gimple_omp_parallel_set_data_arg (omp_par_copy, t);
1807 goto copy_omp_body;
1809 case GIMPLE_OMP_TASK:
1810 t = unshare_expr (gimple_omp_task_clauses (stmt));
1811 gimple_omp_task_set_clauses (copy, t);
1812 t = unshare_expr (gimple_omp_task_child_fn (stmt));
1813 gimple_omp_task_set_child_fn (copy, t);
1814 t = unshare_expr (gimple_omp_task_data_arg (stmt));
1815 gimple_omp_task_set_data_arg (copy, t);
1816 t = unshare_expr (gimple_omp_task_copy_fn (stmt));
1817 gimple_omp_task_set_copy_fn (copy, t);
1818 t = unshare_expr (gimple_omp_task_arg_size (stmt));
1819 gimple_omp_task_set_arg_size (copy, t);
1820 t = unshare_expr (gimple_omp_task_arg_align (stmt));
1821 gimple_omp_task_set_arg_align (copy, t);
1822 goto copy_omp_body;
1824 case GIMPLE_OMP_CRITICAL:
1825 t = unshare_expr (gimple_omp_critical_name
1826 (as_a <gomp_critical *> (stmt)));
1827 gimple_omp_critical_set_name (as_a <gomp_critical *> (copy), t);
1828 t = unshare_expr (gimple_omp_critical_clauses
1829 (as_a <gomp_critical *> (stmt)));
1830 gimple_omp_critical_set_clauses (as_a <gomp_critical *> (copy), t);
1831 goto copy_omp_body;
1833 case GIMPLE_OMP_ORDERED:
1834 t = unshare_expr (gimple_omp_ordered_clauses
1835 (as_a <gomp_ordered *> (stmt)));
1836 gimple_omp_ordered_set_clauses (as_a <gomp_ordered *> (copy), t);
1837 goto copy_omp_body;
1839 case GIMPLE_OMP_SECTIONS:
1840 t = unshare_expr (gimple_omp_sections_clauses (stmt));
1841 gimple_omp_sections_set_clauses (copy, t);
1842 t = unshare_expr (gimple_omp_sections_control (stmt));
1843 gimple_omp_sections_set_control (copy, t);
1844 goto copy_omp_body;
1846 case GIMPLE_OMP_SINGLE:
1848 gomp_single *omp_single_copy = as_a <gomp_single *> (copy);
1849 t = unshare_expr (gimple_omp_single_clauses (stmt));
1850 gimple_omp_single_set_clauses (omp_single_copy, t);
1852 goto copy_omp_body;
1854 case GIMPLE_OMP_TARGET:
1856 gomp_target *omp_target_stmt = as_a <gomp_target *> (stmt);
1857 gomp_target *omp_target_copy = as_a <gomp_target *> (copy);
1858 t = unshare_expr (gimple_omp_target_clauses (omp_target_stmt));
1859 gimple_omp_target_set_clauses (omp_target_copy, t);
1860 t = unshare_expr (gimple_omp_target_data_arg (omp_target_stmt));
1861 gimple_omp_target_set_data_arg (omp_target_copy, t);
1863 goto copy_omp_body;
1865 case GIMPLE_OMP_TEAMS:
1867 gomp_teams *omp_teams_copy = as_a <gomp_teams *> (copy);
1868 t = unshare_expr (gimple_omp_teams_clauses (stmt));
1869 gimple_omp_teams_set_clauses (omp_teams_copy, t);
1871 /* FALLTHRU */
1873 case GIMPLE_OMP_SECTION:
1874 case GIMPLE_OMP_MASTER:
1875 case GIMPLE_OMP_TASKGROUP:
1876 case GIMPLE_OMP_GRID_BODY:
1877 copy_omp_body:
1878 new_seq = gimple_seq_copy (gimple_omp_body (stmt));
1879 gimple_omp_set_body (copy, new_seq);
1880 break;
1882 case GIMPLE_TRANSACTION:
1883 new_seq = gimple_seq_copy (gimple_transaction_body (
1884 as_a <gtransaction *> (stmt)));
1885 gimple_transaction_set_body (as_a <gtransaction *> (copy),
1886 new_seq);
1887 break;
1889 case GIMPLE_WITH_CLEANUP_EXPR:
1890 new_seq = gimple_seq_copy (gimple_wce_cleanup (stmt));
1891 gimple_wce_set_cleanup (copy, new_seq);
1892 break;
1894 default:
1895 gcc_unreachable ();
1899 /* Make copy of operands. */
1900 for (i = 0; i < num_ops; i++)
1901 gimple_set_op (copy, i, unshare_expr (gimple_op (stmt, i)));
1903 if (gimple_has_mem_ops (stmt))
1905 gimple_set_vdef (copy, gimple_vdef (stmt));
1906 gimple_set_vuse (copy, gimple_vuse (stmt));
1909 /* Clear out SSA operand vectors on COPY. */
1910 if (gimple_has_ops (stmt))
1912 gimple_set_use_ops (copy, NULL);
1914 /* SSA operands need to be updated. */
1915 gimple_set_modified (copy, true);
1918 return copy;
1922 /* Return true if statement S has side-effects. We consider a
1923 statement to have side effects if:
1925 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
1926 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
1928 bool
1929 gimple_has_side_effects (const gimple *s)
1931 if (is_gimple_debug (s))
1932 return false;
1934 /* We don't have to scan the arguments to check for
1935 volatile arguments, though, at present, we still
1936 do a scan to check for TREE_SIDE_EFFECTS. */
1937 if (gimple_has_volatile_ops (s))
1938 return true;
1940 if (gimple_code (s) == GIMPLE_ASM
1941 && gimple_asm_volatile_p (as_a <const gasm *> (s)))
1942 return true;
1944 if (is_gimple_call (s))
1946 int flags = gimple_call_flags (s);
1948 /* An infinite loop is considered a side effect. */
1949 if (!(flags & (ECF_CONST | ECF_PURE))
1950 || (flags & ECF_LOOPING_CONST_OR_PURE))
1951 return true;
1953 return false;
1956 return false;
1959 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
1960 Return true if S can trap. When INCLUDE_MEM is true, check whether
1961 the memory operations could trap. When INCLUDE_STORES is true and
1962 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
1964 bool
1965 gimple_could_trap_p_1 (gimple *s, bool include_mem, bool include_stores)
1967 tree t, div = NULL_TREE;
1968 enum tree_code op;
1970 if (include_mem)
1972 unsigned i, start = (is_gimple_assign (s) && !include_stores) ? 1 : 0;
1974 for (i = start; i < gimple_num_ops (s); i++)
1975 if (tree_could_trap_p (gimple_op (s, i)))
1976 return true;
1979 switch (gimple_code (s))
1981 case GIMPLE_ASM:
1982 return gimple_asm_volatile_p (as_a <gasm *> (s));
1984 case GIMPLE_CALL:
1985 t = gimple_call_fndecl (s);
1986 /* Assume that calls to weak functions may trap. */
1987 if (!t || !DECL_P (t) || DECL_WEAK (t))
1988 return true;
1989 return false;
1991 case GIMPLE_ASSIGN:
1992 t = gimple_expr_type (s);
1993 op = gimple_assign_rhs_code (s);
1994 if (get_gimple_rhs_class (op) == GIMPLE_BINARY_RHS)
1995 div = gimple_assign_rhs2 (s);
1996 return (operation_could_trap_p (op, FLOAT_TYPE_P (t),
1997 (INTEGRAL_TYPE_P (t)
1998 && TYPE_OVERFLOW_TRAPS (t)),
1999 div));
2001 case GIMPLE_COND:
2002 t = TREE_TYPE (gimple_cond_lhs (s));
2003 return operation_could_trap_p (gimple_cond_code (s),
2004 FLOAT_TYPE_P (t), false, NULL_TREE);
2006 default:
2007 break;
2010 return false;
2013 /* Return true if statement S can trap. */
2015 bool
2016 gimple_could_trap_p (gimple *s)
2018 return gimple_could_trap_p_1 (s, true, true);
2021 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
2023 bool
2024 gimple_assign_rhs_could_trap_p (gimple *s)
2026 gcc_assert (is_gimple_assign (s));
2027 return gimple_could_trap_p_1 (s, true, false);
2031 /* Print debugging information for gimple stmts generated. */
2033 void
2034 dump_gimple_statistics (void)
2036 int i, total_tuples = 0, total_bytes = 0;
2038 if (! GATHER_STATISTICS)
2040 fprintf (stderr, "No gimple statistics\n");
2041 return;
2044 fprintf (stderr, "\nGIMPLE statements\n");
2045 fprintf (stderr, "Kind Stmts Bytes\n");
2046 fprintf (stderr, "---------------------------------------\n");
2047 for (i = 0; i < (int) gimple_alloc_kind_all; ++i)
2049 fprintf (stderr, "%-20s %7d %10d\n", gimple_alloc_kind_names[i],
2050 gimple_alloc_counts[i], gimple_alloc_sizes[i]);
2051 total_tuples += gimple_alloc_counts[i];
2052 total_bytes += gimple_alloc_sizes[i];
2054 fprintf (stderr, "---------------------------------------\n");
2055 fprintf (stderr, "%-20s %7d %10d\n", "Total", total_tuples, total_bytes);
2056 fprintf (stderr, "---------------------------------------\n");
2060 /* Return the number of operands needed on the RHS of a GIMPLE
2061 assignment for an expression with tree code CODE. */
2063 unsigned
2064 get_gimple_rhs_num_ops (enum tree_code code)
2066 enum gimple_rhs_class rhs_class = get_gimple_rhs_class (code);
2068 if (rhs_class == GIMPLE_UNARY_RHS || rhs_class == GIMPLE_SINGLE_RHS)
2069 return 1;
2070 else if (rhs_class == GIMPLE_BINARY_RHS)
2071 return 2;
2072 else if (rhs_class == GIMPLE_TERNARY_RHS)
2073 return 3;
2074 else
2075 gcc_unreachable ();
2078 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2079 (unsigned char) \
2080 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2081 : ((TYPE) == tcc_binary \
2082 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2083 : ((TYPE) == tcc_constant \
2084 || (TYPE) == tcc_declaration \
2085 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2086 : ((SYM) == TRUTH_AND_EXPR \
2087 || (SYM) == TRUTH_OR_EXPR \
2088 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2089 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2090 : ((SYM) == COND_EXPR \
2091 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2092 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2093 || (SYM) == DOT_PROD_EXPR \
2094 || (SYM) == SAD_EXPR \
2095 || (SYM) == REALIGN_LOAD_EXPR \
2096 || (SYM) == VEC_COND_EXPR \
2097 || (SYM) == VEC_PERM_EXPR \
2098 || (SYM) == BIT_INSERT_EXPR \
2099 || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS \
2100 : ((SYM) == CONSTRUCTOR \
2101 || (SYM) == OBJ_TYPE_REF \
2102 || (SYM) == ASSERT_EXPR \
2103 || (SYM) == ADDR_EXPR \
2104 || (SYM) == WITH_SIZE_EXPR \
2105 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2106 : GIMPLE_INVALID_RHS),
2107 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2109 const unsigned char gimple_rhs_class_table[] = {
2110 #include "all-tree.def"
2113 #undef DEFTREECODE
2114 #undef END_OF_BASE_TREE_CODES
2116 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2117 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2118 we failed to create one. */
2120 tree
2121 canonicalize_cond_expr_cond (tree t)
2123 /* Strip conversions around boolean operations. */
2124 if (CONVERT_EXPR_P (t)
2125 && (truth_value_p (TREE_CODE (TREE_OPERAND (t, 0)))
2126 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0)))
2127 == BOOLEAN_TYPE))
2128 t = TREE_OPERAND (t, 0);
2130 /* For !x use x == 0. */
2131 if (TREE_CODE (t) == TRUTH_NOT_EXPR)
2133 tree top0 = TREE_OPERAND (t, 0);
2134 t = build2 (EQ_EXPR, TREE_TYPE (t),
2135 top0, build_int_cst (TREE_TYPE (top0), 0));
2137 /* For cmp ? 1 : 0 use cmp. */
2138 else if (TREE_CODE (t) == COND_EXPR
2139 && COMPARISON_CLASS_P (TREE_OPERAND (t, 0))
2140 && integer_onep (TREE_OPERAND (t, 1))
2141 && integer_zerop (TREE_OPERAND (t, 2)))
2143 tree top0 = TREE_OPERAND (t, 0);
2144 t = build2 (TREE_CODE (top0), TREE_TYPE (t),
2145 TREE_OPERAND (top0, 0), TREE_OPERAND (top0, 1));
2147 /* For x ^ y use x != y. */
2148 else if (TREE_CODE (t) == BIT_XOR_EXPR)
2149 t = build2 (NE_EXPR, TREE_TYPE (t),
2150 TREE_OPERAND (t, 0), TREE_OPERAND (t, 1));
2152 if (is_gimple_condexpr (t))
2153 return t;
2155 return NULL_TREE;
2158 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2159 the positions marked by the set ARGS_TO_SKIP. */
2161 gcall *
2162 gimple_call_copy_skip_args (gcall *stmt, bitmap args_to_skip)
2164 int i;
2165 int nargs = gimple_call_num_args (stmt);
2166 auto_vec<tree> vargs (nargs);
2167 gcall *new_stmt;
2169 for (i = 0; i < nargs; i++)
2170 if (!bitmap_bit_p (args_to_skip, i))
2171 vargs.quick_push (gimple_call_arg (stmt, i));
2173 if (gimple_call_internal_p (stmt))
2174 new_stmt = gimple_build_call_internal_vec (gimple_call_internal_fn (stmt),
2175 vargs);
2176 else
2177 new_stmt = gimple_build_call_vec (gimple_call_fn (stmt), vargs);
2179 if (gimple_call_lhs (stmt))
2180 gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
2182 gimple_set_vuse (new_stmt, gimple_vuse (stmt));
2183 gimple_set_vdef (new_stmt, gimple_vdef (stmt));
2185 if (gimple_has_location (stmt))
2186 gimple_set_location (new_stmt, gimple_location (stmt));
2187 gimple_call_copy_flags (new_stmt, stmt);
2188 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
2190 gimple_set_modified (new_stmt, true);
2192 return new_stmt;
2197 /* Return true if the field decls F1 and F2 are at the same offset.
2199 This is intended to be used on GIMPLE types only. */
2201 bool
2202 gimple_compare_field_offset (tree f1, tree f2)
2204 if (DECL_OFFSET_ALIGN (f1) == DECL_OFFSET_ALIGN (f2))
2206 tree offset1 = DECL_FIELD_OFFSET (f1);
2207 tree offset2 = DECL_FIELD_OFFSET (f2);
2208 return ((offset1 == offset2
2209 /* Once gimplification is done, self-referential offsets are
2210 instantiated as operand #2 of the COMPONENT_REF built for
2211 each access and reset. Therefore, they are not relevant
2212 anymore and fields are interchangeable provided that they
2213 represent the same access. */
2214 || (TREE_CODE (offset1) == PLACEHOLDER_EXPR
2215 && TREE_CODE (offset2) == PLACEHOLDER_EXPR
2216 && (DECL_SIZE (f1) == DECL_SIZE (f2)
2217 || (TREE_CODE (DECL_SIZE (f1)) == PLACEHOLDER_EXPR
2218 && TREE_CODE (DECL_SIZE (f2)) == PLACEHOLDER_EXPR)
2219 || operand_equal_p (DECL_SIZE (f1), DECL_SIZE (f2), 0))
2220 && DECL_ALIGN (f1) == DECL_ALIGN (f2))
2221 || operand_equal_p (offset1, offset2, 0))
2222 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1),
2223 DECL_FIELD_BIT_OFFSET (f2)));
2226 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2227 should be, so handle differing ones specially by decomposing
2228 the offset into a byte and bit offset manually. */
2229 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1))
2230 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2)))
2232 unsigned HOST_WIDE_INT byte_offset1, byte_offset2;
2233 unsigned HOST_WIDE_INT bit_offset1, bit_offset2;
2234 bit_offset1 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1));
2235 byte_offset1 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1))
2236 + bit_offset1 / BITS_PER_UNIT);
2237 bit_offset2 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2));
2238 byte_offset2 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2))
2239 + bit_offset2 / BITS_PER_UNIT);
2240 if (byte_offset1 != byte_offset2)
2241 return false;
2242 return bit_offset1 % BITS_PER_UNIT == bit_offset2 % BITS_PER_UNIT;
2245 return false;
2249 /* Return a type the same as TYPE except unsigned or
2250 signed according to UNSIGNEDP. */
2252 static tree
2253 gimple_signed_or_unsigned_type (bool unsignedp, tree type)
2255 tree type1;
2256 int i;
2258 type1 = TYPE_MAIN_VARIANT (type);
2259 if (type1 == signed_char_type_node
2260 || type1 == char_type_node
2261 || type1 == unsigned_char_type_node)
2262 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2263 if (type1 == integer_type_node || type1 == unsigned_type_node)
2264 return unsignedp ? unsigned_type_node : integer_type_node;
2265 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
2266 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2267 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
2268 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2269 if (type1 == long_long_integer_type_node
2270 || type1 == long_long_unsigned_type_node)
2271 return unsignedp
2272 ? long_long_unsigned_type_node
2273 : long_long_integer_type_node;
2275 for (i = 0; i < NUM_INT_N_ENTS; i ++)
2276 if (int_n_enabled_p[i]
2277 && (type1 == int_n_trees[i].unsigned_type
2278 || type1 == int_n_trees[i].signed_type))
2279 return unsignedp
2280 ? int_n_trees[i].unsigned_type
2281 : int_n_trees[i].signed_type;
2283 #if HOST_BITS_PER_WIDE_INT >= 64
2284 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
2285 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2286 #endif
2287 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
2288 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2289 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
2290 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2291 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
2292 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2293 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
2294 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2296 #define GIMPLE_FIXED_TYPES(NAME) \
2297 if (type1 == short_ ## NAME ## _type_node \
2298 || type1 == unsigned_short_ ## NAME ## _type_node) \
2299 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2300 : short_ ## NAME ## _type_node; \
2301 if (type1 == NAME ## _type_node \
2302 || type1 == unsigned_ ## NAME ## _type_node) \
2303 return unsignedp ? unsigned_ ## NAME ## _type_node \
2304 : NAME ## _type_node; \
2305 if (type1 == long_ ## NAME ## _type_node \
2306 || type1 == unsigned_long_ ## NAME ## _type_node) \
2307 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2308 : long_ ## NAME ## _type_node; \
2309 if (type1 == long_long_ ## NAME ## _type_node \
2310 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2311 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2312 : long_long_ ## NAME ## _type_node;
2314 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2315 if (type1 == NAME ## _type_node \
2316 || type1 == u ## NAME ## _type_node) \
2317 return unsignedp ? u ## NAME ## _type_node \
2318 : NAME ## _type_node;
2320 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2321 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2322 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2323 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2324 : sat_ ## short_ ## NAME ## _type_node; \
2325 if (type1 == sat_ ## NAME ## _type_node \
2326 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2327 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2328 : sat_ ## NAME ## _type_node; \
2329 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2330 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2331 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2332 : sat_ ## long_ ## NAME ## _type_node; \
2333 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2334 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2335 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2336 : sat_ ## long_long_ ## NAME ## _type_node;
2338 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2339 if (type1 == sat_ ## NAME ## _type_node \
2340 || type1 == sat_ ## u ## NAME ## _type_node) \
2341 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2342 : sat_ ## NAME ## _type_node;
2344 GIMPLE_FIXED_TYPES (fract);
2345 GIMPLE_FIXED_TYPES_SAT (fract);
2346 GIMPLE_FIXED_TYPES (accum);
2347 GIMPLE_FIXED_TYPES_SAT (accum);
2349 GIMPLE_FIXED_MODE_TYPES (qq);
2350 GIMPLE_FIXED_MODE_TYPES (hq);
2351 GIMPLE_FIXED_MODE_TYPES (sq);
2352 GIMPLE_FIXED_MODE_TYPES (dq);
2353 GIMPLE_FIXED_MODE_TYPES (tq);
2354 GIMPLE_FIXED_MODE_TYPES_SAT (qq);
2355 GIMPLE_FIXED_MODE_TYPES_SAT (hq);
2356 GIMPLE_FIXED_MODE_TYPES_SAT (sq);
2357 GIMPLE_FIXED_MODE_TYPES_SAT (dq);
2358 GIMPLE_FIXED_MODE_TYPES_SAT (tq);
2359 GIMPLE_FIXED_MODE_TYPES (ha);
2360 GIMPLE_FIXED_MODE_TYPES (sa);
2361 GIMPLE_FIXED_MODE_TYPES (da);
2362 GIMPLE_FIXED_MODE_TYPES (ta);
2363 GIMPLE_FIXED_MODE_TYPES_SAT (ha);
2364 GIMPLE_FIXED_MODE_TYPES_SAT (sa);
2365 GIMPLE_FIXED_MODE_TYPES_SAT (da);
2366 GIMPLE_FIXED_MODE_TYPES_SAT (ta);
2368 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2369 the precision; they have precision set to match their range, but
2370 may use a wider mode to match an ABI. If we change modes, we may
2371 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2372 the precision as well, so as to yield correct results for
2373 bit-field types. C++ does not have these separate bit-field
2374 types, and producing a signed or unsigned variant of an
2375 ENUMERAL_TYPE may cause other problems as well. */
2376 if (!INTEGRAL_TYPE_P (type)
2377 || TYPE_UNSIGNED (type) == unsignedp)
2378 return type;
2380 #define TYPE_OK(node) \
2381 (TYPE_MODE (type) == TYPE_MODE (node) \
2382 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2383 if (TYPE_OK (signed_char_type_node))
2384 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2385 if (TYPE_OK (integer_type_node))
2386 return unsignedp ? unsigned_type_node : integer_type_node;
2387 if (TYPE_OK (short_integer_type_node))
2388 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2389 if (TYPE_OK (long_integer_type_node))
2390 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2391 if (TYPE_OK (long_long_integer_type_node))
2392 return (unsignedp
2393 ? long_long_unsigned_type_node
2394 : long_long_integer_type_node);
2396 for (i = 0; i < NUM_INT_N_ENTS; i ++)
2397 if (int_n_enabled_p[i]
2398 && TYPE_MODE (type) == int_n_data[i].m
2399 && TYPE_PRECISION (type) == int_n_data[i].bitsize)
2400 return unsignedp
2401 ? int_n_trees[i].unsigned_type
2402 : int_n_trees[i].signed_type;
2404 #if HOST_BITS_PER_WIDE_INT >= 64
2405 if (TYPE_OK (intTI_type_node))
2406 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2407 #endif
2408 if (TYPE_OK (intDI_type_node))
2409 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2410 if (TYPE_OK (intSI_type_node))
2411 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2412 if (TYPE_OK (intHI_type_node))
2413 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2414 if (TYPE_OK (intQI_type_node))
2415 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2417 #undef GIMPLE_FIXED_TYPES
2418 #undef GIMPLE_FIXED_MODE_TYPES
2419 #undef GIMPLE_FIXED_TYPES_SAT
2420 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2421 #undef TYPE_OK
2423 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2427 /* Return an unsigned type the same as TYPE in other respects. */
2429 tree
2430 gimple_unsigned_type (tree type)
2432 return gimple_signed_or_unsigned_type (true, type);
2436 /* Return a signed type the same as TYPE in other respects. */
2438 tree
2439 gimple_signed_type (tree type)
2441 return gimple_signed_or_unsigned_type (false, type);
2445 /* Return the typed-based alias set for T, which may be an expression
2446 or a type. Return -1 if we don't do anything special. */
2448 alias_set_type
2449 gimple_get_alias_set (tree t)
2451 /* That's all the expressions we handle specially. */
2452 if (!TYPE_P (t))
2453 return -1;
2455 /* For convenience, follow the C standard when dealing with
2456 character types. Any object may be accessed via an lvalue that
2457 has character type. */
2458 if (t == char_type_node
2459 || t == signed_char_type_node
2460 || t == unsigned_char_type_node)
2461 return 0;
2463 /* Allow aliasing between signed and unsigned variants of the same
2464 type. We treat the signed variant as canonical. */
2465 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2467 tree t1 = gimple_signed_type (t);
2469 /* t1 == t can happen for boolean nodes which are always unsigned. */
2470 if (t1 != t)
2471 return get_alias_set (t1);
2474 return -1;
2478 /* Helper for gimple_ior_addresses_taken_1. */
2480 static bool
2481 gimple_ior_addresses_taken_1 (gimple *, tree addr, tree, void *data)
2483 bitmap addresses_taken = (bitmap)data;
2484 addr = get_base_address (addr);
2485 if (addr
2486 && DECL_P (addr))
2488 bitmap_set_bit (addresses_taken, DECL_UID (addr));
2489 return true;
2491 return false;
2494 /* Set the bit for the uid of all decls that have their address taken
2495 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2496 were any in this stmt. */
2498 bool
2499 gimple_ior_addresses_taken (bitmap addresses_taken, gimple *stmt)
2501 return walk_stmt_load_store_addr_ops (stmt, addresses_taken, NULL, NULL,
2502 gimple_ior_addresses_taken_1);
2506 /* Return true when STMTs arguments and return value match those of FNDECL,
2507 a decl of a builtin function. */
2509 bool
2510 gimple_builtin_call_types_compatible_p (const gimple *stmt, tree fndecl)
2512 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN);
2514 tree ret = gimple_call_lhs (stmt);
2515 if (ret
2516 && !useless_type_conversion_p (TREE_TYPE (ret),
2517 TREE_TYPE (TREE_TYPE (fndecl))))
2518 return false;
2520 tree targs = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2521 unsigned nargs = gimple_call_num_args (stmt);
2522 for (unsigned i = 0; i < nargs; ++i)
2524 /* Variadic args follow. */
2525 if (!targs)
2526 return true;
2527 tree arg = gimple_call_arg (stmt, i);
2528 tree type = TREE_VALUE (targs);
2529 if (!useless_type_conversion_p (type, TREE_TYPE (arg))
2530 /* char/short integral arguments are promoted to int
2531 by several frontends if targetm.calls.promote_prototypes
2532 is true. Allow such promotion too. */
2533 && !(INTEGRAL_TYPE_P (type)
2534 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
2535 && targetm.calls.promote_prototypes (TREE_TYPE (fndecl))
2536 && useless_type_conversion_p (integer_type_node,
2537 TREE_TYPE (arg))))
2538 return false;
2539 targs = TREE_CHAIN (targs);
2541 if (targs && !VOID_TYPE_P (TREE_VALUE (targs)))
2542 return false;
2543 return true;
2546 /* Return true when STMT is builtins call. */
2548 bool
2549 gimple_call_builtin_p (const gimple *stmt)
2551 tree fndecl;
2552 if (is_gimple_call (stmt)
2553 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2554 && DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN)
2555 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2556 return false;
2559 /* Return true when STMT is builtins call to CLASS. */
2561 bool
2562 gimple_call_builtin_p (const gimple *stmt, enum built_in_class klass)
2564 tree fndecl;
2565 if (is_gimple_call (stmt)
2566 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2567 && DECL_BUILT_IN_CLASS (fndecl) == klass)
2568 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2569 return false;
2572 /* Return true when STMT is builtins call to CODE of CLASS. */
2574 bool
2575 gimple_call_builtin_p (const gimple *stmt, enum built_in_function code)
2577 tree fndecl;
2578 if (is_gimple_call (stmt)
2579 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2580 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
2581 && DECL_FUNCTION_CODE (fndecl) == code)
2582 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2583 return false;
2586 /* If CALL is a call to a combined_fn (i.e. an internal function or
2587 a normal built-in function), return its code, otherwise return
2588 CFN_LAST. */
2590 combined_fn
2591 gimple_call_combined_fn (const gimple *stmt)
2593 if (const gcall *call = dyn_cast <const gcall *> (stmt))
2595 if (gimple_call_internal_p (call))
2596 return as_combined_fn (gimple_call_internal_fn (call));
2598 tree fndecl = gimple_call_fndecl (stmt);
2599 if (fndecl
2600 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
2601 && gimple_builtin_call_types_compatible_p (stmt, fndecl))
2602 return as_combined_fn (DECL_FUNCTION_CODE (fndecl));
2604 return CFN_LAST;
2607 /* Return true if STMT clobbers memory. STMT is required to be a
2608 GIMPLE_ASM. */
2610 bool
2611 gimple_asm_clobbers_memory_p (const gasm *stmt)
2613 unsigned i;
2615 for (i = 0; i < gimple_asm_nclobbers (stmt); i++)
2617 tree op = gimple_asm_clobber_op (stmt, i);
2618 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op)), "memory") == 0)
2619 return true;
2622 /* Non-empty basic ASM implicitly clobbers memory. */
2623 if (gimple_asm_input_p (stmt) && strlen (gimple_asm_string (stmt)) != 0)
2624 return true;
2626 return false;
2629 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2631 void
2632 dump_decl_set (FILE *file, bitmap set)
2634 if (set)
2636 bitmap_iterator bi;
2637 unsigned i;
2639 fprintf (file, "{ ");
2641 EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi)
2643 fprintf (file, "D.%u", i);
2644 fprintf (file, " ");
2647 fprintf (file, "}");
2649 else
2650 fprintf (file, "NIL");
2653 /* Return true when CALL is a call stmt that definitely doesn't
2654 free any memory or makes it unavailable otherwise. */
2655 bool
2656 nonfreeing_call_p (gimple *call)
2658 if (gimple_call_builtin_p (call, BUILT_IN_NORMAL)
2659 && gimple_call_flags (call) & ECF_LEAF)
2660 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call)))
2662 /* Just in case these become ECF_LEAF in the future. */
2663 case BUILT_IN_FREE:
2664 case BUILT_IN_TM_FREE:
2665 case BUILT_IN_REALLOC:
2666 case BUILT_IN_STACK_RESTORE:
2667 return false;
2668 default:
2669 return true;
2671 else if (gimple_call_internal_p (call))
2672 switch (gimple_call_internal_fn (call))
2674 case IFN_ABNORMAL_DISPATCHER:
2675 return true;
2676 case IFN_ASAN_MARK:
2677 return tree_to_uhwi (gimple_call_arg (call, 0)) == ASAN_MARK_UNPOISON;
2678 default:
2679 if (gimple_call_flags (call) & ECF_LEAF)
2680 return true;
2681 return false;
2684 tree fndecl = gimple_call_fndecl (call);
2685 if (!fndecl)
2686 return false;
2687 struct cgraph_node *n = cgraph_node::get (fndecl);
2688 if (!n)
2689 return false;
2690 enum availability availability;
2691 n = n->function_symbol (&availability);
2692 if (!n || availability <= AVAIL_INTERPOSABLE)
2693 return false;
2694 return n->nonfreeing_fn;
2697 /* Return true when CALL is a call stmt that definitely need not
2698 be considered to be a memory barrier. */
2699 bool
2700 nonbarrier_call_p (gimple *call)
2702 if (gimple_call_flags (call) & (ECF_PURE | ECF_CONST))
2703 return true;
2704 /* Should extend this to have a nonbarrier_fn flag, just as above in
2705 the nonfreeing case. */
2706 return false;
2709 /* Callback for walk_stmt_load_store_ops.
2711 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2712 otherwise.
2714 This routine only makes a superficial check for a dereference. Thus
2715 it must only be used if it is safe to return a false negative. */
2716 static bool
2717 check_loadstore (gimple *, tree op, tree, void *data)
2719 if (TREE_CODE (op) == MEM_REF || TREE_CODE (op) == TARGET_MEM_REF)
2721 /* Some address spaces may legitimately dereference zero. */
2722 addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (op));
2723 if (targetm.addr_space.zero_address_valid (as))
2724 return false;
2726 return operand_equal_p (TREE_OPERAND (op, 0), (tree)data, 0);
2728 return false;
2732 /* Return true if OP can be inferred to be non-NULL after STMT executes,
2733 either by using a pointer dereference or attributes. */
2734 bool
2735 infer_nonnull_range (gimple *stmt, tree op)
2737 return infer_nonnull_range_by_dereference (stmt, op)
2738 || infer_nonnull_range_by_attribute (stmt, op);
2741 /* Return true if OP can be inferred to be non-NULL after STMT
2742 executes by using a pointer dereference. */
2743 bool
2744 infer_nonnull_range_by_dereference (gimple *stmt, tree op)
2746 /* We can only assume that a pointer dereference will yield
2747 non-NULL if -fdelete-null-pointer-checks is enabled. */
2748 if (!flag_delete_null_pointer_checks
2749 || !POINTER_TYPE_P (TREE_TYPE (op))
2750 || gimple_code (stmt) == GIMPLE_ASM)
2751 return false;
2753 if (walk_stmt_load_store_ops (stmt, (void *)op,
2754 check_loadstore, check_loadstore))
2755 return true;
2757 return false;
2760 /* Return true if OP can be inferred to be a non-NULL after STMT
2761 executes by using attributes. */
2762 bool
2763 infer_nonnull_range_by_attribute (gimple *stmt, tree op)
2765 /* We can only assume that a pointer dereference will yield
2766 non-NULL if -fdelete-null-pointer-checks is enabled. */
2767 if (!flag_delete_null_pointer_checks
2768 || !POINTER_TYPE_P (TREE_TYPE (op))
2769 || gimple_code (stmt) == GIMPLE_ASM)
2770 return false;
2772 if (is_gimple_call (stmt) && !gimple_call_internal_p (stmt))
2774 tree fntype = gimple_call_fntype (stmt);
2775 tree attrs = TYPE_ATTRIBUTES (fntype);
2776 for (; attrs; attrs = TREE_CHAIN (attrs))
2778 attrs = lookup_attribute ("nonnull", attrs);
2780 /* If "nonnull" wasn't specified, we know nothing about
2781 the argument. */
2782 if (attrs == NULL_TREE)
2783 return false;
2785 /* If "nonnull" applies to all the arguments, then ARG
2786 is non-null if it's in the argument list. */
2787 if (TREE_VALUE (attrs) == NULL_TREE)
2789 for (unsigned int i = 0; i < gimple_call_num_args (stmt); i++)
2791 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt, i)))
2792 && operand_equal_p (op, gimple_call_arg (stmt, i), 0))
2793 return true;
2795 return false;
2798 /* Now see if op appears in the nonnull list. */
2799 for (tree t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t))
2801 unsigned int idx = TREE_INT_CST_LOW (TREE_VALUE (t)) - 1;
2802 if (idx < gimple_call_num_args (stmt))
2804 tree arg = gimple_call_arg (stmt, idx);
2805 if (operand_equal_p (op, arg, 0))
2806 return true;
2812 /* If this function is marked as returning non-null, then we can
2813 infer OP is non-null if it is used in the return statement. */
2814 if (greturn *return_stmt = dyn_cast <greturn *> (stmt))
2815 if (gimple_return_retval (return_stmt)
2816 && operand_equal_p (gimple_return_retval (return_stmt), op, 0)
2817 && lookup_attribute ("returns_nonnull",
2818 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
2819 return true;
2821 return false;
2824 /* Compare two case labels. Because the front end should already have
2825 made sure that case ranges do not overlap, it is enough to only compare
2826 the CASE_LOW values of each case label. */
2828 static int
2829 compare_case_labels (const void *p1, const void *p2)
2831 const_tree const case1 = *(const_tree const*)p1;
2832 const_tree const case2 = *(const_tree const*)p2;
2834 /* The 'default' case label always goes first. */
2835 if (!CASE_LOW (case1))
2836 return -1;
2837 else if (!CASE_LOW (case2))
2838 return 1;
2839 else
2840 return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
2843 /* Sort the case labels in LABEL_VEC in place in ascending order. */
2845 void
2846 sort_case_labels (vec<tree> label_vec)
2848 label_vec.qsort (compare_case_labels);
2851 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2853 LABELS is a vector that contains all case labels to look at.
2855 INDEX_TYPE is the type of the switch index expression. Case labels
2856 in LABELS are discarded if their values are not in the value range
2857 covered by INDEX_TYPE. The remaining case label values are folded
2858 to INDEX_TYPE.
2860 If a default case exists in LABELS, it is removed from LABELS and
2861 returned in DEFAULT_CASEP. If no default case exists, but the
2862 case labels already cover the whole range of INDEX_TYPE, a default
2863 case is returned pointing to one of the existing case labels.
2864 Otherwise DEFAULT_CASEP is set to NULL_TREE.
2866 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2867 apply and no action is taken regardless of whether a default case is
2868 found or not. */
2870 void
2871 preprocess_case_label_vec_for_gimple (vec<tree> labels,
2872 tree index_type,
2873 tree *default_casep)
2875 tree min_value, max_value;
2876 tree default_case = NULL_TREE;
2877 size_t i, len;
2879 i = 0;
2880 min_value = TYPE_MIN_VALUE (index_type);
2881 max_value = TYPE_MAX_VALUE (index_type);
2882 while (i < labels.length ())
2884 tree elt = labels[i];
2885 tree low = CASE_LOW (elt);
2886 tree high = CASE_HIGH (elt);
2887 bool remove_element = FALSE;
2889 if (low)
2891 gcc_checking_assert (TREE_CODE (low) == INTEGER_CST);
2892 gcc_checking_assert (!high || TREE_CODE (high) == INTEGER_CST);
2894 /* This is a non-default case label, i.e. it has a value.
2896 See if the case label is reachable within the range of
2897 the index type. Remove out-of-range case values. Turn
2898 case ranges into a canonical form (high > low strictly)
2899 and convert the case label values to the index type.
2901 NB: The type of gimple_switch_index() may be the promoted
2902 type, but the case labels retain the original type. */
2904 if (high)
2906 /* This is a case range. Discard empty ranges.
2907 If the bounds or the range are equal, turn this
2908 into a simple (one-value) case. */
2909 int cmp = tree_int_cst_compare (high, low);
2910 if (cmp < 0)
2911 remove_element = TRUE;
2912 else if (cmp == 0)
2913 high = NULL_TREE;
2916 if (! high)
2918 /* If the simple case value is unreachable, ignore it. */
2919 if ((TREE_CODE (min_value) == INTEGER_CST
2920 && tree_int_cst_compare (low, min_value) < 0)
2921 || (TREE_CODE (max_value) == INTEGER_CST
2922 && tree_int_cst_compare (low, max_value) > 0))
2923 remove_element = TRUE;
2924 else
2925 low = fold_convert (index_type, low);
2927 else
2929 /* If the entire case range is unreachable, ignore it. */
2930 if ((TREE_CODE (min_value) == INTEGER_CST
2931 && tree_int_cst_compare (high, min_value) < 0)
2932 || (TREE_CODE (max_value) == INTEGER_CST
2933 && tree_int_cst_compare (low, max_value) > 0))
2934 remove_element = TRUE;
2935 else
2937 /* If the lower bound is less than the index type's
2938 minimum value, truncate the range bounds. */
2939 if (TREE_CODE (min_value) == INTEGER_CST
2940 && tree_int_cst_compare (low, min_value) < 0)
2941 low = min_value;
2942 low = fold_convert (index_type, low);
2944 /* If the upper bound is greater than the index type's
2945 maximum value, truncate the range bounds. */
2946 if (TREE_CODE (max_value) == INTEGER_CST
2947 && tree_int_cst_compare (high, max_value) > 0)
2948 high = max_value;
2949 high = fold_convert (index_type, high);
2951 /* We may have folded a case range to a one-value case. */
2952 if (tree_int_cst_equal (low, high))
2953 high = NULL_TREE;
2957 CASE_LOW (elt) = low;
2958 CASE_HIGH (elt) = high;
2960 else
2962 gcc_assert (!default_case);
2963 default_case = elt;
2964 /* The default case must be passed separately to the
2965 gimple_build_switch routine. But if DEFAULT_CASEP
2966 is NULL, we do not remove the default case (it would
2967 be completely lost). */
2968 if (default_casep)
2969 remove_element = TRUE;
2972 if (remove_element)
2973 labels.ordered_remove (i);
2974 else
2975 i++;
2977 len = i;
2979 if (!labels.is_empty ())
2980 sort_case_labels (labels);
2982 if (default_casep && !default_case)
2984 /* If the switch has no default label, add one, so that we jump
2985 around the switch body. If the labels already cover the whole
2986 range of the switch index_type, add the default label pointing
2987 to one of the existing labels. */
2988 if (len
2989 && TYPE_MIN_VALUE (index_type)
2990 && TYPE_MAX_VALUE (index_type)
2991 && tree_int_cst_equal (CASE_LOW (labels[0]),
2992 TYPE_MIN_VALUE (index_type)))
2994 tree low, high = CASE_HIGH (labels[len - 1]);
2995 if (!high)
2996 high = CASE_LOW (labels[len - 1]);
2997 if (tree_int_cst_equal (high, TYPE_MAX_VALUE (index_type)))
2999 tree widest_label = labels[0];
3000 for (i = 1; i < len; i++)
3002 high = CASE_LOW (labels[i]);
3003 low = CASE_HIGH (labels[i - 1]);
3004 if (!low)
3005 low = CASE_LOW (labels[i - 1]);
3007 if (CASE_HIGH (labels[i]) != NULL_TREE
3008 && (CASE_HIGH (widest_label) == NULL_TREE
3009 || (wi::gtu_p
3010 (wi::to_wide (CASE_HIGH (labels[i]))
3011 - wi::to_wide (CASE_LOW (labels[i])),
3012 wi::to_wide (CASE_HIGH (widest_label))
3013 - wi::to_wide (CASE_LOW (widest_label))))))
3014 widest_label = labels[i];
3016 if (wi::to_wide (low) + 1 != wi::to_wide (high))
3017 break;
3019 if (i == len)
3021 /* Designate the label with the widest range to be the
3022 default label. */
3023 tree label = CASE_LABEL (widest_label);
3024 default_case = build_case_label (NULL_TREE, NULL_TREE,
3025 label);
3031 if (default_casep)
3032 *default_casep = default_case;
3035 /* Set the location of all statements in SEQ to LOC. */
3037 void
3038 gimple_seq_set_location (gimple_seq seq, location_t loc)
3040 for (gimple_stmt_iterator i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
3041 gimple_set_location (gsi_stmt (i), loc);
3044 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
3046 void
3047 gimple_seq_discard (gimple_seq seq)
3049 gimple_stmt_iterator gsi;
3051 for (gsi = gsi_start (seq); !gsi_end_p (gsi); )
3053 gimple *stmt = gsi_stmt (gsi);
3054 gsi_remove (&gsi, true);
3055 release_defs (stmt);
3056 ggc_free (stmt);
3060 /* See if STMT now calls function that takes no parameters and if so, drop
3061 call arguments. This is used when devirtualization machinery redirects
3062 to __builtin_unreachable or __cxa_pure_virtual. */
3064 void
3065 maybe_remove_unused_call_args (struct function *fn, gimple *stmt)
3067 tree decl = gimple_call_fndecl (stmt);
3068 if (TYPE_ARG_TYPES (TREE_TYPE (decl))
3069 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))) == void_type_node
3070 && gimple_call_num_args (stmt))
3072 gimple_set_num_ops (stmt, 3);
3073 update_stmt_fn (fn, stmt);
3077 /* Return false if STMT will likely expand to real function call. */
3079 bool
3080 gimple_inexpensive_call_p (gcall *stmt)
3082 if (gimple_call_internal_p (stmt))
3083 return true;
3084 tree decl = gimple_call_fndecl (stmt);
3085 if (decl && is_inexpensive_builtin (decl))
3086 return true;
3087 return false;
3090 #if CHECKING_P
3092 namespace selftest {
3094 /* Selftests for core gimple structures. */
3096 /* Verify that STMT is pretty-printed as EXPECTED.
3097 Helper function for selftests. */
3099 static void
3100 verify_gimple_pp (const char *expected, gimple *stmt)
3102 pretty_printer pp;
3103 pp_gimple_stmt_1 (&pp, stmt, 0 /* spc */, 0 /* flags */);
3104 ASSERT_STREQ (expected, pp_formatted_text (&pp));
3107 /* Build a GIMPLE_ASSIGN equivalent to
3108 tmp = 5;
3109 and verify various properties of it. */
3111 static void
3112 test_assign_single ()
3114 tree type = integer_type_node;
3115 tree lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3116 get_identifier ("tmp"),
3117 type);
3118 tree rhs = build_int_cst (type, 5);
3119 gassign *stmt = gimple_build_assign (lhs, rhs);
3120 verify_gimple_pp ("tmp = 5;", stmt);
3122 ASSERT_TRUE (is_gimple_assign (stmt));
3123 ASSERT_EQ (lhs, gimple_assign_lhs (stmt));
3124 ASSERT_EQ (lhs, gimple_get_lhs (stmt));
3125 ASSERT_EQ (rhs, gimple_assign_rhs1 (stmt));
3126 ASSERT_EQ (NULL, gimple_assign_rhs2 (stmt));
3127 ASSERT_EQ (NULL, gimple_assign_rhs3 (stmt));
3128 ASSERT_TRUE (gimple_assign_single_p (stmt));
3129 ASSERT_EQ (INTEGER_CST, gimple_assign_rhs_code (stmt));
3132 /* Build a GIMPLE_ASSIGN equivalent to
3133 tmp = a * b;
3134 and verify various properties of it. */
3136 static void
3137 test_assign_binop ()
3139 tree type = integer_type_node;
3140 tree lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3141 get_identifier ("tmp"),
3142 type);
3143 tree a = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3144 get_identifier ("a"),
3145 type);
3146 tree b = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3147 get_identifier ("b"),
3148 type);
3149 gassign *stmt = gimple_build_assign (lhs, MULT_EXPR, a, b);
3150 verify_gimple_pp ("tmp = a * b;", stmt);
3152 ASSERT_TRUE (is_gimple_assign (stmt));
3153 ASSERT_EQ (lhs, gimple_assign_lhs (stmt));
3154 ASSERT_EQ (lhs, gimple_get_lhs (stmt));
3155 ASSERT_EQ (a, gimple_assign_rhs1 (stmt));
3156 ASSERT_EQ (b, gimple_assign_rhs2 (stmt));
3157 ASSERT_EQ (NULL, gimple_assign_rhs3 (stmt));
3158 ASSERT_FALSE (gimple_assign_single_p (stmt));
3159 ASSERT_EQ (MULT_EXPR, gimple_assign_rhs_code (stmt));
3162 /* Build a GIMPLE_NOP and verify various properties of it. */
3164 static void
3165 test_nop_stmt ()
3167 gimple *stmt = gimple_build_nop ();
3168 verify_gimple_pp ("GIMPLE_NOP", stmt);
3169 ASSERT_EQ (GIMPLE_NOP, gimple_code (stmt));
3170 ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3171 ASSERT_FALSE (gimple_assign_single_p (stmt));
3174 /* Build a GIMPLE_RETURN equivalent to
3175 return 7;
3176 and verify various properties of it. */
3178 static void
3179 test_return_stmt ()
3181 tree type = integer_type_node;
3182 tree val = build_int_cst (type, 7);
3183 greturn *stmt = gimple_build_return (val);
3184 verify_gimple_pp ("return 7;", stmt);
3186 ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt));
3187 ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3188 ASSERT_EQ (val, gimple_return_retval (stmt));
3189 ASSERT_FALSE (gimple_assign_single_p (stmt));
3192 /* Build a GIMPLE_RETURN equivalent to
3193 return;
3194 and verify various properties of it. */
3196 static void
3197 test_return_without_value ()
3199 greturn *stmt = gimple_build_return (NULL);
3200 verify_gimple_pp ("return;", stmt);
3202 ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt));
3203 ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3204 ASSERT_EQ (NULL, gimple_return_retval (stmt));
3205 ASSERT_FALSE (gimple_assign_single_p (stmt));
3208 /* Run all of the selftests within this file. */
3210 void
3211 gimple_c_tests ()
3213 test_assign_single ();
3214 test_assign_binop ();
3215 test_nop_stmt ();
3216 test_return_stmt ();
3217 test_return_without_value ();
3220 } // namespace selftest
3223 #endif /* CHECKING_P */