[RS6000] ICE in decompose, at rtl.h:2282
[official-gcc.git] / gcc / gimple.c
blobfd4e0fac0d4a8da90e52ea7d6caff93b8570e222
1 /* Gimple IR support functions.
3 Copyright (C) 2007-2020 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"
47 #include "langhooks.h"
50 /* All the tuples have their operand vector (if present) at the very bottom
51 of the structure. Therefore, the offset required to find the
52 operands vector the size of the structure minus the size of the 1
53 element tree array at the end (see gimple_ops). */
54 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
55 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
56 EXPORTED_CONST size_t gimple_ops_offset_[] = {
57 #include "gsstruct.def"
59 #undef DEFGSSTRUCT
61 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
62 static const size_t gsstruct_code_size[] = {
63 #include "gsstruct.def"
65 #undef DEFGSSTRUCT
67 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
68 const char *const gimple_code_name[] = {
69 #include "gimple.def"
71 #undef DEFGSCODE
73 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
74 EXPORTED_CONST enum gimple_statement_structure_enum gss_for_code_[] = {
75 #include "gimple.def"
77 #undef DEFGSCODE
79 /* Gimple stats. */
81 uint64_t gimple_alloc_counts[(int) gimple_alloc_kind_all];
82 uint64_t gimple_alloc_sizes[(int) gimple_alloc_kind_all];
84 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
85 static const char * const gimple_alloc_kind_names[] = {
86 "assignments",
87 "phi nodes",
88 "conditionals",
89 "everything else"
92 /* Static gimple tuple members. */
93 const enum gimple_code gassign::code_;
94 const enum gimple_code gcall::code_;
95 const enum gimple_code gcond::code_;
98 /* Gimple tuple constructors.
99 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
100 be passed a NULL to start with an empty sequence. */
102 /* Set the code for statement G to CODE. */
104 static inline void
105 gimple_set_code (gimple *g, enum gimple_code code)
107 g->code = code;
110 /* Return the number of bytes needed to hold a GIMPLE statement with
111 code CODE. */
113 size_t
114 gimple_size (enum gimple_code code, unsigned num_ops)
116 size_t size = gsstruct_code_size[gss_for_code (code)];
117 if (num_ops > 0)
118 size += (sizeof (tree) * (num_ops - 1));
119 return size;
122 /* Initialize GIMPLE statement G with CODE and NUM_OPS. */
124 void
125 gimple_init (gimple *g, enum gimple_code code, unsigned num_ops)
127 gimple_set_code (g, code);
128 gimple_set_num_ops (g, num_ops);
130 /* Do not call gimple_set_modified here as it has other side
131 effects and this tuple is still not completely built. */
132 g->modified = 1;
133 gimple_init_singleton (g);
136 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
137 operands. */
139 gimple *
140 gimple_alloc (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
142 size_t size;
143 gimple *stmt;
145 size = gimple_size (code, num_ops);
146 if (GATHER_STATISTICS)
148 enum gimple_alloc_kind kind = gimple_alloc_kind (code);
149 gimple_alloc_counts[(int) kind]++;
150 gimple_alloc_sizes[(int) kind] += size;
153 stmt = ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT);
154 gimple_init (stmt, code, num_ops);
155 return stmt;
158 /* Set SUBCODE to be the code of the expression computed by statement G. */
160 static inline void
161 gimple_set_subcode (gimple *g, unsigned subcode)
163 /* We only have 16 bits for the RHS code. Assert that we are not
164 overflowing it. */
165 gcc_assert (subcode < (1 << 16));
166 g->subcode = subcode;
171 /* Build a tuple with operands. CODE is the statement to build (which
172 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
173 for the new tuple. NUM_OPS is the number of operands to allocate. */
175 #define gimple_build_with_ops(c, s, n) \
176 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
178 static gimple *
179 gimple_build_with_ops_stat (enum gimple_code code, unsigned subcode,
180 unsigned num_ops MEM_STAT_DECL)
182 gimple *s = gimple_alloc (code, num_ops PASS_MEM_STAT);
183 gimple_set_subcode (s, subcode);
185 return s;
189 /* Build a GIMPLE_RETURN statement returning RETVAL. */
191 greturn *
192 gimple_build_return (tree retval)
194 greturn *s
195 = as_a <greturn *> (gimple_build_with_ops (GIMPLE_RETURN, ERROR_MARK,
196 2));
197 if (retval)
198 gimple_return_set_retval (s, retval);
199 return s;
202 /* Reset alias information on call S. */
204 void
205 gimple_call_reset_alias_info (gcall *s)
207 if (gimple_call_flags (s) & ECF_CONST)
208 memset (gimple_call_use_set (s), 0, sizeof (struct pt_solution));
209 else
210 pt_solution_reset (gimple_call_use_set (s));
211 if (gimple_call_flags (s) & (ECF_CONST|ECF_PURE|ECF_NOVOPS))
212 memset (gimple_call_clobber_set (s), 0, sizeof (struct pt_solution));
213 else
214 pt_solution_reset (gimple_call_clobber_set (s));
217 /* Helper for gimple_build_call, gimple_build_call_valist,
218 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
219 components of a GIMPLE_CALL statement to function FN with NARGS
220 arguments. */
222 static inline gcall *
223 gimple_build_call_1 (tree fn, unsigned nargs)
225 gcall *s
226 = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
227 nargs + 3));
228 if (TREE_CODE (fn) == FUNCTION_DECL)
229 fn = build_fold_addr_expr (fn);
230 gimple_set_op (s, 1, fn);
231 gimple_call_set_fntype (s, TREE_TYPE (TREE_TYPE (fn)));
232 gimple_call_reset_alias_info (s);
233 return s;
237 /* Build a GIMPLE_CALL statement to function FN with the arguments
238 specified in vector ARGS. */
240 gcall *
241 gimple_build_call_vec (tree fn, vec<tree> args)
243 unsigned i;
244 unsigned nargs = args.length ();
245 gcall *call = gimple_build_call_1 (fn, nargs);
247 for (i = 0; i < nargs; i++)
248 gimple_call_set_arg (call, i, args[i]);
250 return call;
254 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
255 arguments. The ... are the arguments. */
257 gcall *
258 gimple_build_call (tree fn, unsigned nargs, ...)
260 va_list ap;
261 gcall *call;
262 unsigned i;
264 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
266 call = gimple_build_call_1 (fn, nargs);
268 va_start (ap, nargs);
269 for (i = 0; i < nargs; i++)
270 gimple_call_set_arg (call, i, va_arg (ap, tree));
271 va_end (ap);
273 return call;
277 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
278 arguments. AP contains the arguments. */
280 gcall *
281 gimple_build_call_valist (tree fn, unsigned nargs, va_list ap)
283 gcall *call;
284 unsigned i;
286 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
288 call = gimple_build_call_1 (fn, nargs);
290 for (i = 0; i < nargs; i++)
291 gimple_call_set_arg (call, i, va_arg (ap, tree));
293 return call;
297 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
298 Build the basic components of a GIMPLE_CALL statement to internal
299 function FN with NARGS arguments. */
301 static inline gcall *
302 gimple_build_call_internal_1 (enum internal_fn fn, unsigned nargs)
304 gcall *s
305 = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
306 nargs + 3));
307 s->subcode |= GF_CALL_INTERNAL;
308 gimple_call_set_internal_fn (s, fn);
309 gimple_call_reset_alias_info (s);
310 return s;
314 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
315 the number of arguments. The ... are the arguments. */
317 gcall *
318 gimple_build_call_internal (enum internal_fn fn, unsigned nargs, ...)
320 va_list ap;
321 gcall *call;
322 unsigned i;
324 call = gimple_build_call_internal_1 (fn, nargs);
325 va_start (ap, nargs);
326 for (i = 0; i < nargs; i++)
327 gimple_call_set_arg (call, i, va_arg (ap, tree));
328 va_end (ap);
330 return call;
334 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
335 specified in vector ARGS. */
337 gcall *
338 gimple_build_call_internal_vec (enum internal_fn fn, vec<tree> args)
340 unsigned i, nargs;
341 gcall *call;
343 nargs = args.length ();
344 call = gimple_build_call_internal_1 (fn, nargs);
345 for (i = 0; i < nargs; i++)
346 gimple_call_set_arg (call, i, args[i]);
348 return call;
352 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
353 assumed to be in GIMPLE form already. Minimal checking is done of
354 this fact. */
356 gcall *
357 gimple_build_call_from_tree (tree t, tree fnptrtype)
359 unsigned i, nargs;
360 gcall *call;
362 gcc_assert (TREE_CODE (t) == CALL_EXPR);
364 nargs = call_expr_nargs (t);
366 tree fndecl = NULL_TREE;
367 if (CALL_EXPR_FN (t) == NULL_TREE)
368 call = gimple_build_call_internal_1 (CALL_EXPR_IFN (t), nargs);
369 else
371 fndecl = get_callee_fndecl (t);
372 call = gimple_build_call_1 (fndecl ? fndecl : CALL_EXPR_FN (t), nargs);
375 for (i = 0; i < nargs; i++)
376 gimple_call_set_arg (call, i, CALL_EXPR_ARG (t, i));
378 gimple_set_block (call, TREE_BLOCK (t));
379 gimple_set_location (call, EXPR_LOCATION (t));
381 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
382 gimple_call_set_chain (call, CALL_EXPR_STATIC_CHAIN (t));
383 gimple_call_set_tail (call, CALL_EXPR_TAILCALL (t));
384 gimple_call_set_must_tail (call, CALL_EXPR_MUST_TAIL_CALL (t));
385 gimple_call_set_return_slot_opt (call, CALL_EXPR_RETURN_SLOT_OPT (t));
386 if (fndecl
387 && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL)
388 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl)))
389 gimple_call_set_alloca_for_var (call, CALL_ALLOCA_FOR_VAR_P (t));
390 else
391 gimple_call_set_from_thunk (call, CALL_FROM_THUNK_P (t));
392 gimple_call_set_va_arg_pack (call, CALL_EXPR_VA_ARG_PACK (t));
393 gimple_call_set_nothrow (call, TREE_NOTHROW (t));
394 gimple_call_set_by_descriptor (call, CALL_EXPR_BY_DESCRIPTOR (t));
395 gimple_set_no_warning (call, TREE_NO_WARNING (t));
397 if (fnptrtype)
399 gimple_call_set_fntype (call, TREE_TYPE (fnptrtype));
401 /* Check if it's an indirect CALL and the type has the
402 nocf_check attribute. In that case propagate the information
403 to the gimple CALL insn. */
404 if (!fndecl)
406 gcc_assert (POINTER_TYPE_P (fnptrtype));
407 tree fntype = TREE_TYPE (fnptrtype);
409 if (lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (fntype)))
410 gimple_call_set_nocf_check (call, TRUE);
414 return call;
418 /* Build a GIMPLE_ASSIGN statement.
420 LHS of the assignment.
421 RHS of the assignment which can be unary or binary. */
423 gassign *
424 gimple_build_assign (tree lhs, tree rhs MEM_STAT_DECL)
426 enum tree_code subcode;
427 tree op1, op2, op3;
429 extract_ops_from_tree (rhs, &subcode, &op1, &op2, &op3);
430 return gimple_build_assign (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
434 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
435 OP1, OP2 and OP3. */
437 static inline gassign *
438 gimple_build_assign_1 (tree lhs, enum tree_code subcode, tree op1,
439 tree op2, tree op3 MEM_STAT_DECL)
441 unsigned num_ops;
442 gassign *p;
444 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
445 code). */
446 num_ops = get_gimple_rhs_num_ops (subcode) + 1;
448 p = as_a <gassign *> (
449 gimple_build_with_ops_stat (GIMPLE_ASSIGN, (unsigned)subcode, num_ops
450 PASS_MEM_STAT));
451 gimple_assign_set_lhs (p, lhs);
452 gimple_assign_set_rhs1 (p, op1);
453 if (op2)
455 gcc_assert (num_ops > 2);
456 gimple_assign_set_rhs2 (p, op2);
459 if (op3)
461 gcc_assert (num_ops > 3);
462 gimple_assign_set_rhs3 (p, op3);
465 return p;
468 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
469 OP1, OP2 and OP3. */
471 gassign *
472 gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
473 tree op2, tree op3 MEM_STAT_DECL)
475 return gimple_build_assign_1 (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
478 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
479 OP1 and OP2. */
481 gassign *
482 gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
483 tree op2 MEM_STAT_DECL)
485 return gimple_build_assign_1 (lhs, subcode, op1, op2, NULL_TREE
486 PASS_MEM_STAT);
489 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
491 gassign *
492 gimple_build_assign (tree lhs, enum tree_code subcode, tree op1 MEM_STAT_DECL)
494 return gimple_build_assign_1 (lhs, subcode, op1, NULL_TREE, NULL_TREE
495 PASS_MEM_STAT);
499 /* Build a GIMPLE_COND statement.
501 PRED is the condition used to compare LHS and the RHS.
502 T_LABEL is the label to jump to if the condition is true.
503 F_LABEL is the label to jump to otherwise. */
505 gcond *
506 gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs,
507 tree t_label, tree f_label)
509 gcond *p;
511 gcc_assert (TREE_CODE_CLASS (pred_code) == tcc_comparison);
512 p = as_a <gcond *> (gimple_build_with_ops (GIMPLE_COND, pred_code, 4));
513 gimple_cond_set_lhs (p, lhs);
514 gimple_cond_set_rhs (p, rhs);
515 gimple_cond_set_true_label (p, t_label);
516 gimple_cond_set_false_label (p, f_label);
517 return p;
520 /* Build a GIMPLE_COND statement from the conditional expression tree
521 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
523 gcond *
524 gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
526 enum tree_code code;
527 tree lhs, rhs;
529 gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
530 return gimple_build_cond (code, lhs, rhs, t_label, f_label);
533 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
534 boolean expression tree COND. */
536 void
537 gimple_cond_set_condition_from_tree (gcond *stmt, tree cond)
539 enum tree_code code;
540 tree lhs, rhs;
542 gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
543 gimple_cond_set_condition (stmt, code, lhs, rhs);
546 /* Build a GIMPLE_LABEL statement for LABEL. */
548 glabel *
549 gimple_build_label (tree label)
551 glabel *p
552 = as_a <glabel *> (gimple_build_with_ops (GIMPLE_LABEL, ERROR_MARK, 1));
553 gimple_label_set_label (p, label);
554 return p;
557 /* Build a GIMPLE_GOTO statement to label DEST. */
559 ggoto *
560 gimple_build_goto (tree dest)
562 ggoto *p
563 = as_a <ggoto *> (gimple_build_with_ops (GIMPLE_GOTO, ERROR_MARK, 1));
564 gimple_goto_set_dest (p, dest);
565 return p;
569 /* Build a GIMPLE_NOP statement. */
571 gimple *
572 gimple_build_nop (void)
574 return gimple_alloc (GIMPLE_NOP, 0);
578 /* Build a GIMPLE_BIND statement.
579 VARS are the variables in BODY.
580 BLOCK is the containing block. */
582 gbind *
583 gimple_build_bind (tree vars, gimple_seq body, tree block)
585 gbind *p = as_a <gbind *> (gimple_alloc (GIMPLE_BIND, 0));
586 gimple_bind_set_vars (p, vars);
587 if (body)
588 gimple_bind_set_body (p, body);
589 if (block)
590 gimple_bind_set_block (p, block);
591 return p;
594 /* Helper function to set the simple fields of a asm stmt.
596 STRING is a pointer to a string that is the asm blocks assembly code.
597 NINPUT is the number of register inputs.
598 NOUTPUT is the number of register outputs.
599 NCLOBBERS is the number of clobbered registers.
602 static inline gasm *
603 gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
604 unsigned nclobbers, unsigned nlabels)
606 gasm *p;
607 int size = strlen (string);
609 /* ASMs with labels cannot have outputs. This should have been
610 enforced by the front end. */
611 gcc_assert (nlabels == 0 || noutputs == 0);
613 p = as_a <gasm *> (
614 gimple_build_with_ops (GIMPLE_ASM, ERROR_MARK,
615 ninputs + noutputs + nclobbers + nlabels));
617 p->ni = ninputs;
618 p->no = noutputs;
619 p->nc = nclobbers;
620 p->nl = nlabels;
621 p->string = ggc_alloc_string (string, size);
623 if (GATHER_STATISTICS)
624 gimple_alloc_sizes[(int) gimple_alloc_kind (GIMPLE_ASM)] += size;
626 return p;
629 /* Build a GIMPLE_ASM statement.
631 STRING is the assembly code.
632 NINPUT is the number of register inputs.
633 NOUTPUT is the number of register outputs.
634 NCLOBBERS is the number of clobbered registers.
635 INPUTS is a vector of the input register parameters.
636 OUTPUTS is a vector of the output register parameters.
637 CLOBBERS is a vector of the clobbered register parameters.
638 LABELS is a vector of destination labels. */
640 gasm *
641 gimple_build_asm_vec (const char *string, vec<tree, va_gc> *inputs,
642 vec<tree, va_gc> *outputs, vec<tree, va_gc> *clobbers,
643 vec<tree, va_gc> *labels)
645 gasm *p;
646 unsigned i;
648 p = gimple_build_asm_1 (string,
649 vec_safe_length (inputs),
650 vec_safe_length (outputs),
651 vec_safe_length (clobbers),
652 vec_safe_length (labels));
654 for (i = 0; i < vec_safe_length (inputs); i++)
655 gimple_asm_set_input_op (p, i, (*inputs)[i]);
657 for (i = 0; i < vec_safe_length (outputs); i++)
658 gimple_asm_set_output_op (p, i, (*outputs)[i]);
660 for (i = 0; i < vec_safe_length (clobbers); i++)
661 gimple_asm_set_clobber_op (p, i, (*clobbers)[i]);
663 for (i = 0; i < vec_safe_length (labels); i++)
664 gimple_asm_set_label_op (p, i, (*labels)[i]);
666 return p;
669 /* Build a GIMPLE_CATCH statement.
671 TYPES are the catch types.
672 HANDLER is the exception handler. */
674 gcatch *
675 gimple_build_catch (tree types, gimple_seq handler)
677 gcatch *p = as_a <gcatch *> (gimple_alloc (GIMPLE_CATCH, 0));
678 gimple_catch_set_types (p, types);
679 if (handler)
680 gimple_catch_set_handler (p, handler);
682 return p;
685 /* Build a GIMPLE_EH_FILTER statement.
687 TYPES are the filter's types.
688 FAILURE is the filter's failure action. */
690 geh_filter *
691 gimple_build_eh_filter (tree types, gimple_seq failure)
693 geh_filter *p = as_a <geh_filter *> (gimple_alloc (GIMPLE_EH_FILTER, 0));
694 gimple_eh_filter_set_types (p, types);
695 if (failure)
696 gimple_eh_filter_set_failure (p, failure);
698 return p;
701 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
703 geh_mnt *
704 gimple_build_eh_must_not_throw (tree decl)
706 geh_mnt *p = as_a <geh_mnt *> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW, 0));
708 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
709 gcc_assert (flags_from_decl_or_type (decl) & ECF_NORETURN);
710 gimple_eh_must_not_throw_set_fndecl (p, decl);
712 return p;
715 /* Build a GIMPLE_EH_ELSE statement. */
717 geh_else *
718 gimple_build_eh_else (gimple_seq n_body, gimple_seq e_body)
720 geh_else *p = as_a <geh_else *> (gimple_alloc (GIMPLE_EH_ELSE, 0));
721 gimple_eh_else_set_n_body (p, n_body);
722 gimple_eh_else_set_e_body (p, e_body);
723 return p;
726 /* Build a GIMPLE_TRY statement.
728 EVAL is the expression to evaluate.
729 CLEANUP is the cleanup expression.
730 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
731 whether this is a try/catch or a try/finally respectively. */
733 gtry *
734 gimple_build_try (gimple_seq eval, gimple_seq cleanup,
735 enum gimple_try_flags kind)
737 gtry *p;
739 gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
740 p = as_a <gtry *> (gimple_alloc (GIMPLE_TRY, 0));
741 gimple_set_subcode (p, kind);
742 if (eval)
743 gimple_try_set_eval (p, eval);
744 if (cleanup)
745 gimple_try_set_cleanup (p, cleanup);
747 return p;
750 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
752 CLEANUP is the cleanup expression. */
754 gimple *
755 gimple_build_wce (gimple_seq cleanup)
757 gimple *p = gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR, 0);
758 if (cleanup)
759 gimple_wce_set_cleanup (p, cleanup);
761 return p;
765 /* Build a GIMPLE_RESX statement. */
767 gresx *
768 gimple_build_resx (int region)
770 gresx *p
771 = as_a <gresx *> (gimple_build_with_ops (GIMPLE_RESX, ERROR_MARK, 0));
772 p->region = region;
773 return p;
777 /* The helper for constructing a gimple switch statement.
778 INDEX is the switch's index.
779 NLABELS is the number of labels in the switch excluding the default.
780 DEFAULT_LABEL is the default label for the switch statement. */
782 gswitch *
783 gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
785 /* nlabels + 1 default label + 1 index. */
786 gcc_checking_assert (default_label);
787 gswitch *p = as_a <gswitch *> (gimple_build_with_ops (GIMPLE_SWITCH,
788 ERROR_MARK,
789 1 + 1 + nlabels));
790 gimple_switch_set_index (p, index);
791 gimple_switch_set_default_label (p, default_label);
792 return p;
795 /* Build a GIMPLE_SWITCH statement.
797 INDEX is the switch's index.
798 DEFAULT_LABEL is the default label
799 ARGS is a vector of labels excluding the default. */
801 gswitch *
802 gimple_build_switch (tree index, tree default_label, vec<tree> args)
804 unsigned i, nlabels = args.length ();
806 gswitch *p = gimple_build_switch_nlabels (nlabels, index, default_label);
808 /* Copy the labels from the vector to the switch statement. */
809 for (i = 0; i < nlabels; i++)
810 gimple_switch_set_label (p, i + 1, args[i]);
812 return p;
815 /* Build a GIMPLE_EH_DISPATCH statement. */
817 geh_dispatch *
818 gimple_build_eh_dispatch (int region)
820 geh_dispatch *p
821 = as_a <geh_dispatch *> (
822 gimple_build_with_ops (GIMPLE_EH_DISPATCH, ERROR_MARK, 0));
823 p->region = region;
824 return p;
827 /* Build a new GIMPLE_DEBUG_BIND statement.
829 VAR is bound to VALUE; block and location are taken from STMT. */
831 gdebug *
832 gimple_build_debug_bind (tree var, tree value, gimple *stmt MEM_STAT_DECL)
834 gdebug *p
835 = as_a <gdebug *> (gimple_build_with_ops_stat (GIMPLE_DEBUG,
836 (unsigned)GIMPLE_DEBUG_BIND, 2
837 PASS_MEM_STAT));
838 gimple_debug_bind_set_var (p, var);
839 gimple_debug_bind_set_value (p, value);
840 if (stmt)
841 gimple_set_location (p, gimple_location (stmt));
843 return p;
847 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
849 VAR is bound to VALUE; block and location are taken from STMT. */
851 gdebug *
852 gimple_build_debug_source_bind (tree var, tree value,
853 gimple *stmt MEM_STAT_DECL)
855 gdebug *p
856 = as_a <gdebug *> (
857 gimple_build_with_ops_stat (GIMPLE_DEBUG,
858 (unsigned)GIMPLE_DEBUG_SOURCE_BIND, 2
859 PASS_MEM_STAT));
861 gimple_debug_source_bind_set_var (p, var);
862 gimple_debug_source_bind_set_value (p, value);
863 if (stmt)
864 gimple_set_location (p, gimple_location (stmt));
866 return p;
870 /* Build a new GIMPLE_DEBUG_BEGIN_STMT statement in BLOCK at
871 LOCATION. */
873 gdebug *
874 gimple_build_debug_begin_stmt (tree block, location_t location
875 MEM_STAT_DECL)
877 gdebug *p
878 = as_a <gdebug *> (
879 gimple_build_with_ops_stat (GIMPLE_DEBUG,
880 (unsigned)GIMPLE_DEBUG_BEGIN_STMT, 0
881 PASS_MEM_STAT));
883 gimple_set_location (p, location);
884 gimple_set_block (p, block);
885 cfun->debug_marker_count++;
887 return p;
891 /* Build a new GIMPLE_DEBUG_INLINE_ENTRY statement in BLOCK at
892 LOCATION. The BLOCK links to the inlined function. */
894 gdebug *
895 gimple_build_debug_inline_entry (tree block, location_t location
896 MEM_STAT_DECL)
898 gdebug *p
899 = as_a <gdebug *> (
900 gimple_build_with_ops_stat (GIMPLE_DEBUG,
901 (unsigned)GIMPLE_DEBUG_INLINE_ENTRY, 0
902 PASS_MEM_STAT));
904 gimple_set_location (p, location);
905 gimple_set_block (p, block);
906 cfun->debug_marker_count++;
908 return p;
912 /* Build a GIMPLE_OMP_CRITICAL statement.
914 BODY is the sequence of statements for which only one thread can execute.
915 NAME is optional identifier for this critical block.
916 CLAUSES are clauses for this critical block. */
918 gomp_critical *
919 gimple_build_omp_critical (gimple_seq body, tree name, tree clauses)
921 gomp_critical *p
922 = as_a <gomp_critical *> (gimple_alloc (GIMPLE_OMP_CRITICAL, 0));
923 gimple_omp_critical_set_name (p, name);
924 gimple_omp_critical_set_clauses (p, clauses);
925 if (body)
926 gimple_omp_set_body (p, body);
928 return p;
931 /* Build a GIMPLE_OMP_FOR statement.
933 BODY is sequence of statements inside the for loop.
934 KIND is the `for' variant.
935 CLAUSES are any of the construct's clauses.
936 COLLAPSE is the collapse count.
937 PRE_BODY is the sequence of statements that are loop invariant. */
939 gomp_for *
940 gimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse,
941 gimple_seq pre_body)
943 gomp_for *p = as_a <gomp_for *> (gimple_alloc (GIMPLE_OMP_FOR, 0));
944 if (body)
945 gimple_omp_set_body (p, body);
946 gimple_omp_for_set_clauses (p, clauses);
947 gimple_omp_for_set_kind (p, kind);
948 p->collapse = collapse;
949 p->iter = ggc_cleared_vec_alloc<gimple_omp_for_iter> (collapse);
951 if (pre_body)
952 gimple_omp_for_set_pre_body (p, pre_body);
954 return p;
958 /* Build a GIMPLE_OMP_PARALLEL statement.
960 BODY is sequence of statements which are executed in parallel.
961 CLAUSES are the OMP parallel construct's clauses.
962 CHILD_FN is the function created for the parallel threads to execute.
963 DATA_ARG are the shared data argument(s). */
965 gomp_parallel *
966 gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
967 tree data_arg)
969 gomp_parallel *p
970 = as_a <gomp_parallel *> (gimple_alloc (GIMPLE_OMP_PARALLEL, 0));
971 if (body)
972 gimple_omp_set_body (p, body);
973 gimple_omp_parallel_set_clauses (p, clauses);
974 gimple_omp_parallel_set_child_fn (p, child_fn);
975 gimple_omp_parallel_set_data_arg (p, data_arg);
977 return p;
981 /* Build a GIMPLE_OMP_TASK statement.
983 BODY is sequence of statements which are executed by the explicit task.
984 CLAUSES are the OMP task construct's clauses.
985 CHILD_FN is the function created for the parallel threads to execute.
986 DATA_ARG are the shared data argument(s).
987 COPY_FN is the optional function for firstprivate initialization.
988 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
990 gomp_task *
991 gimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn,
992 tree data_arg, tree copy_fn, tree arg_size,
993 tree arg_align)
995 gomp_task *p = as_a <gomp_task *> (gimple_alloc (GIMPLE_OMP_TASK, 0));
996 if (body)
997 gimple_omp_set_body (p, body);
998 gimple_omp_task_set_clauses (p, clauses);
999 gimple_omp_task_set_child_fn (p, child_fn);
1000 gimple_omp_task_set_data_arg (p, data_arg);
1001 gimple_omp_task_set_copy_fn (p, copy_fn);
1002 gimple_omp_task_set_arg_size (p, arg_size);
1003 gimple_omp_task_set_arg_align (p, arg_align);
1005 return p;
1009 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
1011 BODY is the sequence of statements in the section. */
1013 gimple *
1014 gimple_build_omp_section (gimple_seq body)
1016 gimple *p = gimple_alloc (GIMPLE_OMP_SECTION, 0);
1017 if (body)
1018 gimple_omp_set_body (p, body);
1020 return p;
1024 /* Build a GIMPLE_OMP_MASTER statement.
1026 BODY is the sequence of statements to be executed by just the master. */
1028 gimple *
1029 gimple_build_omp_master (gimple_seq body)
1031 gimple *p = gimple_alloc (GIMPLE_OMP_MASTER, 0);
1032 if (body)
1033 gimple_omp_set_body (p, body);
1035 return p;
1038 /* Build a GIMPLE_OMP_TASKGROUP statement.
1040 BODY is the sequence of statements to be executed by the taskgroup
1041 construct.
1042 CLAUSES are any of the construct's clauses. */
1044 gimple *
1045 gimple_build_omp_taskgroup (gimple_seq body, tree clauses)
1047 gimple *p = gimple_alloc (GIMPLE_OMP_TASKGROUP, 0);
1048 gimple_omp_taskgroup_set_clauses (p, clauses);
1049 if (body)
1050 gimple_omp_set_body (p, body);
1052 return p;
1056 /* Build a GIMPLE_OMP_CONTINUE statement.
1058 CONTROL_DEF is the definition of the control variable.
1059 CONTROL_USE is the use of the control variable. */
1061 gomp_continue *
1062 gimple_build_omp_continue (tree control_def, tree control_use)
1064 gomp_continue *p
1065 = as_a <gomp_continue *> (gimple_alloc (GIMPLE_OMP_CONTINUE, 0));
1066 gimple_omp_continue_set_control_def (p, control_def);
1067 gimple_omp_continue_set_control_use (p, control_use);
1068 return p;
1071 /* Build a GIMPLE_OMP_ORDERED statement.
1073 BODY is the sequence of statements inside a loop that will executed in
1074 sequence.
1075 CLAUSES are clauses for this statement. */
1077 gomp_ordered *
1078 gimple_build_omp_ordered (gimple_seq body, tree clauses)
1080 gomp_ordered *p
1081 = as_a <gomp_ordered *> (gimple_alloc (GIMPLE_OMP_ORDERED, 0));
1082 gimple_omp_ordered_set_clauses (p, clauses);
1083 if (body)
1084 gimple_omp_set_body (p, body);
1086 return p;
1090 /* Build a GIMPLE_OMP_RETURN statement.
1091 WAIT_P is true if this is a non-waiting return. */
1093 gimple *
1094 gimple_build_omp_return (bool wait_p)
1096 gimple *p = gimple_alloc (GIMPLE_OMP_RETURN, 0);
1097 if (wait_p)
1098 gimple_omp_return_set_nowait (p);
1100 return p;
1104 /* Build a GIMPLE_OMP_SCAN statement.
1106 BODY is the sequence of statements to be executed by the scan
1107 construct.
1108 CLAUSES are any of the construct's clauses. */
1110 gomp_scan *
1111 gimple_build_omp_scan (gimple_seq body, tree clauses)
1113 gomp_scan *p
1114 = as_a <gomp_scan *> (gimple_alloc (GIMPLE_OMP_SCAN, 0));
1115 gimple_omp_scan_set_clauses (p, clauses);
1116 if (body)
1117 gimple_omp_set_body (p, body);
1119 return p;
1123 /* Build a GIMPLE_OMP_SECTIONS statement.
1125 BODY is a sequence of section statements.
1126 CLAUSES are any of the OMP sections contsruct's clauses: private,
1127 firstprivate, lastprivate, reduction, and nowait. */
1129 gomp_sections *
1130 gimple_build_omp_sections (gimple_seq body, tree clauses)
1132 gomp_sections *p
1133 = as_a <gomp_sections *> (gimple_alloc (GIMPLE_OMP_SECTIONS, 0));
1134 if (body)
1135 gimple_omp_set_body (p, body);
1136 gimple_omp_sections_set_clauses (p, clauses);
1138 return p;
1142 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1144 gimple *
1145 gimple_build_omp_sections_switch (void)
1147 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH, 0);
1151 /* Build a GIMPLE_OMP_SINGLE statement.
1153 BODY is the sequence of statements that will be executed once.
1154 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1155 copyprivate, nowait. */
1157 gomp_single *
1158 gimple_build_omp_single (gimple_seq body, tree clauses)
1160 gomp_single *p
1161 = as_a <gomp_single *> (gimple_alloc (GIMPLE_OMP_SINGLE, 0));
1162 if (body)
1163 gimple_omp_set_body (p, body);
1164 gimple_omp_single_set_clauses (p, clauses);
1166 return p;
1170 /* Build a GIMPLE_OMP_TARGET statement.
1172 BODY is the sequence of statements that will be executed.
1173 KIND is the kind of the region.
1174 CLAUSES are any of the construct's clauses. */
1176 gomp_target *
1177 gimple_build_omp_target (gimple_seq body, int kind, tree clauses)
1179 gomp_target *p
1180 = as_a <gomp_target *> (gimple_alloc (GIMPLE_OMP_TARGET, 0));
1181 if (body)
1182 gimple_omp_set_body (p, body);
1183 gimple_omp_target_set_clauses (p, clauses);
1184 gimple_omp_target_set_kind (p, kind);
1186 return p;
1190 /* Build a GIMPLE_OMP_TEAMS statement.
1192 BODY is the sequence of statements that will be executed.
1193 CLAUSES are any of the OMP teams construct's clauses. */
1195 gomp_teams *
1196 gimple_build_omp_teams (gimple_seq body, tree clauses)
1198 gomp_teams *p = as_a <gomp_teams *> (gimple_alloc (GIMPLE_OMP_TEAMS, 0));
1199 if (body)
1200 gimple_omp_set_body (p, body);
1201 gimple_omp_teams_set_clauses (p, clauses);
1203 return p;
1207 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1209 gomp_atomic_load *
1210 gimple_build_omp_atomic_load (tree lhs, tree rhs, enum omp_memory_order mo)
1212 gomp_atomic_load *p
1213 = as_a <gomp_atomic_load *> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0));
1214 gimple_omp_atomic_load_set_lhs (p, lhs);
1215 gimple_omp_atomic_load_set_rhs (p, rhs);
1216 gimple_omp_atomic_set_memory_order (p, mo);
1217 return p;
1220 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1222 VAL is the value we are storing. */
1224 gomp_atomic_store *
1225 gimple_build_omp_atomic_store (tree val, enum omp_memory_order mo)
1227 gomp_atomic_store *p
1228 = as_a <gomp_atomic_store *> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE, 0));
1229 gimple_omp_atomic_store_set_val (p, val);
1230 gimple_omp_atomic_set_memory_order (p, mo);
1231 return p;
1234 /* Build a GIMPLE_TRANSACTION statement. */
1236 gtransaction *
1237 gimple_build_transaction (gimple_seq body)
1239 gtransaction *p
1240 = as_a <gtransaction *> (gimple_alloc (GIMPLE_TRANSACTION, 0));
1241 gimple_transaction_set_body (p, body);
1242 gimple_transaction_set_label_norm (p, 0);
1243 gimple_transaction_set_label_uninst (p, 0);
1244 gimple_transaction_set_label_over (p, 0);
1245 return p;
1248 #if defined ENABLE_GIMPLE_CHECKING
1249 /* Complain of a gimple type mismatch and die. */
1251 void
1252 gimple_check_failed (const gimple *gs, const char *file, int line,
1253 const char *function, enum gimple_code code,
1254 enum tree_code subcode)
1256 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1257 gimple_code_name[code],
1258 get_tree_code_name (subcode),
1259 gimple_code_name[gimple_code (gs)],
1260 gs->subcode > 0
1261 ? get_tree_code_name ((enum tree_code) gs->subcode)
1262 : "",
1263 function, trim_filename (file), line);
1265 #endif /* ENABLE_GIMPLE_CHECKING */
1268 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1269 *SEQ_P is NULL, a new sequence is allocated. */
1271 void
1272 gimple_seq_add_stmt (gimple_seq *seq_p, gimple *gs)
1274 gimple_stmt_iterator si;
1275 if (gs == NULL)
1276 return;
1278 si = gsi_last (*seq_p);
1279 gsi_insert_after (&si, gs, GSI_NEW_STMT);
1282 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1283 *SEQ_P is NULL, a new sequence is allocated. This function is
1284 similar to gimple_seq_add_stmt, but does not scan the operands.
1285 During gimplification, we need to manipulate statement sequences
1286 before the def/use vectors have been constructed. */
1288 void
1289 gimple_seq_add_stmt_without_update (gimple_seq *seq_p, gimple *gs)
1291 gimple_stmt_iterator si;
1293 if (gs == NULL)
1294 return;
1296 si = gsi_last (*seq_p);
1297 gsi_insert_after_without_update (&si, gs, GSI_NEW_STMT);
1300 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1301 NULL, a new sequence is allocated. */
1303 void
1304 gimple_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
1306 gimple_stmt_iterator si;
1307 if (src == NULL)
1308 return;
1310 si = gsi_last (*dst_p);
1311 gsi_insert_seq_after (&si, src, GSI_NEW_STMT);
1314 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1315 NULL, a new sequence is allocated. This function is
1316 similar to gimple_seq_add_seq, but does not scan the operands. */
1318 void
1319 gimple_seq_add_seq_without_update (gimple_seq *dst_p, gimple_seq src)
1321 gimple_stmt_iterator si;
1322 if (src == NULL)
1323 return;
1325 si = gsi_last (*dst_p);
1326 gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
1329 /* Determine whether to assign a location to the statement GS. */
1331 static bool
1332 should_carry_location_p (gimple *gs)
1334 /* Don't emit a line note for a label. We particularly don't want to
1335 emit one for the break label, since it doesn't actually correspond
1336 to the beginning of the loop/switch. */
1337 if (gimple_code (gs) == GIMPLE_LABEL)
1338 return false;
1340 return true;
1343 /* Set the location for gimple statement GS to LOCATION. */
1345 static void
1346 annotate_one_with_location (gimple *gs, location_t location)
1348 if (!gimple_has_location (gs)
1349 && !gimple_do_not_emit_location_p (gs)
1350 && should_carry_location_p (gs))
1351 gimple_set_location (gs, location);
1354 /* Set LOCATION for all the statements after iterator GSI in sequence
1355 SEQ. If GSI is pointing to the end of the sequence, start with the
1356 first statement in SEQ. */
1358 void
1359 annotate_all_with_location_after (gimple_seq seq, gimple_stmt_iterator gsi,
1360 location_t location)
1362 if (gsi_end_p (gsi))
1363 gsi = gsi_start (seq);
1364 else
1365 gsi_next (&gsi);
1367 for (; !gsi_end_p (gsi); gsi_next (&gsi))
1368 annotate_one_with_location (gsi_stmt (gsi), location);
1371 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1373 void
1374 annotate_all_with_location (gimple_seq stmt_p, location_t location)
1376 gimple_stmt_iterator i;
1378 if (gimple_seq_empty_p (stmt_p))
1379 return;
1381 for (i = gsi_start (stmt_p); !gsi_end_p (i); gsi_next (&i))
1383 gimple *gs = gsi_stmt (i);
1384 annotate_one_with_location (gs, location);
1388 /* Helper function of empty_body_p. Return true if STMT is an empty
1389 statement. */
1391 static bool
1392 empty_stmt_p (gimple *stmt)
1394 if (gimple_code (stmt) == GIMPLE_NOP)
1395 return true;
1396 if (gbind *bind_stmt = dyn_cast <gbind *> (stmt))
1397 return empty_body_p (gimple_bind_body (bind_stmt));
1398 return false;
1402 /* Return true if BODY contains nothing but empty statements. */
1404 bool
1405 empty_body_p (gimple_seq body)
1407 gimple_stmt_iterator i;
1409 if (gimple_seq_empty_p (body))
1410 return true;
1411 for (i = gsi_start (body); !gsi_end_p (i); gsi_next (&i))
1412 if (!empty_stmt_p (gsi_stmt (i))
1413 && !is_gimple_debug (gsi_stmt (i)))
1414 return false;
1416 return true;
1420 /* Perform a deep copy of sequence SRC and return the result. */
1422 gimple_seq
1423 gimple_seq_copy (gimple_seq src)
1425 gimple_stmt_iterator gsi;
1426 gimple_seq new_seq = NULL;
1427 gimple *stmt;
1429 for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi))
1431 stmt = gimple_copy (gsi_stmt (gsi));
1432 gimple_seq_add_stmt (&new_seq, stmt);
1435 return new_seq;
1440 /* Return true if calls C1 and C2 are known to go to the same function. */
1442 bool
1443 gimple_call_same_target_p (const gimple *c1, const gimple *c2)
1445 if (gimple_call_internal_p (c1))
1446 return (gimple_call_internal_p (c2)
1447 && gimple_call_internal_fn (c1) == gimple_call_internal_fn (c2)
1448 && (!gimple_call_internal_unique_p (as_a <const gcall *> (c1))
1449 || c1 == c2));
1450 else
1451 return (gimple_call_fn (c1) == gimple_call_fn (c2)
1452 || (gimple_call_fndecl (c1)
1453 && gimple_call_fndecl (c1) == gimple_call_fndecl (c2)));
1456 /* Detect flags from a GIMPLE_CALL. This is just like
1457 call_expr_flags, but for gimple tuples. */
1460 gimple_call_flags (const gimple *stmt)
1462 int flags = 0;
1464 if (gimple_call_internal_p (stmt))
1465 flags = internal_fn_flags (gimple_call_internal_fn (stmt));
1466 else
1468 tree decl = gimple_call_fndecl (stmt);
1469 if (decl)
1470 flags = flags_from_decl_or_type (decl);
1471 flags |= flags_from_decl_or_type (gimple_call_fntype (stmt));
1474 if (stmt->subcode & GF_CALL_NOTHROW)
1475 flags |= ECF_NOTHROW;
1477 if (stmt->subcode & GF_CALL_BY_DESCRIPTOR)
1478 flags |= ECF_BY_DESCRIPTOR;
1480 return flags;
1483 /* Return the "fn spec" string for call STMT. */
1485 static const_tree
1486 gimple_call_fnspec (const gcall *stmt)
1488 tree type, attr;
1490 if (gimple_call_internal_p (stmt))
1491 return internal_fn_fnspec (gimple_call_internal_fn (stmt));
1493 type = gimple_call_fntype (stmt);
1494 if (!type)
1495 return NULL_TREE;
1497 attr = lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type));
1498 if (!attr)
1499 return NULL_TREE;
1501 return TREE_VALUE (TREE_VALUE (attr));
1504 /* Detects argument flags for argument number ARG on call STMT. */
1507 gimple_call_arg_flags (const gcall *stmt, unsigned arg)
1509 const_tree attr = gimple_call_fnspec (stmt);
1511 if (!attr || 1 + arg >= (unsigned) TREE_STRING_LENGTH (attr))
1512 return 0;
1514 switch (TREE_STRING_POINTER (attr)[1 + arg])
1516 case 'x':
1517 case 'X':
1518 return EAF_UNUSED;
1520 case 'R':
1521 return EAF_DIRECT | EAF_NOCLOBBER | EAF_NOESCAPE;
1523 case 'r':
1524 return EAF_NOCLOBBER | EAF_NOESCAPE;
1526 case 'W':
1527 return EAF_DIRECT | EAF_NOESCAPE;
1529 case 'w':
1530 return EAF_NOESCAPE;
1532 case '.':
1533 default:
1534 return 0;
1538 /* Detects return flags for the call STMT. */
1541 gimple_call_return_flags (const gcall *stmt)
1543 const_tree attr;
1545 if (gimple_call_flags (stmt) & ECF_MALLOC)
1546 return ERF_NOALIAS;
1548 attr = gimple_call_fnspec (stmt);
1549 if (!attr || TREE_STRING_LENGTH (attr) < 1)
1550 return 0;
1552 switch (TREE_STRING_POINTER (attr)[0])
1554 case '1':
1555 case '2':
1556 case '3':
1557 case '4':
1558 return ERF_RETURNS_ARG | (TREE_STRING_POINTER (attr)[0] - '1');
1560 case 'm':
1561 return ERF_NOALIAS;
1563 case '.':
1564 default:
1565 return 0;
1570 /* Return true if call STMT is known to return a non-zero result. */
1572 bool
1573 gimple_call_nonnull_result_p (gcall *call)
1575 tree fndecl = gimple_call_fndecl (call);
1576 if (!fndecl)
1577 return false;
1578 if (flag_delete_null_pointer_checks && !flag_check_new
1579 && DECL_IS_OPERATOR_NEW_P (fndecl)
1580 && !TREE_NOTHROW (fndecl))
1581 return true;
1583 /* References are always non-NULL. */
1584 if (flag_delete_null_pointer_checks
1585 && TREE_CODE (TREE_TYPE (fndecl)) == REFERENCE_TYPE)
1586 return true;
1588 if (flag_delete_null_pointer_checks
1589 && lookup_attribute ("returns_nonnull",
1590 TYPE_ATTRIBUTES (gimple_call_fntype (call))))
1591 return true;
1592 return gimple_alloca_call_p (call);
1596 /* If CALL returns a non-null result in an argument, return that arg. */
1598 tree
1599 gimple_call_nonnull_arg (gcall *call)
1601 tree fndecl = gimple_call_fndecl (call);
1602 if (!fndecl)
1603 return NULL_TREE;
1605 unsigned rf = gimple_call_return_flags (call);
1606 if (rf & ERF_RETURNS_ARG)
1608 unsigned argnum = rf & ERF_RETURN_ARG_MASK;
1609 if (argnum < gimple_call_num_args (call))
1611 tree arg = gimple_call_arg (call, argnum);
1612 if (SSA_VAR_P (arg)
1613 && infer_nonnull_range_by_attribute (call, arg))
1614 return arg;
1617 return NULL_TREE;
1621 /* Return true if GS is a copy assignment. */
1623 bool
1624 gimple_assign_copy_p (gimple *gs)
1626 return (gimple_assign_single_p (gs)
1627 && is_gimple_val (gimple_op (gs, 1)));
1631 /* Return true if GS is a SSA_NAME copy assignment. */
1633 bool
1634 gimple_assign_ssa_name_copy_p (gimple *gs)
1636 return (gimple_assign_single_p (gs)
1637 && TREE_CODE (gimple_assign_lhs (gs)) == SSA_NAME
1638 && TREE_CODE (gimple_assign_rhs1 (gs)) == SSA_NAME);
1642 /* Return true if GS is an assignment with a unary RHS, but the
1643 operator has no effect on the assigned value. The logic is adapted
1644 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1645 instances in which STRIP_NOPS was previously applied to the RHS of
1646 an assignment.
1648 NOTE: In the use cases that led to the creation of this function
1649 and of gimple_assign_single_p, it is typical to test for either
1650 condition and to proceed in the same manner. In each case, the
1651 assigned value is represented by the single RHS operand of the
1652 assignment. I suspect there may be cases where gimple_assign_copy_p,
1653 gimple_assign_single_p, or equivalent logic is used where a similar
1654 treatment of unary NOPs is appropriate. */
1656 bool
1657 gimple_assign_unary_nop_p (gimple *gs)
1659 return (is_gimple_assign (gs)
1660 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
1661 || gimple_assign_rhs_code (gs) == NON_LVALUE_EXPR)
1662 && gimple_assign_rhs1 (gs) != error_mark_node
1663 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs)))
1664 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs)))));
1667 /* Set BB to be the basic block holding G. */
1669 void
1670 gimple_set_bb (gimple *stmt, basic_block bb)
1672 stmt->bb = bb;
1674 if (gimple_code (stmt) != GIMPLE_LABEL)
1675 return;
1677 /* If the statement is a label, add the label to block-to-labels map
1678 so that we can speed up edge creation for GIMPLE_GOTOs. */
1679 if (cfun->cfg)
1681 tree t;
1682 int uid;
1684 t = gimple_label_label (as_a <glabel *> (stmt));
1685 uid = LABEL_DECL_UID (t);
1686 if (uid == -1)
1688 unsigned old_len =
1689 vec_safe_length (label_to_block_map_for_fn (cfun));
1690 LABEL_DECL_UID (t) = uid = cfun->cfg->last_label_uid++;
1691 if (old_len <= (unsigned) uid)
1692 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun), uid + 1);
1695 (*label_to_block_map_for_fn (cfun))[uid] = bb;
1700 /* Modify the RHS of the assignment pointed-to by GSI using the
1701 operands in the expression tree EXPR.
1703 NOTE: The statement pointed-to by GSI may be reallocated if it
1704 did not have enough operand slots.
1706 This function is useful to convert an existing tree expression into
1707 the flat representation used for the RHS of a GIMPLE assignment.
1708 It will reallocate memory as needed to expand or shrink the number
1709 of operand slots needed to represent EXPR.
1711 NOTE: If you find yourself building a tree and then calling this
1712 function, you are most certainly doing it the slow way. It is much
1713 better to build a new assignment or to use the function
1714 gimple_assign_set_rhs_with_ops, which does not require an
1715 expression tree to be built. */
1717 void
1718 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *gsi, tree expr)
1720 enum tree_code subcode;
1721 tree op1, op2, op3;
1723 extract_ops_from_tree (expr, &subcode, &op1, &op2, &op3);
1724 gimple_assign_set_rhs_with_ops (gsi, subcode, op1, op2, op3);
1728 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1729 operands OP1, OP2 and OP3.
1731 NOTE: The statement pointed-to by GSI may be reallocated if it
1732 did not have enough operand slots. */
1734 void
1735 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
1736 tree op1, tree op2, tree op3)
1738 unsigned new_rhs_ops = get_gimple_rhs_num_ops (code);
1739 gimple *stmt = gsi_stmt (*gsi);
1740 gimple *old_stmt = stmt;
1742 /* If the new CODE needs more operands, allocate a new statement. */
1743 if (gimple_num_ops (stmt) < new_rhs_ops + 1)
1745 tree lhs = gimple_assign_lhs (old_stmt);
1746 stmt = gimple_alloc (gimple_code (old_stmt), new_rhs_ops + 1);
1747 memcpy (stmt, old_stmt, gimple_size (gimple_code (old_stmt)));
1748 gimple_init_singleton (stmt);
1750 /* The LHS needs to be reset as this also changes the SSA name
1751 on the LHS. */
1752 gimple_assign_set_lhs (stmt, lhs);
1755 gimple_set_num_ops (stmt, new_rhs_ops + 1);
1756 gimple_set_subcode (stmt, code);
1757 gimple_assign_set_rhs1 (stmt, op1);
1758 if (new_rhs_ops > 1)
1759 gimple_assign_set_rhs2 (stmt, op2);
1760 if (new_rhs_ops > 2)
1761 gimple_assign_set_rhs3 (stmt, op3);
1762 if (stmt != old_stmt)
1763 gsi_replace (gsi, stmt, false);
1767 /* Return the LHS of a statement that performs an assignment,
1768 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1769 for a call to a function that returns no value, or for a
1770 statement other than an assignment or a call. */
1772 tree
1773 gimple_get_lhs (const gimple *stmt)
1775 enum gimple_code code = gimple_code (stmt);
1777 if (code == GIMPLE_ASSIGN)
1778 return gimple_assign_lhs (stmt);
1779 else if (code == GIMPLE_CALL)
1780 return gimple_call_lhs (stmt);
1781 else if (code == GIMPLE_PHI)
1782 return gimple_phi_result (stmt);
1783 else
1784 return NULL_TREE;
1788 /* Set the LHS of a statement that performs an assignment,
1789 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1791 void
1792 gimple_set_lhs (gimple *stmt, tree lhs)
1794 enum gimple_code code = gimple_code (stmt);
1796 if (code == GIMPLE_ASSIGN)
1797 gimple_assign_set_lhs (stmt, lhs);
1798 else if (code == GIMPLE_CALL)
1799 gimple_call_set_lhs (stmt, lhs);
1800 else
1801 gcc_unreachable ();
1805 /* Return a deep copy of statement STMT. All the operands from STMT
1806 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1807 and VUSE operand arrays are set to empty in the new copy. The new
1808 copy isn't part of any sequence. */
1810 gimple *
1811 gimple_copy (gimple *stmt)
1813 enum gimple_code code = gimple_code (stmt);
1814 unsigned num_ops = gimple_num_ops (stmt);
1815 gimple *copy = gimple_alloc (code, num_ops);
1816 unsigned i;
1818 /* Shallow copy all the fields from STMT. */
1819 memcpy (copy, stmt, gimple_size (code));
1820 gimple_init_singleton (copy);
1822 /* If STMT has sub-statements, deep-copy them as well. */
1823 if (gimple_has_substatements (stmt))
1825 gimple_seq new_seq;
1826 tree t;
1828 switch (gimple_code (stmt))
1830 case GIMPLE_BIND:
1832 gbind *bind_stmt = as_a <gbind *> (stmt);
1833 gbind *bind_copy = as_a <gbind *> (copy);
1834 new_seq = gimple_seq_copy (gimple_bind_body (bind_stmt));
1835 gimple_bind_set_body (bind_copy, new_seq);
1836 gimple_bind_set_vars (bind_copy,
1837 unshare_expr (gimple_bind_vars (bind_stmt)));
1838 gimple_bind_set_block (bind_copy, gimple_bind_block (bind_stmt));
1840 break;
1842 case GIMPLE_CATCH:
1844 gcatch *catch_stmt = as_a <gcatch *> (stmt);
1845 gcatch *catch_copy = as_a <gcatch *> (copy);
1846 new_seq = gimple_seq_copy (gimple_catch_handler (catch_stmt));
1847 gimple_catch_set_handler (catch_copy, new_seq);
1848 t = unshare_expr (gimple_catch_types (catch_stmt));
1849 gimple_catch_set_types (catch_copy, t);
1851 break;
1853 case GIMPLE_EH_FILTER:
1855 geh_filter *eh_filter_stmt = as_a <geh_filter *> (stmt);
1856 geh_filter *eh_filter_copy = as_a <geh_filter *> (copy);
1857 new_seq
1858 = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt));
1859 gimple_eh_filter_set_failure (eh_filter_copy, new_seq);
1860 t = unshare_expr (gimple_eh_filter_types (eh_filter_stmt));
1861 gimple_eh_filter_set_types (eh_filter_copy, t);
1863 break;
1865 case GIMPLE_EH_ELSE:
1867 geh_else *eh_else_stmt = as_a <geh_else *> (stmt);
1868 geh_else *eh_else_copy = as_a <geh_else *> (copy);
1869 new_seq = gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt));
1870 gimple_eh_else_set_n_body (eh_else_copy, new_seq);
1871 new_seq = gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt));
1872 gimple_eh_else_set_e_body (eh_else_copy, new_seq);
1874 break;
1876 case GIMPLE_TRY:
1878 gtry *try_stmt = as_a <gtry *> (stmt);
1879 gtry *try_copy = as_a <gtry *> (copy);
1880 new_seq = gimple_seq_copy (gimple_try_eval (try_stmt));
1881 gimple_try_set_eval (try_copy, new_seq);
1882 new_seq = gimple_seq_copy (gimple_try_cleanup (try_stmt));
1883 gimple_try_set_cleanup (try_copy, new_seq);
1885 break;
1887 case GIMPLE_OMP_FOR:
1888 new_seq = gimple_seq_copy (gimple_omp_for_pre_body (stmt));
1889 gimple_omp_for_set_pre_body (copy, new_seq);
1890 t = unshare_expr (gimple_omp_for_clauses (stmt));
1891 gimple_omp_for_set_clauses (copy, t);
1893 gomp_for *omp_for_copy = as_a <gomp_for *> (copy);
1894 omp_for_copy->iter = ggc_vec_alloc<gimple_omp_for_iter>
1895 ( gimple_omp_for_collapse (stmt));
1897 for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
1899 gimple_omp_for_set_cond (copy, i,
1900 gimple_omp_for_cond (stmt, i));
1901 gimple_omp_for_set_index (copy, i,
1902 gimple_omp_for_index (stmt, i));
1903 t = unshare_expr (gimple_omp_for_initial (stmt, i));
1904 gimple_omp_for_set_initial (copy, i, t);
1905 t = unshare_expr (gimple_omp_for_final (stmt, i));
1906 gimple_omp_for_set_final (copy, i, t);
1907 t = unshare_expr (gimple_omp_for_incr (stmt, i));
1908 gimple_omp_for_set_incr (copy, i, t);
1910 goto copy_omp_body;
1912 case GIMPLE_OMP_PARALLEL:
1914 gomp_parallel *omp_par_stmt = as_a <gomp_parallel *> (stmt);
1915 gomp_parallel *omp_par_copy = as_a <gomp_parallel *> (copy);
1916 t = unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt));
1917 gimple_omp_parallel_set_clauses (omp_par_copy, t);
1918 t = unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt));
1919 gimple_omp_parallel_set_child_fn (omp_par_copy, t);
1920 t = unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt));
1921 gimple_omp_parallel_set_data_arg (omp_par_copy, t);
1923 goto copy_omp_body;
1925 case GIMPLE_OMP_TASK:
1926 t = unshare_expr (gimple_omp_task_clauses (stmt));
1927 gimple_omp_task_set_clauses (copy, t);
1928 t = unshare_expr (gimple_omp_task_child_fn (stmt));
1929 gimple_omp_task_set_child_fn (copy, t);
1930 t = unshare_expr (gimple_omp_task_data_arg (stmt));
1931 gimple_omp_task_set_data_arg (copy, t);
1932 t = unshare_expr (gimple_omp_task_copy_fn (stmt));
1933 gimple_omp_task_set_copy_fn (copy, t);
1934 t = unshare_expr (gimple_omp_task_arg_size (stmt));
1935 gimple_omp_task_set_arg_size (copy, t);
1936 t = unshare_expr (gimple_omp_task_arg_align (stmt));
1937 gimple_omp_task_set_arg_align (copy, t);
1938 goto copy_omp_body;
1940 case GIMPLE_OMP_CRITICAL:
1941 t = unshare_expr (gimple_omp_critical_name
1942 (as_a <gomp_critical *> (stmt)));
1943 gimple_omp_critical_set_name (as_a <gomp_critical *> (copy), t);
1944 t = unshare_expr (gimple_omp_critical_clauses
1945 (as_a <gomp_critical *> (stmt)));
1946 gimple_omp_critical_set_clauses (as_a <gomp_critical *> (copy), t);
1947 goto copy_omp_body;
1949 case GIMPLE_OMP_ORDERED:
1950 t = unshare_expr (gimple_omp_ordered_clauses
1951 (as_a <gomp_ordered *> (stmt)));
1952 gimple_omp_ordered_set_clauses (as_a <gomp_ordered *> (copy), t);
1953 goto copy_omp_body;
1955 case GIMPLE_OMP_SCAN:
1956 t = gimple_omp_scan_clauses (as_a <gomp_scan *> (stmt));
1957 t = unshare_expr (t);
1958 gimple_omp_scan_set_clauses (as_a <gomp_scan *> (copy), t);
1959 goto copy_omp_body;
1961 case GIMPLE_OMP_TASKGROUP:
1962 t = unshare_expr (gimple_omp_taskgroup_clauses (stmt));
1963 gimple_omp_taskgroup_set_clauses (copy, t);
1964 goto copy_omp_body;
1966 case GIMPLE_OMP_SECTIONS:
1967 t = unshare_expr (gimple_omp_sections_clauses (stmt));
1968 gimple_omp_sections_set_clauses (copy, t);
1969 t = unshare_expr (gimple_omp_sections_control (stmt));
1970 gimple_omp_sections_set_control (copy, t);
1971 goto copy_omp_body;
1973 case GIMPLE_OMP_SINGLE:
1975 gomp_single *omp_single_copy = as_a <gomp_single *> (copy);
1976 t = unshare_expr (gimple_omp_single_clauses (stmt));
1977 gimple_omp_single_set_clauses (omp_single_copy, t);
1979 goto copy_omp_body;
1981 case GIMPLE_OMP_TARGET:
1983 gomp_target *omp_target_stmt = as_a <gomp_target *> (stmt);
1984 gomp_target *omp_target_copy = as_a <gomp_target *> (copy);
1985 t = unshare_expr (gimple_omp_target_clauses (omp_target_stmt));
1986 gimple_omp_target_set_clauses (omp_target_copy, t);
1987 t = unshare_expr (gimple_omp_target_data_arg (omp_target_stmt));
1988 gimple_omp_target_set_data_arg (omp_target_copy, t);
1990 goto copy_omp_body;
1992 case GIMPLE_OMP_TEAMS:
1994 gomp_teams *omp_teams_copy = as_a <gomp_teams *> (copy);
1995 t = unshare_expr (gimple_omp_teams_clauses (stmt));
1996 gimple_omp_teams_set_clauses (omp_teams_copy, t);
1998 /* FALLTHRU */
2000 case GIMPLE_OMP_SECTION:
2001 case GIMPLE_OMP_MASTER:
2002 copy_omp_body:
2003 new_seq = gimple_seq_copy (gimple_omp_body (stmt));
2004 gimple_omp_set_body (copy, new_seq);
2005 break;
2007 case GIMPLE_TRANSACTION:
2008 new_seq = gimple_seq_copy (gimple_transaction_body (
2009 as_a <gtransaction *> (stmt)));
2010 gimple_transaction_set_body (as_a <gtransaction *> (copy),
2011 new_seq);
2012 break;
2014 case GIMPLE_WITH_CLEANUP_EXPR:
2015 new_seq = gimple_seq_copy (gimple_wce_cleanup (stmt));
2016 gimple_wce_set_cleanup (copy, new_seq);
2017 break;
2019 default:
2020 gcc_unreachable ();
2024 /* Make copy of operands. */
2025 for (i = 0; i < num_ops; i++)
2026 gimple_set_op (copy, i, unshare_expr (gimple_op (stmt, i)));
2028 if (gimple_has_mem_ops (stmt))
2030 gimple_set_vdef (copy, gimple_vdef (stmt));
2031 gimple_set_vuse (copy, gimple_vuse (stmt));
2034 /* Clear out SSA operand vectors on COPY. */
2035 if (gimple_has_ops (stmt))
2037 gimple_set_use_ops (copy, NULL);
2039 /* SSA operands need to be updated. */
2040 gimple_set_modified (copy, true);
2043 if (gimple_debug_nonbind_marker_p (stmt))
2044 cfun->debug_marker_count++;
2046 return copy;
2049 /* Move OLD_STMT's vuse and vdef operands to NEW_STMT, on the assumption
2050 that OLD_STMT is about to be removed. */
2052 void
2053 gimple_move_vops (gimple *new_stmt, gimple *old_stmt)
2055 tree vdef = gimple_vdef (old_stmt);
2056 gimple_set_vuse (new_stmt, gimple_vuse (old_stmt));
2057 gimple_set_vdef (new_stmt, vdef);
2058 if (vdef && TREE_CODE (vdef) == SSA_NAME)
2059 SSA_NAME_DEF_STMT (vdef) = new_stmt;
2062 /* Return true if statement S has side-effects. We consider a
2063 statement to have side effects if:
2065 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
2066 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
2068 bool
2069 gimple_has_side_effects (const gimple *s)
2071 if (is_gimple_debug (s))
2072 return false;
2074 /* We don't have to scan the arguments to check for
2075 volatile arguments, though, at present, we still
2076 do a scan to check for TREE_SIDE_EFFECTS. */
2077 if (gimple_has_volatile_ops (s))
2078 return true;
2080 if (gimple_code (s) == GIMPLE_ASM
2081 && gimple_asm_volatile_p (as_a <const gasm *> (s)))
2082 return true;
2084 if (is_gimple_call (s))
2086 int flags = gimple_call_flags (s);
2088 /* An infinite loop is considered a side effect. */
2089 if (!(flags & (ECF_CONST | ECF_PURE))
2090 || (flags & ECF_LOOPING_CONST_OR_PURE))
2091 return true;
2093 return false;
2096 return false;
2099 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
2100 Return true if S can trap. When INCLUDE_MEM is true, check whether
2101 the memory operations could trap. When INCLUDE_STORES is true and
2102 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
2104 bool
2105 gimple_could_trap_p_1 (gimple *s, bool include_mem, bool include_stores)
2107 tree t, div = NULL_TREE;
2108 enum tree_code op;
2110 if (include_mem)
2112 unsigned i, start = (is_gimple_assign (s) && !include_stores) ? 1 : 0;
2114 for (i = start; i < gimple_num_ops (s); i++)
2115 if (tree_could_trap_p (gimple_op (s, i)))
2116 return true;
2119 switch (gimple_code (s))
2121 case GIMPLE_ASM:
2122 return gimple_asm_volatile_p (as_a <gasm *> (s));
2124 case GIMPLE_CALL:
2125 t = gimple_call_fndecl (s);
2126 /* Assume that calls to weak functions may trap. */
2127 if (!t || !DECL_P (t) || DECL_WEAK (t))
2128 return true;
2129 return false;
2131 case GIMPLE_ASSIGN:
2132 op = gimple_assign_rhs_code (s);
2134 /* For COND_EXPR and VEC_COND_EXPR only the condition may trap. */
2135 if (op == COND_EXPR || op == VEC_COND_EXPR)
2136 return tree_could_trap_p (gimple_assign_rhs1 (s));
2138 /* For comparisons we need to check rhs operand types instead of rhs type
2139 (which is BOOLEAN_TYPE). */
2140 if (TREE_CODE_CLASS (op) == tcc_comparison)
2141 t = TREE_TYPE (gimple_assign_rhs1 (s));
2142 else
2143 t = gimple_expr_type (s);
2145 if (get_gimple_rhs_class (op) == GIMPLE_BINARY_RHS)
2146 div = gimple_assign_rhs2 (s);
2148 return (operation_could_trap_p (op, FLOAT_TYPE_P (t),
2149 (INTEGRAL_TYPE_P (t)
2150 && TYPE_OVERFLOW_TRAPS (t)),
2151 div));
2153 case GIMPLE_COND:
2154 t = TREE_TYPE (gimple_cond_lhs (s));
2155 return operation_could_trap_p (gimple_cond_code (s),
2156 FLOAT_TYPE_P (t), false, NULL_TREE);
2158 default:
2159 break;
2162 return false;
2165 /* Return true if statement S can trap. */
2167 bool
2168 gimple_could_trap_p (gimple *s)
2170 return gimple_could_trap_p_1 (s, true, true);
2173 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
2175 bool
2176 gimple_assign_rhs_could_trap_p (gimple *s)
2178 gcc_assert (is_gimple_assign (s));
2179 return gimple_could_trap_p_1 (s, true, false);
2183 /* Print debugging information for gimple stmts generated. */
2185 void
2186 dump_gimple_statistics (void)
2188 int i;
2189 uint64_t total_tuples = 0, total_bytes = 0;
2191 if (! GATHER_STATISTICS)
2193 fprintf (stderr, "No GIMPLE statistics\n");
2194 return;
2197 fprintf (stderr, "\nGIMPLE statements\n");
2198 fprintf (stderr, "Kind Stmts Bytes\n");
2199 fprintf (stderr, "---------------------------------------\n");
2200 for (i = 0; i < (int) gimple_alloc_kind_all; ++i)
2202 fprintf (stderr, "%-20s %7" PRIu64 "%c %10" PRIu64 "%c\n",
2203 gimple_alloc_kind_names[i],
2204 SIZE_AMOUNT (gimple_alloc_counts[i]),
2205 SIZE_AMOUNT (gimple_alloc_sizes[i]));
2206 total_tuples += gimple_alloc_counts[i];
2207 total_bytes += gimple_alloc_sizes[i];
2209 fprintf (stderr, "---------------------------------------\n");
2210 fprintf (stderr, "%-20s %7" PRIu64 "%c %10" PRIu64 "%c\n", "Total",
2211 SIZE_AMOUNT (total_tuples), SIZE_AMOUNT (total_bytes));
2212 fprintf (stderr, "---------------------------------------\n");
2216 /* Return the number of operands needed on the RHS of a GIMPLE
2217 assignment for an expression with tree code CODE. */
2219 unsigned
2220 get_gimple_rhs_num_ops (enum tree_code code)
2222 switch (get_gimple_rhs_class (code))
2224 case GIMPLE_UNARY_RHS:
2225 case GIMPLE_SINGLE_RHS:
2226 return 1;
2227 case GIMPLE_BINARY_RHS:
2228 return 2;
2229 case GIMPLE_TERNARY_RHS:
2230 return 3;
2231 default:
2232 gcc_unreachable ();
2236 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2237 (unsigned char) \
2238 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2239 : ((TYPE) == tcc_binary \
2240 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2241 : ((TYPE) == tcc_constant \
2242 || (TYPE) == tcc_declaration \
2243 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2244 : ((SYM) == TRUTH_AND_EXPR \
2245 || (SYM) == TRUTH_OR_EXPR \
2246 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2247 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2248 : ((SYM) == COND_EXPR \
2249 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2250 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2251 || (SYM) == DOT_PROD_EXPR \
2252 || (SYM) == SAD_EXPR \
2253 || (SYM) == REALIGN_LOAD_EXPR \
2254 || (SYM) == VEC_COND_EXPR \
2255 || (SYM) == VEC_PERM_EXPR \
2256 || (SYM) == BIT_INSERT_EXPR) ? GIMPLE_TERNARY_RHS \
2257 : ((SYM) == CONSTRUCTOR \
2258 || (SYM) == OBJ_TYPE_REF \
2259 || (SYM) == ASSERT_EXPR \
2260 || (SYM) == ADDR_EXPR \
2261 || (SYM) == WITH_SIZE_EXPR \
2262 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2263 : GIMPLE_INVALID_RHS),
2264 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2266 const unsigned char gimple_rhs_class_table[] = {
2267 #include "all-tree.def"
2270 #undef DEFTREECODE
2271 #undef END_OF_BASE_TREE_CODES
2273 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2274 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2275 we failed to create one. */
2277 tree
2278 canonicalize_cond_expr_cond (tree t)
2280 /* Strip conversions around boolean operations. */
2281 if (CONVERT_EXPR_P (t)
2282 && (truth_value_p (TREE_CODE (TREE_OPERAND (t, 0)))
2283 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0)))
2284 == BOOLEAN_TYPE))
2285 t = TREE_OPERAND (t, 0);
2287 /* For !x use x == 0. */
2288 if (TREE_CODE (t) == TRUTH_NOT_EXPR)
2290 tree top0 = TREE_OPERAND (t, 0);
2291 t = build2 (EQ_EXPR, TREE_TYPE (t),
2292 top0, build_int_cst (TREE_TYPE (top0), 0));
2294 /* For cmp ? 1 : 0 use cmp. */
2295 else if (TREE_CODE (t) == COND_EXPR
2296 && COMPARISON_CLASS_P (TREE_OPERAND (t, 0))
2297 && integer_onep (TREE_OPERAND (t, 1))
2298 && integer_zerop (TREE_OPERAND (t, 2)))
2300 tree top0 = TREE_OPERAND (t, 0);
2301 t = build2 (TREE_CODE (top0), TREE_TYPE (t),
2302 TREE_OPERAND (top0, 0), TREE_OPERAND (top0, 1));
2304 /* For x ^ y use x != y. */
2305 else if (TREE_CODE (t) == BIT_XOR_EXPR)
2306 t = build2 (NE_EXPR, TREE_TYPE (t),
2307 TREE_OPERAND (t, 0), TREE_OPERAND (t, 1));
2309 if (is_gimple_condexpr (t))
2310 return t;
2312 return NULL_TREE;
2315 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2316 the positions marked by the set ARGS_TO_SKIP. */
2318 gcall *
2319 gimple_call_copy_skip_args (gcall *stmt, bitmap args_to_skip)
2321 int i;
2322 int nargs = gimple_call_num_args (stmt);
2323 auto_vec<tree> vargs (nargs);
2324 gcall *new_stmt;
2326 for (i = 0; i < nargs; i++)
2327 if (!bitmap_bit_p (args_to_skip, i))
2328 vargs.quick_push (gimple_call_arg (stmt, i));
2330 if (gimple_call_internal_p (stmt))
2331 new_stmt = gimple_build_call_internal_vec (gimple_call_internal_fn (stmt),
2332 vargs);
2333 else
2334 new_stmt = gimple_build_call_vec (gimple_call_fn (stmt), vargs);
2336 if (gimple_call_lhs (stmt))
2337 gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
2339 gimple_set_vuse (new_stmt, gimple_vuse (stmt));
2340 gimple_set_vdef (new_stmt, gimple_vdef (stmt));
2342 if (gimple_has_location (stmt))
2343 gimple_set_location (new_stmt, gimple_location (stmt));
2344 gimple_call_copy_flags (new_stmt, stmt);
2345 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
2347 gimple_set_modified (new_stmt, true);
2349 return new_stmt;
2354 /* Return true if the field decls F1 and F2 are at the same offset.
2356 This is intended to be used on GIMPLE types only. */
2358 bool
2359 gimple_compare_field_offset (tree f1, tree f2)
2361 if (DECL_OFFSET_ALIGN (f1) == DECL_OFFSET_ALIGN (f2))
2363 tree offset1 = DECL_FIELD_OFFSET (f1);
2364 tree offset2 = DECL_FIELD_OFFSET (f2);
2365 return ((offset1 == offset2
2366 /* Once gimplification is done, self-referential offsets are
2367 instantiated as operand #2 of the COMPONENT_REF built for
2368 each access and reset. Therefore, they are not relevant
2369 anymore and fields are interchangeable provided that they
2370 represent the same access. */
2371 || (TREE_CODE (offset1) == PLACEHOLDER_EXPR
2372 && TREE_CODE (offset2) == PLACEHOLDER_EXPR
2373 && (DECL_SIZE (f1) == DECL_SIZE (f2)
2374 || (TREE_CODE (DECL_SIZE (f1)) == PLACEHOLDER_EXPR
2375 && TREE_CODE (DECL_SIZE (f2)) == PLACEHOLDER_EXPR)
2376 || operand_equal_p (DECL_SIZE (f1), DECL_SIZE (f2), 0))
2377 && DECL_ALIGN (f1) == DECL_ALIGN (f2))
2378 || operand_equal_p (offset1, offset2, 0))
2379 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1),
2380 DECL_FIELD_BIT_OFFSET (f2)));
2383 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2384 should be, so handle differing ones specially by decomposing
2385 the offset into a byte and bit offset manually. */
2386 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1))
2387 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2)))
2389 unsigned HOST_WIDE_INT byte_offset1, byte_offset2;
2390 unsigned HOST_WIDE_INT bit_offset1, bit_offset2;
2391 bit_offset1 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1));
2392 byte_offset1 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1))
2393 + bit_offset1 / BITS_PER_UNIT);
2394 bit_offset2 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2));
2395 byte_offset2 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2))
2396 + bit_offset2 / BITS_PER_UNIT);
2397 if (byte_offset1 != byte_offset2)
2398 return false;
2399 return bit_offset1 % BITS_PER_UNIT == bit_offset2 % BITS_PER_UNIT;
2402 return false;
2406 /* Return a type the same as TYPE except unsigned or
2407 signed according to UNSIGNEDP. */
2409 static tree
2410 gimple_signed_or_unsigned_type (bool unsignedp, tree type)
2412 tree type1;
2413 int i;
2415 type1 = TYPE_MAIN_VARIANT (type);
2416 if (type1 == signed_char_type_node
2417 || type1 == char_type_node
2418 || type1 == unsigned_char_type_node)
2419 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2420 if (type1 == integer_type_node || type1 == unsigned_type_node)
2421 return unsignedp ? unsigned_type_node : integer_type_node;
2422 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
2423 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2424 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
2425 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2426 if (type1 == long_long_integer_type_node
2427 || type1 == long_long_unsigned_type_node)
2428 return unsignedp
2429 ? long_long_unsigned_type_node
2430 : long_long_integer_type_node;
2432 for (i = 0; i < NUM_INT_N_ENTS; i ++)
2433 if (int_n_enabled_p[i]
2434 && (type1 == int_n_trees[i].unsigned_type
2435 || type1 == int_n_trees[i].signed_type))
2436 return unsignedp
2437 ? int_n_trees[i].unsigned_type
2438 : int_n_trees[i].signed_type;
2440 #if HOST_BITS_PER_WIDE_INT >= 64
2441 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
2442 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2443 #endif
2444 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
2445 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2446 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
2447 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2448 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
2449 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2450 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
2451 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2453 #define GIMPLE_FIXED_TYPES(NAME) \
2454 if (type1 == short_ ## NAME ## _type_node \
2455 || type1 == unsigned_short_ ## NAME ## _type_node) \
2456 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2457 : short_ ## NAME ## _type_node; \
2458 if (type1 == NAME ## _type_node \
2459 || type1 == unsigned_ ## NAME ## _type_node) \
2460 return unsignedp ? unsigned_ ## NAME ## _type_node \
2461 : NAME ## _type_node; \
2462 if (type1 == long_ ## NAME ## _type_node \
2463 || type1 == unsigned_long_ ## NAME ## _type_node) \
2464 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2465 : long_ ## NAME ## _type_node; \
2466 if (type1 == long_long_ ## NAME ## _type_node \
2467 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2468 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2469 : long_long_ ## NAME ## _type_node;
2471 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2472 if (type1 == NAME ## _type_node \
2473 || type1 == u ## NAME ## _type_node) \
2474 return unsignedp ? u ## NAME ## _type_node \
2475 : NAME ## _type_node;
2477 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2478 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2479 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2480 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2481 : sat_ ## short_ ## NAME ## _type_node; \
2482 if (type1 == sat_ ## NAME ## _type_node \
2483 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2484 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2485 : sat_ ## NAME ## _type_node; \
2486 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2487 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2488 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2489 : sat_ ## long_ ## NAME ## _type_node; \
2490 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2491 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2492 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2493 : sat_ ## long_long_ ## NAME ## _type_node;
2495 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2496 if (type1 == sat_ ## NAME ## _type_node \
2497 || type1 == sat_ ## u ## NAME ## _type_node) \
2498 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2499 : sat_ ## NAME ## _type_node;
2501 GIMPLE_FIXED_TYPES (fract);
2502 GIMPLE_FIXED_TYPES_SAT (fract);
2503 GIMPLE_FIXED_TYPES (accum);
2504 GIMPLE_FIXED_TYPES_SAT (accum);
2506 GIMPLE_FIXED_MODE_TYPES (qq);
2507 GIMPLE_FIXED_MODE_TYPES (hq);
2508 GIMPLE_FIXED_MODE_TYPES (sq);
2509 GIMPLE_FIXED_MODE_TYPES (dq);
2510 GIMPLE_FIXED_MODE_TYPES (tq);
2511 GIMPLE_FIXED_MODE_TYPES_SAT (qq);
2512 GIMPLE_FIXED_MODE_TYPES_SAT (hq);
2513 GIMPLE_FIXED_MODE_TYPES_SAT (sq);
2514 GIMPLE_FIXED_MODE_TYPES_SAT (dq);
2515 GIMPLE_FIXED_MODE_TYPES_SAT (tq);
2516 GIMPLE_FIXED_MODE_TYPES (ha);
2517 GIMPLE_FIXED_MODE_TYPES (sa);
2518 GIMPLE_FIXED_MODE_TYPES (da);
2519 GIMPLE_FIXED_MODE_TYPES (ta);
2520 GIMPLE_FIXED_MODE_TYPES_SAT (ha);
2521 GIMPLE_FIXED_MODE_TYPES_SAT (sa);
2522 GIMPLE_FIXED_MODE_TYPES_SAT (da);
2523 GIMPLE_FIXED_MODE_TYPES_SAT (ta);
2525 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2526 the precision; they have precision set to match their range, but
2527 may use a wider mode to match an ABI. If we change modes, we may
2528 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2529 the precision as well, so as to yield correct results for
2530 bit-field types. C++ does not have these separate bit-field
2531 types, and producing a signed or unsigned variant of an
2532 ENUMERAL_TYPE may cause other problems as well. */
2533 if (!INTEGRAL_TYPE_P (type)
2534 || TYPE_UNSIGNED (type) == unsignedp)
2535 return type;
2537 #define TYPE_OK(node) \
2538 (TYPE_MODE (type) == TYPE_MODE (node) \
2539 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2540 if (TYPE_OK (signed_char_type_node))
2541 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2542 if (TYPE_OK (integer_type_node))
2543 return unsignedp ? unsigned_type_node : integer_type_node;
2544 if (TYPE_OK (short_integer_type_node))
2545 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2546 if (TYPE_OK (long_integer_type_node))
2547 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2548 if (TYPE_OK (long_long_integer_type_node))
2549 return (unsignedp
2550 ? long_long_unsigned_type_node
2551 : long_long_integer_type_node);
2553 for (i = 0; i < NUM_INT_N_ENTS; i ++)
2554 if (int_n_enabled_p[i]
2555 && TYPE_MODE (type) == int_n_data[i].m
2556 && TYPE_PRECISION (type) == int_n_data[i].bitsize)
2557 return unsignedp
2558 ? int_n_trees[i].unsigned_type
2559 : int_n_trees[i].signed_type;
2561 #if HOST_BITS_PER_WIDE_INT >= 64
2562 if (TYPE_OK (intTI_type_node))
2563 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2564 #endif
2565 if (TYPE_OK (intDI_type_node))
2566 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2567 if (TYPE_OK (intSI_type_node))
2568 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2569 if (TYPE_OK (intHI_type_node))
2570 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2571 if (TYPE_OK (intQI_type_node))
2572 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2574 #undef GIMPLE_FIXED_TYPES
2575 #undef GIMPLE_FIXED_MODE_TYPES
2576 #undef GIMPLE_FIXED_TYPES_SAT
2577 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2578 #undef TYPE_OK
2580 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2584 /* Return an unsigned type the same as TYPE in other respects. */
2586 tree
2587 gimple_unsigned_type (tree type)
2589 return gimple_signed_or_unsigned_type (true, type);
2593 /* Return a signed type the same as TYPE in other respects. */
2595 tree
2596 gimple_signed_type (tree type)
2598 return gimple_signed_or_unsigned_type (false, type);
2602 /* Return the typed-based alias set for T, which may be an expression
2603 or a type. Return -1 if we don't do anything special. */
2605 alias_set_type
2606 gimple_get_alias_set (tree t)
2608 /* That's all the expressions we handle specially. */
2609 if (!TYPE_P (t))
2610 return -1;
2612 /* For convenience, follow the C standard when dealing with
2613 character types. Any object may be accessed via an lvalue that
2614 has character type. */
2615 if (t == char_type_node
2616 || t == signed_char_type_node
2617 || t == unsigned_char_type_node)
2618 return 0;
2620 /* Allow aliasing between signed and unsigned variants of the same
2621 type. We treat the signed variant as canonical. */
2622 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2624 tree t1 = gimple_signed_type (t);
2626 /* t1 == t can happen for boolean nodes which are always unsigned. */
2627 if (t1 != t)
2628 return get_alias_set (t1);
2631 /* Allow aliasing between enumeral types and the underlying
2632 integer type. This is required for C since those are
2633 compatible types. */
2634 else if (TREE_CODE (t) == ENUMERAL_TYPE)
2636 tree t1 = lang_hooks.types.type_for_size (tree_to_uhwi (TYPE_SIZE (t)),
2637 false /* short-cut above */);
2638 return get_alias_set (t1);
2641 return -1;
2645 /* Helper for gimple_ior_addresses_taken_1. */
2647 static bool
2648 gimple_ior_addresses_taken_1 (gimple *, tree addr, tree, void *data)
2650 bitmap addresses_taken = (bitmap)data;
2651 addr = get_base_address (addr);
2652 if (addr
2653 && DECL_P (addr))
2655 bitmap_set_bit (addresses_taken, DECL_UID (addr));
2656 return true;
2658 return false;
2661 /* Set the bit for the uid of all decls that have their address taken
2662 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2663 were any in this stmt. */
2665 bool
2666 gimple_ior_addresses_taken (bitmap addresses_taken, gimple *stmt)
2668 return walk_stmt_load_store_addr_ops (stmt, addresses_taken, NULL, NULL,
2669 gimple_ior_addresses_taken_1);
2673 /* Return true when STMTs arguments and return value match those of FNDECL,
2674 a decl of a builtin function. */
2676 bool
2677 gimple_builtin_call_types_compatible_p (const gimple *stmt, tree fndecl)
2679 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN);
2681 tree ret = gimple_call_lhs (stmt);
2682 if (ret
2683 && !useless_type_conversion_p (TREE_TYPE (ret),
2684 TREE_TYPE (TREE_TYPE (fndecl))))
2685 return false;
2687 tree targs = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2688 unsigned nargs = gimple_call_num_args (stmt);
2689 for (unsigned i = 0; i < nargs; ++i)
2691 /* Variadic args follow. */
2692 if (!targs)
2693 return true;
2694 tree arg = gimple_call_arg (stmt, i);
2695 tree type = TREE_VALUE (targs);
2696 if (!useless_type_conversion_p (type, TREE_TYPE (arg))
2697 /* char/short integral arguments are promoted to int
2698 by several frontends if targetm.calls.promote_prototypes
2699 is true. Allow such promotion too. */
2700 && !(INTEGRAL_TYPE_P (type)
2701 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
2702 && targetm.calls.promote_prototypes (TREE_TYPE (fndecl))
2703 && useless_type_conversion_p (integer_type_node,
2704 TREE_TYPE (arg))))
2705 return false;
2706 targs = TREE_CHAIN (targs);
2708 if (targs && !VOID_TYPE_P (TREE_VALUE (targs)))
2709 return false;
2710 return true;
2713 /* Return true when STMT is operator a replaceable delete call. */
2715 bool
2716 gimple_call_replaceable_operator_delete_p (const gcall *stmt)
2718 tree fndecl;
2720 if ((fndecl = gimple_call_fndecl (stmt)) != NULL_TREE)
2721 return DECL_IS_REPLACEABLE_OPERATOR_DELETE_P (fndecl);
2722 return false;
2725 /* Return true when STMT is builtins call. */
2727 bool
2728 gimple_call_builtin_p (const gimple *stmt)
2730 tree fndecl;
2731 if (is_gimple_call (stmt)
2732 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2733 && DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN)
2734 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2735 return false;
2738 /* Return true when STMT is builtins call to CLASS. */
2740 bool
2741 gimple_call_builtin_p (const gimple *stmt, enum built_in_class klass)
2743 tree fndecl;
2744 if (is_gimple_call (stmt)
2745 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2746 && DECL_BUILT_IN_CLASS (fndecl) == klass)
2747 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2748 return false;
2751 /* Return true when STMT is builtins call to CODE of CLASS. */
2753 bool
2754 gimple_call_builtin_p (const gimple *stmt, enum built_in_function code)
2756 tree fndecl;
2757 if (is_gimple_call (stmt)
2758 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2759 && fndecl_built_in_p (fndecl, code))
2760 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2761 return false;
2764 /* If CALL is a call to a combined_fn (i.e. an internal function or
2765 a normal built-in function), return its code, otherwise return
2766 CFN_LAST. */
2768 combined_fn
2769 gimple_call_combined_fn (const gimple *stmt)
2771 if (const gcall *call = dyn_cast <const gcall *> (stmt))
2773 if (gimple_call_internal_p (call))
2774 return as_combined_fn (gimple_call_internal_fn (call));
2776 tree fndecl = gimple_call_fndecl (stmt);
2777 if (fndecl
2778 && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL)
2779 && gimple_builtin_call_types_compatible_p (stmt, fndecl))
2780 return as_combined_fn (DECL_FUNCTION_CODE (fndecl));
2782 return CFN_LAST;
2785 /* Return true if STMT clobbers memory. STMT is required to be a
2786 GIMPLE_ASM. */
2788 bool
2789 gimple_asm_clobbers_memory_p (const gasm *stmt)
2791 unsigned i;
2793 for (i = 0; i < gimple_asm_nclobbers (stmt); i++)
2795 tree op = gimple_asm_clobber_op (stmt, i);
2796 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op)), "memory") == 0)
2797 return true;
2800 /* Non-empty basic ASM implicitly clobbers memory. */
2801 if (gimple_asm_input_p (stmt) && strlen (gimple_asm_string (stmt)) != 0)
2802 return true;
2804 return false;
2807 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2809 void
2810 dump_decl_set (FILE *file, bitmap set)
2812 if (set)
2814 bitmap_iterator bi;
2815 unsigned i;
2817 fprintf (file, "{ ");
2819 EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi)
2821 fprintf (file, "D.%u", i);
2822 fprintf (file, " ");
2825 fprintf (file, "}");
2827 else
2828 fprintf (file, "NIL");
2831 /* Return true when CALL is a call stmt that definitely doesn't
2832 free any memory or makes it unavailable otherwise. */
2833 bool
2834 nonfreeing_call_p (gimple *call)
2836 if (gimple_call_builtin_p (call, BUILT_IN_NORMAL)
2837 && gimple_call_flags (call) & ECF_LEAF)
2838 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call)))
2840 /* Just in case these become ECF_LEAF in the future. */
2841 case BUILT_IN_FREE:
2842 case BUILT_IN_TM_FREE:
2843 case BUILT_IN_REALLOC:
2844 case BUILT_IN_STACK_RESTORE:
2845 return false;
2846 default:
2847 return true;
2849 else if (gimple_call_internal_p (call))
2850 switch (gimple_call_internal_fn (call))
2852 case IFN_ABNORMAL_DISPATCHER:
2853 return true;
2854 case IFN_ASAN_MARK:
2855 return tree_to_uhwi (gimple_call_arg (call, 0)) == ASAN_MARK_UNPOISON;
2856 default:
2857 if (gimple_call_flags (call) & ECF_LEAF)
2858 return true;
2859 return false;
2862 tree fndecl = gimple_call_fndecl (call);
2863 if (!fndecl)
2864 return false;
2865 struct cgraph_node *n = cgraph_node::get (fndecl);
2866 if (!n)
2867 return false;
2868 enum availability availability;
2869 n = n->function_symbol (&availability);
2870 if (!n || availability <= AVAIL_INTERPOSABLE)
2871 return false;
2872 return n->nonfreeing_fn;
2875 /* Return true when CALL is a call stmt that definitely need not
2876 be considered to be a memory barrier. */
2877 bool
2878 nonbarrier_call_p (gimple *call)
2880 if (gimple_call_flags (call) & (ECF_PURE | ECF_CONST))
2881 return true;
2882 /* Should extend this to have a nonbarrier_fn flag, just as above in
2883 the nonfreeing case. */
2884 return false;
2887 /* Callback for walk_stmt_load_store_ops.
2889 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2890 otherwise.
2892 This routine only makes a superficial check for a dereference. Thus
2893 it must only be used if it is safe to return a false negative. */
2894 static bool
2895 check_loadstore (gimple *, tree op, tree, void *data)
2897 if (TREE_CODE (op) == MEM_REF || TREE_CODE (op) == TARGET_MEM_REF)
2899 /* Some address spaces may legitimately dereference zero. */
2900 addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (op));
2901 if (targetm.addr_space.zero_address_valid (as))
2902 return false;
2904 return operand_equal_p (TREE_OPERAND (op, 0), (tree)data, 0);
2906 return false;
2910 /* Return true if OP can be inferred to be non-NULL after STMT executes,
2911 either by using a pointer dereference or attributes. */
2912 bool
2913 infer_nonnull_range (gimple *stmt, tree op)
2915 return (infer_nonnull_range_by_dereference (stmt, op)
2916 || infer_nonnull_range_by_attribute (stmt, op));
2919 /* Return true if OP can be inferred to be non-NULL after STMT
2920 executes by using a pointer dereference. */
2921 bool
2922 infer_nonnull_range_by_dereference (gimple *stmt, tree op)
2924 /* We can only assume that a pointer dereference will yield
2925 non-NULL if -fdelete-null-pointer-checks is enabled. */
2926 if (!flag_delete_null_pointer_checks
2927 || !POINTER_TYPE_P (TREE_TYPE (op))
2928 || gimple_code (stmt) == GIMPLE_ASM
2929 || gimple_clobber_p (stmt))
2930 return false;
2932 if (walk_stmt_load_store_ops (stmt, (void *)op,
2933 check_loadstore, check_loadstore))
2934 return true;
2936 return false;
2939 /* Return true if OP can be inferred to be a non-NULL after STMT
2940 executes by using attributes. */
2941 bool
2942 infer_nonnull_range_by_attribute (gimple *stmt, tree op)
2944 /* We can only assume that a pointer dereference will yield
2945 non-NULL if -fdelete-null-pointer-checks is enabled. */
2946 if (!flag_delete_null_pointer_checks
2947 || !POINTER_TYPE_P (TREE_TYPE (op))
2948 || gimple_code (stmt) == GIMPLE_ASM)
2949 return false;
2951 if (is_gimple_call (stmt) && !gimple_call_internal_p (stmt))
2953 tree fntype = gimple_call_fntype (stmt);
2954 tree attrs = TYPE_ATTRIBUTES (fntype);
2955 for (; attrs; attrs = TREE_CHAIN (attrs))
2957 attrs = lookup_attribute ("nonnull", attrs);
2959 /* If "nonnull" wasn't specified, we know nothing about
2960 the argument. */
2961 if (attrs == NULL_TREE)
2962 return false;
2964 /* If "nonnull" applies to all the arguments, then ARG
2965 is non-null if it's in the argument list. */
2966 if (TREE_VALUE (attrs) == NULL_TREE)
2968 for (unsigned int i = 0; i < gimple_call_num_args (stmt); i++)
2970 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt, i)))
2971 && operand_equal_p (op, gimple_call_arg (stmt, i), 0))
2972 return true;
2974 return false;
2977 /* Now see if op appears in the nonnull list. */
2978 for (tree t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t))
2980 unsigned int idx = TREE_INT_CST_LOW (TREE_VALUE (t)) - 1;
2981 if (idx < gimple_call_num_args (stmt))
2983 tree arg = gimple_call_arg (stmt, idx);
2984 if (operand_equal_p (op, arg, 0))
2985 return true;
2991 /* If this function is marked as returning non-null, then we can
2992 infer OP is non-null if it is used in the return statement. */
2993 if (greturn *return_stmt = dyn_cast <greturn *> (stmt))
2994 if (gimple_return_retval (return_stmt)
2995 && operand_equal_p (gimple_return_retval (return_stmt), op, 0)
2996 && lookup_attribute ("returns_nonnull",
2997 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
2998 return true;
3000 return false;
3003 /* Compare two case labels. Because the front end should already have
3004 made sure that case ranges do not overlap, it is enough to only compare
3005 the CASE_LOW values of each case label. */
3007 static int
3008 compare_case_labels (const void *p1, const void *p2)
3010 const_tree const case1 = *(const_tree const*)p1;
3011 const_tree const case2 = *(const_tree const*)p2;
3013 /* The 'default' case label always goes first. */
3014 if (!CASE_LOW (case1))
3015 return -1;
3016 else if (!CASE_LOW (case2))
3017 return 1;
3018 else
3019 return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
3022 /* Sort the case labels in LABEL_VEC in place in ascending order. */
3024 void
3025 sort_case_labels (vec<tree> label_vec)
3027 label_vec.qsort (compare_case_labels);
3030 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
3032 LABELS is a vector that contains all case labels to look at.
3034 INDEX_TYPE is the type of the switch index expression. Case labels
3035 in LABELS are discarded if their values are not in the value range
3036 covered by INDEX_TYPE. The remaining case label values are folded
3037 to INDEX_TYPE.
3039 If a default case exists in LABELS, it is removed from LABELS and
3040 returned in DEFAULT_CASEP. If no default case exists, but the
3041 case labels already cover the whole range of INDEX_TYPE, a default
3042 case is returned pointing to one of the existing case labels.
3043 Otherwise DEFAULT_CASEP is set to NULL_TREE.
3045 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
3046 apply and no action is taken regardless of whether a default case is
3047 found or not. */
3049 void
3050 preprocess_case_label_vec_for_gimple (vec<tree> labels,
3051 tree index_type,
3052 tree *default_casep)
3054 tree min_value, max_value;
3055 tree default_case = NULL_TREE;
3056 size_t i, len;
3058 i = 0;
3059 min_value = TYPE_MIN_VALUE (index_type);
3060 max_value = TYPE_MAX_VALUE (index_type);
3061 while (i < labels.length ())
3063 tree elt = labels[i];
3064 tree low = CASE_LOW (elt);
3065 tree high = CASE_HIGH (elt);
3066 bool remove_element = FALSE;
3068 if (low)
3070 gcc_checking_assert (TREE_CODE (low) == INTEGER_CST);
3071 gcc_checking_assert (!high || TREE_CODE (high) == INTEGER_CST);
3073 /* This is a non-default case label, i.e. it has a value.
3075 See if the case label is reachable within the range of
3076 the index type. Remove out-of-range case values. Turn
3077 case ranges into a canonical form (high > low strictly)
3078 and convert the case label values to the index type.
3080 NB: The type of gimple_switch_index() may be the promoted
3081 type, but the case labels retain the original type. */
3083 if (high)
3085 /* This is a case range. Discard empty ranges.
3086 If the bounds or the range are equal, turn this
3087 into a simple (one-value) case. */
3088 int cmp = tree_int_cst_compare (high, low);
3089 if (cmp < 0)
3090 remove_element = TRUE;
3091 else if (cmp == 0)
3092 high = NULL_TREE;
3095 if (! high)
3097 /* If the simple case value is unreachable, ignore it. */
3098 if ((TREE_CODE (min_value) == INTEGER_CST
3099 && tree_int_cst_compare (low, min_value) < 0)
3100 || (TREE_CODE (max_value) == INTEGER_CST
3101 && tree_int_cst_compare (low, max_value) > 0))
3102 remove_element = TRUE;
3103 else
3104 low = fold_convert (index_type, low);
3106 else
3108 /* If the entire case range is unreachable, ignore it. */
3109 if ((TREE_CODE (min_value) == INTEGER_CST
3110 && tree_int_cst_compare (high, min_value) < 0)
3111 || (TREE_CODE (max_value) == INTEGER_CST
3112 && tree_int_cst_compare (low, max_value) > 0))
3113 remove_element = TRUE;
3114 else
3116 /* If the lower bound is less than the index type's
3117 minimum value, truncate the range bounds. */
3118 if (TREE_CODE (min_value) == INTEGER_CST
3119 && tree_int_cst_compare (low, min_value) < 0)
3120 low = min_value;
3121 low = fold_convert (index_type, low);
3123 /* If the upper bound is greater than the index type's
3124 maximum value, truncate the range bounds. */
3125 if (TREE_CODE (max_value) == INTEGER_CST
3126 && tree_int_cst_compare (high, max_value) > 0)
3127 high = max_value;
3128 high = fold_convert (index_type, high);
3130 /* We may have folded a case range to a one-value case. */
3131 if (tree_int_cst_equal (low, high))
3132 high = NULL_TREE;
3136 CASE_LOW (elt) = low;
3137 CASE_HIGH (elt) = high;
3139 else
3141 gcc_assert (!default_case);
3142 default_case = elt;
3143 /* The default case must be passed separately to the
3144 gimple_build_switch routine. But if DEFAULT_CASEP
3145 is NULL, we do not remove the default case (it would
3146 be completely lost). */
3147 if (default_casep)
3148 remove_element = TRUE;
3151 if (remove_element)
3152 labels.ordered_remove (i);
3153 else
3154 i++;
3156 len = i;
3158 if (!labels.is_empty ())
3159 sort_case_labels (labels);
3161 if (default_casep && !default_case)
3163 /* If the switch has no default label, add one, so that we jump
3164 around the switch body. If the labels already cover the whole
3165 range of the switch index_type, add the default label pointing
3166 to one of the existing labels. */
3167 if (len
3168 && TYPE_MIN_VALUE (index_type)
3169 && TYPE_MAX_VALUE (index_type)
3170 && tree_int_cst_equal (CASE_LOW (labels[0]),
3171 TYPE_MIN_VALUE (index_type)))
3173 tree low, high = CASE_HIGH (labels[len - 1]);
3174 if (!high)
3175 high = CASE_LOW (labels[len - 1]);
3176 if (tree_int_cst_equal (high, TYPE_MAX_VALUE (index_type)))
3178 tree widest_label = labels[0];
3179 for (i = 1; i < len; i++)
3181 high = CASE_LOW (labels[i]);
3182 low = CASE_HIGH (labels[i - 1]);
3183 if (!low)
3184 low = CASE_LOW (labels[i - 1]);
3186 if (CASE_HIGH (labels[i]) != NULL_TREE
3187 && (CASE_HIGH (widest_label) == NULL_TREE
3188 || (wi::gtu_p
3189 (wi::to_wide (CASE_HIGH (labels[i]))
3190 - wi::to_wide (CASE_LOW (labels[i])),
3191 wi::to_wide (CASE_HIGH (widest_label))
3192 - wi::to_wide (CASE_LOW (widest_label))))))
3193 widest_label = labels[i];
3195 if (wi::to_wide (low) + 1 != wi::to_wide (high))
3196 break;
3198 if (i == len)
3200 /* Designate the label with the widest range to be the
3201 default label. */
3202 tree label = CASE_LABEL (widest_label);
3203 default_case = build_case_label (NULL_TREE, NULL_TREE,
3204 label);
3210 if (default_casep)
3211 *default_casep = default_case;
3214 /* Set the location of all statements in SEQ to LOC. */
3216 void
3217 gimple_seq_set_location (gimple_seq seq, location_t loc)
3219 for (gimple_stmt_iterator i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
3220 gimple_set_location (gsi_stmt (i), loc);
3223 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
3225 void
3226 gimple_seq_discard (gimple_seq seq)
3228 gimple_stmt_iterator gsi;
3230 for (gsi = gsi_start (seq); !gsi_end_p (gsi); )
3232 gimple *stmt = gsi_stmt (gsi);
3233 gsi_remove (&gsi, true);
3234 release_defs (stmt);
3235 ggc_free (stmt);
3239 /* See if STMT now calls function that takes no parameters and if so, drop
3240 call arguments. This is used when devirtualization machinery redirects
3241 to __builtin_unreachable or __cxa_pure_virtual. */
3243 void
3244 maybe_remove_unused_call_args (struct function *fn, gimple *stmt)
3246 tree decl = gimple_call_fndecl (stmt);
3247 if (TYPE_ARG_TYPES (TREE_TYPE (decl))
3248 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))) == void_type_node
3249 && gimple_call_num_args (stmt))
3251 gimple_set_num_ops (stmt, 3);
3252 update_stmt_fn (fn, stmt);
3256 /* Return false if STMT will likely expand to real function call. */
3258 bool
3259 gimple_inexpensive_call_p (gcall *stmt)
3261 if (gimple_call_internal_p (stmt))
3262 return true;
3263 tree decl = gimple_call_fndecl (stmt);
3264 if (decl && is_inexpensive_builtin (decl))
3265 return true;
3266 return false;
3269 /* Return a non-artificial location for STMT. If STMT does not have
3270 location information, get the location from EXPR. */
3272 location_t
3273 gimple_or_expr_nonartificial_location (gimple *stmt, tree expr)
3275 location_t loc = gimple_nonartificial_location (stmt);
3276 if (loc == UNKNOWN_LOCATION && EXPR_HAS_LOCATION (expr))
3277 loc = tree_nonartificial_location (expr);
3278 return expansion_point_location_if_in_system_header (loc);
3282 #if CHECKING_P
3284 namespace selftest {
3286 /* Selftests for core gimple structures. */
3288 /* Verify that STMT is pretty-printed as EXPECTED.
3289 Helper function for selftests. */
3291 static void
3292 verify_gimple_pp (const char *expected, gimple *stmt)
3294 pretty_printer pp;
3295 pp_gimple_stmt_1 (&pp, stmt, 0 /* spc */, TDF_NONE /* flags */);
3296 ASSERT_STREQ (expected, pp_formatted_text (&pp));
3299 /* Build a GIMPLE_ASSIGN equivalent to
3300 tmp = 5;
3301 and verify various properties of it. */
3303 static void
3304 test_assign_single ()
3306 tree type = integer_type_node;
3307 tree lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3308 get_identifier ("tmp"),
3309 type);
3310 tree rhs = build_int_cst (type, 5);
3311 gassign *stmt = gimple_build_assign (lhs, rhs);
3312 verify_gimple_pp ("tmp = 5;", stmt);
3314 ASSERT_TRUE (is_gimple_assign (stmt));
3315 ASSERT_EQ (lhs, gimple_assign_lhs (stmt));
3316 ASSERT_EQ (lhs, gimple_get_lhs (stmt));
3317 ASSERT_EQ (rhs, gimple_assign_rhs1 (stmt));
3318 ASSERT_EQ (NULL, gimple_assign_rhs2 (stmt));
3319 ASSERT_EQ (NULL, gimple_assign_rhs3 (stmt));
3320 ASSERT_TRUE (gimple_assign_single_p (stmt));
3321 ASSERT_EQ (INTEGER_CST, gimple_assign_rhs_code (stmt));
3324 /* Build a GIMPLE_ASSIGN equivalent to
3325 tmp = a * b;
3326 and verify various properties of it. */
3328 static void
3329 test_assign_binop ()
3331 tree type = integer_type_node;
3332 tree lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3333 get_identifier ("tmp"),
3334 type);
3335 tree a = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3336 get_identifier ("a"),
3337 type);
3338 tree b = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3339 get_identifier ("b"),
3340 type);
3341 gassign *stmt = gimple_build_assign (lhs, MULT_EXPR, a, b);
3342 verify_gimple_pp ("tmp = a * b;", stmt);
3344 ASSERT_TRUE (is_gimple_assign (stmt));
3345 ASSERT_EQ (lhs, gimple_assign_lhs (stmt));
3346 ASSERT_EQ (lhs, gimple_get_lhs (stmt));
3347 ASSERT_EQ (a, gimple_assign_rhs1 (stmt));
3348 ASSERT_EQ (b, gimple_assign_rhs2 (stmt));
3349 ASSERT_EQ (NULL, gimple_assign_rhs3 (stmt));
3350 ASSERT_FALSE (gimple_assign_single_p (stmt));
3351 ASSERT_EQ (MULT_EXPR, gimple_assign_rhs_code (stmt));
3354 /* Build a GIMPLE_NOP and verify various properties of it. */
3356 static void
3357 test_nop_stmt ()
3359 gimple *stmt = gimple_build_nop ();
3360 verify_gimple_pp ("GIMPLE_NOP", stmt);
3361 ASSERT_EQ (GIMPLE_NOP, gimple_code (stmt));
3362 ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3363 ASSERT_FALSE (gimple_assign_single_p (stmt));
3366 /* Build a GIMPLE_RETURN equivalent to
3367 return 7;
3368 and verify various properties of it. */
3370 static void
3371 test_return_stmt ()
3373 tree type = integer_type_node;
3374 tree val = build_int_cst (type, 7);
3375 greturn *stmt = gimple_build_return (val);
3376 verify_gimple_pp ("return 7;", stmt);
3378 ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt));
3379 ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3380 ASSERT_EQ (val, gimple_return_retval (stmt));
3381 ASSERT_FALSE (gimple_assign_single_p (stmt));
3384 /* Build a GIMPLE_RETURN equivalent to
3385 return;
3386 and verify various properties of it. */
3388 static void
3389 test_return_without_value ()
3391 greturn *stmt = gimple_build_return (NULL);
3392 verify_gimple_pp ("return;", stmt);
3394 ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt));
3395 ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3396 ASSERT_EQ (NULL, gimple_return_retval (stmt));
3397 ASSERT_FALSE (gimple_assign_single_p (stmt));
3400 /* Run all of the selftests within this file. */
3402 void
3403 gimple_c_tests ()
3405 test_assign_single ();
3406 test_assign_binop ();
3407 test_nop_stmt ();
3408 test_return_stmt ();
3409 test_return_without_value ();
3412 } // namespace selftest
3415 #endif /* CHECKING_P */