1/* Gimple IR support functions.
2
3 Copyright (C) 2007-2017 Free Software Foundation, Inc.
4 Contributed by Aldy Hernandez <aldyh@redhat.com>
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify it under
9the terms of the GNU General Public License as published by the Free
10Software Foundation; either version 3, or (at your option) any later
11version.
12
13GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14WARRANTY; without even the implied warranty of MERCHANTABILITY or
15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16for more details.
17
18You should have received a copy of the GNU General Public License
19along with GCC; see the file COPYING3. If not see
20<http://www.gnu.org/licenses/>. */
21
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
48
49/* All the tuples have their operand vector (if present) at the very bottom
50 of the structure. Therefore, the offset required to find the
51 operands vector the size of the structure minus the size of the 1
52 element tree array at the end (see gimple_ops). */
53#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
54 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
55EXPORTED_CONST size_t gimple_ops_offset_[] = {
56#include "gsstruct.def"
57};
58#undef DEFGSSTRUCT
59
60#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
61static const size_t gsstruct_code_size[] = {
62#include "gsstruct.def"
63};
64#undef DEFGSSTRUCT
65
66#define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
67const char *const gimple_code_name[] = {
68#include "gimple.def"
69};
70#undef DEFGSCODE
71
72#define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
73EXPORTED_CONST enum gimple_statement_structure_enum gss_for_code_[] = {
74#include "gimple.def"
75};
76#undef DEFGSCODE
77
78/* Gimple stats. */
79
80int gimple_alloc_counts[(int) gimple_alloc_kind_all];
81int gimple_alloc_sizes[(int) gimple_alloc_kind_all];
82
83/* Keep in sync with gimple.h:enum gimple_alloc_kind. */
84static const char * const gimple_alloc_kind_names[] = {
85 "assignments",
86 "phi nodes",
87 "conditionals",
88 "everything else"
89};
90
91/* Static gimple tuple members. */
92const enum gimple_code gassign::code_;
93const enum gimple_code gcall::code_;
94const enum gimple_code gcond::code_;
95
96
97/* Gimple tuple constructors.
98 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
99 be passed a NULL to start with an empty sequence. */
100
101/* Set the code for statement G to CODE. */
102
103static inline void
104gimple_set_code (gimple *g, enum gimple_code code)
105{
106 g->code = code;
107}
108
109/* Return the number of bytes needed to hold a GIMPLE statement with
110 code CODE. */
111
112static inline size_t
113gimple_size (enum gimple_code code)
114{
115 return gsstruct_code_size[gss_for_code (code)];
116}
117
118/* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
119 operands. */
120
121gimple *
122gimple_alloc (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
123{
124 size_t size;
125 gimple *stmt;
126
127 size = gimple_size (code);
128 if (num_ops > 0)
129 size += sizeof (tree) * (num_ops - 1);
130
131 if (GATHER_STATISTICS)
132 {
133 enum gimple_alloc_kind kind = gimple_alloc_kind (code);
134 gimple_alloc_counts[(int) kind]++;
135 gimple_alloc_sizes[(int) kind] += size;
136 }
137
138 stmt = ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT);
139 gimple_set_code (stmt, code);
140 gimple_set_num_ops (stmt, num_ops);
141
142 /* Do not call gimple_set_modified here as it has other side
143 effects and this tuple is still not completely built. */
144 stmt->modified = 1;
145 gimple_init_singleton (stmt);
146
147 return stmt;
148}
149
150/* Set SUBCODE to be the code of the expression computed by statement G. */
151
152static inline void
153gimple_set_subcode (gimple *g, unsigned subcode)
154{
155 /* We only have 16 bits for the RHS code. Assert that we are not
156 overflowing it. */
157 gcc_assert (subcode < (1 << 16));
158 g->subcode = subcode;
159}
160
161
162
163/* Build a tuple with operands. CODE is the statement to build (which
164 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
165 for the new tuple. NUM_OPS is the number of operands to allocate. */
166
167#define gimple_build_with_ops(c, s, n) \
168 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
169
170static gimple *
171gimple_build_with_ops_stat (enum gimple_code code, unsigned subcode,
172 unsigned num_ops MEM_STAT_DECL)
173{
174 gimple *s = gimple_alloc (code, num_ops PASS_MEM_STAT);
175 gimple_set_subcode (s, subcode);
176
177 return s;
178}
179
180
181/* Build a GIMPLE_RETURN statement returning RETVAL. */
182
183greturn *
184gimple_build_return (tree retval)
185{
186 greturn *s
187 = as_a <greturn *> (gimple_build_with_ops (GIMPLE_RETURN, ERROR_MARK,
188 2));
189 if (retval)
190 gimple_return_set_retval (s, retval);
191 return s;
192}
193
194/* Reset alias information on call S. */
195
196void
197gimple_call_reset_alias_info (gcall *s)
198{
199 if (gimple_call_flags (s) & ECF_CONST)
200 memset (gimple_call_use_set (s), 0, sizeof (struct pt_solution));
201 else
202 pt_solution_reset (gimple_call_use_set (s));
203 if (gimple_call_flags (s) & (ECF_CONST|ECF_PURE|ECF_NOVOPS))
204 memset (gimple_call_clobber_set (s), 0, sizeof (struct pt_solution));
205 else
206 pt_solution_reset (gimple_call_clobber_set (s));
207}
208
209/* Helper for gimple_build_call, gimple_build_call_valist,
210 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
211 components of a GIMPLE_CALL statement to function FN with NARGS
212 arguments. */
213
214static inline gcall *
215gimple_build_call_1 (tree fn, unsigned nargs)
216{
217 gcall *s
218 = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
219 nargs + 3));
220 if (TREE_CODE (fn) == FUNCTION_DECL)
221 fn = build_fold_addr_expr (fn);
222 gimple_set_op (s, 1, fn);
223 gimple_call_set_fntype (s, TREE_TYPE (TREE_TYPE (fn)));
224 gimple_call_reset_alias_info (s);
225 return s;
226}
227
228
229/* Build a GIMPLE_CALL statement to function FN with the arguments
230 specified in vector ARGS. */
231
232gcall *
233gimple_build_call_vec (tree fn, vec<tree> args)
234{
235 unsigned i;
236 unsigned nargs = args.length ();
237 gcall *call = gimple_build_call_1 (fn, nargs);
238
239 for (i = 0; i < nargs; i++)
240 gimple_call_set_arg (call, i, args[i]);
241
242 return call;
243}
244
245
246/* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
247 arguments. The ... are the arguments. */
248
249gcall *
250gimple_build_call (tree fn, unsigned nargs, ...)
251{
252 va_list ap;
253 gcall *call;
254 unsigned i;
255
256 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
257
258 call = gimple_build_call_1 (fn, nargs);
259
260 va_start (ap, nargs);
261 for (i = 0; i < nargs; i++)
262 gimple_call_set_arg (call, i, va_arg (ap, tree));
263 va_end (ap);
264
265 return call;
266}
267
268
269/* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
270 arguments. AP contains the arguments. */
271
272gcall *
273gimple_build_call_valist (tree fn, unsigned nargs, va_list ap)
274{
275 gcall *call;
276 unsigned i;
277
278 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
279
280 call = gimple_build_call_1 (fn, nargs);
281
282 for (i = 0; i < nargs; i++)
283 gimple_call_set_arg (call, i, va_arg (ap, tree));
284
285 return call;
286}
287
288
289/* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
290 Build the basic components of a GIMPLE_CALL statement to internal
291 function FN with NARGS arguments. */
292
293static inline gcall *
294gimple_build_call_internal_1 (enum internal_fn fn, unsigned nargs)
295{
296 gcall *s
297 = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
298 nargs + 3));
299 s->subcode |= GF_CALL_INTERNAL;
300 gimple_call_set_internal_fn (s, fn);
301 gimple_call_reset_alias_info (s);
302 return s;
303}
304
305
306/* Build a GIMPLE_CALL statement to internal function FN. NARGS is
307 the number of arguments. The ... are the arguments. */
308
309gcall *
310gimple_build_call_internal (enum internal_fn fn, unsigned nargs, ...)
311{
312 va_list ap;
313 gcall *call;
314 unsigned i;
315
316 call = gimple_build_call_internal_1 (fn, nargs);
317 va_start (ap, nargs);
318 for (i = 0; i < nargs; i++)
319 gimple_call_set_arg (call, i, va_arg (ap, tree));
320 va_end (ap);
321
322 return call;
323}
324
325
326/* Build a GIMPLE_CALL statement to internal function FN with the arguments
327 specified in vector ARGS. */
328
329gcall *
330gimple_build_call_internal_vec (enum internal_fn fn, vec<tree> args)
331{
332 unsigned i, nargs;
333 gcall *call;
334
335 nargs = args.length ();
336 call = gimple_build_call_internal_1 (fn, nargs);
337 for (i = 0; i < nargs; i++)
338 gimple_call_set_arg (call, i, args[i]);
339
340 return call;
341}
342
343
344/* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
345 assumed to be in GIMPLE form already. Minimal checking is done of
346 this fact. */
347
348gcall *
349gimple_build_call_from_tree (tree t, tree fnptrtype)
350{
351 unsigned i, nargs;
352 gcall *call;
353 tree fndecl = get_callee_fndecl (t);
354
355 gcc_assert (TREE_CODE (t) == CALL_EXPR);
356
357 nargs = call_expr_nargs (t);
358 call = gimple_build_call_1 (fndecl ? fndecl : CALL_EXPR_FN (t), nargs);
359
360 for (i = 0; i < nargs; i++)
361 gimple_call_set_arg (call, i, CALL_EXPR_ARG (t, i));
362
363 gimple_set_block (call, TREE_BLOCK (t));
364 gimple_set_location (call, EXPR_LOCATION (t));
365
366 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
367 gimple_call_set_chain (call, CALL_EXPR_STATIC_CHAIN (t));
368 gimple_call_set_tail (call, CALL_EXPR_TAILCALL (t));
369 gimple_call_set_must_tail (call, CALL_EXPR_MUST_TAIL_CALL (t));
370 gimple_call_set_return_slot_opt (call, CALL_EXPR_RETURN_SLOT_OPT (t));
371 if (fndecl
372 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
373 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl)))
374 gimple_call_set_alloca_for_var (call, CALL_ALLOCA_FOR_VAR_P (t));
375 else
376 gimple_call_set_from_thunk (call, CALL_FROM_THUNK_P (t));
377 gimple_call_set_va_arg_pack (call, CALL_EXPR_VA_ARG_PACK (t));
378 gimple_call_set_nothrow (call, TREE_NOTHROW (t));
379 gimple_call_set_by_descriptor (call, CALL_EXPR_BY_DESCRIPTOR (t));
380 gimple_set_no_warning (call, TREE_NO_WARNING (t));
381 gimple_call_set_with_bounds (call, CALL_WITH_BOUNDS_P (t));
382
383 if (fnptrtype)
384 {
385 gimple_call_set_fntype (call, TREE_TYPE (fnptrtype));
386
387 /* Check if it's an indirect CALL and the type has the
388 nocf_check attribute. In that case propagate the information
389 to the gimple CALL insn. */
390 if (!fndecl)
391 {
392 gcc_assert (POINTER_TYPE_P (fnptrtype));
393 tree fntype = TREE_TYPE (fnptrtype);
394
395 if (lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (fntype)))
396 gimple_call_set_nocf_check (call, TRUE);
397 }
398 }
399
400 return call;
401}
402
403
404/* Build a GIMPLE_ASSIGN statement.
405
406 LHS of the assignment.
407 RHS of the assignment which can be unary or binary. */
408
409gassign *
410gimple_build_assign (tree lhs, tree rhs MEM_STAT_DECL)
411{
412 enum tree_code subcode;
413 tree op1, op2, op3;
414
415 extract_ops_from_tree (rhs, &subcode, &op1, &op2, &op3);
416 return gimple_build_assign (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
417}
418
419
420/* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
421 OP1, OP2 and OP3. */
422
423static inline gassign *
424gimple_build_assign_1 (tree lhs, enum tree_code subcode, tree op1,
425 tree op2, tree op3 MEM_STAT_DECL)
426{
427 unsigned num_ops;
428 gassign *p;
429
430 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
431 code). */
432 num_ops = get_gimple_rhs_num_ops (subcode) + 1;
433
434 p = as_a <gassign *> (
435 gimple_build_with_ops_stat (GIMPLE_ASSIGN, (unsigned)subcode, num_ops
436 PASS_MEM_STAT));
437 gimple_assign_set_lhs (p, lhs);
438 gimple_assign_set_rhs1 (p, op1);
439 if (op2)
440 {
441 gcc_assert (num_ops > 2);
442 gimple_assign_set_rhs2 (p, op2);
443 }
444
445 if (op3)
446 {
447 gcc_assert (num_ops > 3);
448 gimple_assign_set_rhs3 (p, op3);
449 }
450
451 return p;
452}
453
454/* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
455 OP1, OP2 and OP3. */
456
457gassign *
458gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
459 tree op2, tree op3 MEM_STAT_DECL)
460{
461 return gimple_build_assign_1 (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
462}
463
464/* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
465 OP1 and OP2. */
466
467gassign *
468gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
469 tree op2 MEM_STAT_DECL)
470{
471 return gimple_build_assign_1 (lhs, subcode, op1, op2, NULL_TREE
472 PASS_MEM_STAT);
473}
474
475/* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
476
477gassign *
478gimple_build_assign (tree lhs, enum tree_code subcode, tree op1 MEM_STAT_DECL)
479{
480 return gimple_build_assign_1 (lhs, subcode, op1, NULL_TREE, NULL_TREE
481 PASS_MEM_STAT);
482}
483
484
485/* Build a GIMPLE_COND statement.
486
487 PRED is the condition used to compare LHS and the RHS.
488 T_LABEL is the label to jump to if the condition is true.
489 F_LABEL is the label to jump to otherwise. */
490
491gcond *
492gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs,
493 tree t_label, tree f_label)
494{
495 gcond *p;
496
497 gcc_assert (TREE_CODE_CLASS (pred_code) == tcc_comparison);
498 p = as_a <gcond *> (gimple_build_with_ops (GIMPLE_COND, pred_code, 4));
499 gimple_cond_set_lhs (p, lhs);
500 gimple_cond_set_rhs (p, rhs);
501 gimple_cond_set_true_label (p, t_label);
502 gimple_cond_set_false_label (p, f_label);
503 return p;
504}
505
506/* Build a GIMPLE_COND statement from the conditional expression tree
507 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
508
509gcond *
510gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
511{
512 enum tree_code code;
513 tree lhs, rhs;
514
515 gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
516 return gimple_build_cond (code, lhs, rhs, t_label, f_label);
517}
518
519/* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
520 boolean expression tree COND. */
521
522void
523gimple_cond_set_condition_from_tree (gcond *stmt, tree cond)
524{
525 enum tree_code code;
526 tree lhs, rhs;
527
528 gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
529 gimple_cond_set_condition (stmt, code, lhs, rhs);
530}
531
532/* Build a GIMPLE_LABEL statement for LABEL. */
533
534glabel *
535gimple_build_label (tree label)
536{
537 glabel *p
538 = as_a <glabel *> (gimple_build_with_ops (GIMPLE_LABEL, ERROR_MARK, 1));
539 gimple_label_set_label (p, label);
540 return p;
541}
542
543/* Build a GIMPLE_GOTO statement to label DEST. */
544
545ggoto *
546gimple_build_goto (tree dest)
547{
548 ggoto *p
549 = as_a <ggoto *> (gimple_build_with_ops (GIMPLE_GOTO, ERROR_MARK, 1));
550 gimple_goto_set_dest (p, dest);
551 return p;
552}
553
554
555/* Build a GIMPLE_NOP statement. */
556
557gimple *
558gimple_build_nop (void)
559{
560 return gimple_alloc (GIMPLE_NOP, 0);
561}
562
563
564/* Build a GIMPLE_BIND statement.
565 VARS are the variables in BODY.
566 BLOCK is the containing block. */
567
568gbind *
569gimple_build_bind (tree vars, gimple_seq body, tree block)
570{
571 gbind *p = as_a <gbind *> (gimple_alloc (GIMPLE_BIND, 0));
572 gimple_bind_set_vars (p, vars);
573 if (body)
574 gimple_bind_set_body (p, body);
575 if (block)
576 gimple_bind_set_block (p, block);
577 return p;
578}
579
580/* Helper function to set the simple fields of a asm stmt.
581
582 STRING is a pointer to a string that is the asm blocks assembly code.
583 NINPUT is the number of register inputs.
584 NOUTPUT is the number of register outputs.
585 NCLOBBERS is the number of clobbered registers.
586 */
587
588static inline gasm *
589gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
590 unsigned nclobbers, unsigned nlabels)
591{
592 gasm *p;
593 int size = strlen (string);
594
595 /* ASMs with labels cannot have outputs. This should have been
596 enforced by the front end. */
597 gcc_assert (nlabels == 0 || noutputs == 0);
598
599 p = as_a <gasm *> (
600 gimple_build_with_ops (GIMPLE_ASM, ERROR_MARK,
601 ninputs + noutputs + nclobbers + nlabels));
602
603 p->ni = ninputs;
604 p->no = noutputs;
605 p->nc = nclobbers;
606 p->nl = nlabels;
607 p->string = ggc_alloc_string (string, size);
608
609 if (GATHER_STATISTICS)
610 gimple_alloc_sizes[(int) gimple_alloc_kind (GIMPLE_ASM)] += size;
611
612 return p;
613}
614
615/* Build a GIMPLE_ASM statement.
616
617 STRING is the assembly code.
618 NINPUT is the number of register inputs.
619 NOUTPUT is the number of register outputs.
620 NCLOBBERS is the number of clobbered registers.
621 INPUTS is a vector of the input register parameters.
622 OUTPUTS is a vector of the output register parameters.
623 CLOBBERS is a vector of the clobbered register parameters.
624 LABELS is a vector of destination labels. */
625
626gasm *
627gimple_build_asm_vec (const char *string, vec<tree, va_gc> *inputs,
628 vec<tree, va_gc> *outputs, vec<tree, va_gc> *clobbers,
629 vec<tree, va_gc> *labels)
630{
631 gasm *p;
632 unsigned i;
633
634 p = gimple_build_asm_1 (string,
635 vec_safe_length (inputs),
636 vec_safe_length (outputs),
637 vec_safe_length (clobbers),
638 vec_safe_length (labels));
639
640 for (i = 0; i < vec_safe_length (inputs); i++)
641 gimple_asm_set_input_op (p, i, (*inputs)[i]);
642
643 for (i = 0; i < vec_safe_length (outputs); i++)
644 gimple_asm_set_output_op (p, i, (*outputs)[i]);
645
646 for (i = 0; i < vec_safe_length (clobbers); i++)
647 gimple_asm_set_clobber_op (p, i, (*clobbers)[i]);
648
649 for (i = 0; i < vec_safe_length (labels); i++)
650 gimple_asm_set_label_op (p, i, (*labels)[i]);
651
652 return p;
653}
654
655/* Build a GIMPLE_CATCH statement.
656
657 TYPES are the catch types.
658 HANDLER is the exception handler. */
659
660gcatch *
661gimple_build_catch (tree types, gimple_seq handler)
662{
663 gcatch *p = as_a <gcatch *> (gimple_alloc (GIMPLE_CATCH, 0));
664 gimple_catch_set_types (p, types);
665 if (handler)
666 gimple_catch_set_handler (p, handler);
667
668 return p;
669}
670
671/* Build a GIMPLE_EH_FILTER statement.
672
673 TYPES are the filter's types.
674 FAILURE is the filter's failure action. */
675
676geh_filter *
677gimple_build_eh_filter (tree types, gimple_seq failure)
678{
679 geh_filter *p = as_a <geh_filter *> (gimple_alloc (GIMPLE_EH_FILTER, 0));
680 gimple_eh_filter_set_types (p, types);
681 if (failure)
682 gimple_eh_filter_set_failure (p, failure);
683
684 return p;
685}
686
687/* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
688
689geh_mnt *
690gimple_build_eh_must_not_throw (tree decl)
691{
692 geh_mnt *p = as_a <geh_mnt *> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW, 0));
693
694 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
695 gcc_assert (flags_from_decl_or_type (decl) & ECF_NORETURN);
696 gimple_eh_must_not_throw_set_fndecl (p, decl);
697
698 return p;
699}
700
701/* Build a GIMPLE_EH_ELSE statement. */
702
703geh_else *
704gimple_build_eh_else (gimple_seq n_body, gimple_seq e_body)
705{
706 geh_else *p = as_a <geh_else *> (gimple_alloc (GIMPLE_EH_ELSE, 0));
707 gimple_eh_else_set_n_body (p, n_body);
708 gimple_eh_else_set_e_body (p, e_body);
709 return p;
710}
711
712/* Build a GIMPLE_TRY statement.
713
714 EVAL is the expression to evaluate.
715 CLEANUP is the cleanup expression.
716 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
717 whether this is a try/catch or a try/finally respectively. */
718
719gtry *
720gimple_build_try (gimple_seq eval, gimple_seq cleanup,
721 enum gimple_try_flags kind)
722{
723 gtry *p;
724
725 gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
726 p = as_a <gtry *> (gimple_alloc (GIMPLE_TRY, 0));
727 gimple_set_subcode (p, kind);
728 if (eval)
729 gimple_try_set_eval (p, eval);
730 if (cleanup)
731 gimple_try_set_cleanup (p, cleanup);
732
733 return p;
734}
735
736/* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
737
738 CLEANUP is the cleanup expression. */
739
740gimple *
741gimple_build_wce (gimple_seq cleanup)
742{
743 gimple *p = gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR, 0);
744 if (cleanup)
745 gimple_wce_set_cleanup (p, cleanup);
746
747 return p;
748}
749
750
751/* Build a GIMPLE_RESX statement. */
752
753gresx *
754gimple_build_resx (int region)
755{
756 gresx *p
757 = as_a <gresx *> (gimple_build_with_ops (GIMPLE_RESX, ERROR_MARK, 0));
758 p->region = region;
759 return p;
760}
761
762
763/* The helper for constructing a gimple switch statement.
764 INDEX is the switch's index.
765 NLABELS is the number of labels in the switch excluding the default.
766 DEFAULT_LABEL is the default label for the switch statement. */
767
768gswitch *
769gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
770{
771 /* nlabels + 1 default label + 1 index. */
772 gcc_checking_assert (default_label);
773 gswitch *p = as_a <gswitch *> (gimple_build_with_ops (GIMPLE_SWITCH,
774 ERROR_MARK,
775 1 + 1 + nlabels));
776 gimple_switch_set_index (p, index);
777 gimple_switch_set_default_label (p, default_label);
778 return p;
779}
780
781/* Build a GIMPLE_SWITCH statement.
782
783 INDEX is the switch's index.
784 DEFAULT_LABEL is the default label
785 ARGS is a vector of labels excluding the default. */
786
787gswitch *
788gimple_build_switch (tree index, tree default_label, vec<tree> args)
789{
790 unsigned i, nlabels = args.length ();
791
792 gswitch *p = gimple_build_switch_nlabels (nlabels, index, default_label);
793
794 /* Copy the labels from the vector to the switch statement. */
795 for (i = 0; i < nlabels; i++)
796 gimple_switch_set_label (p, i + 1, args[i]);
797
798 return p;
799}
800
801/* Build a GIMPLE_EH_DISPATCH statement. */
802
803geh_dispatch *
804gimple_build_eh_dispatch (int region)
805{
806 geh_dispatch *p
807 = as_a <geh_dispatch *> (
808 gimple_build_with_ops (GIMPLE_EH_DISPATCH, ERROR_MARK, 0));
809 p->region = region;
810 return p;
811}
812
813/* Build a new GIMPLE_DEBUG_BIND statement.
814
815 VAR is bound to VALUE; block and location are taken from STMT. */
816
817gdebug *
818gimple_build_debug_bind (tree var, tree value, gimple *stmt MEM_STAT_DECL)
819{
820 gdebug *p
821 = as_a <gdebug *> (gimple_build_with_ops_stat (GIMPLE_DEBUG,
822 (unsigned)GIMPLE_DEBUG_BIND, 2
823 PASS_MEM_STAT));
824 gimple_debug_bind_set_var (p, var);
825 gimple_debug_bind_set_value (p, value);
826 if (stmt)
827 gimple_set_location (p, gimple_location (stmt));
828
829 return p;
830}
831
832
833/* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
834
835 VAR is bound to VALUE; block and location are taken from STMT. */
836
837gdebug *
838gimple_build_debug_source_bind (tree var, tree value,
839 gimple *stmt MEM_STAT_DECL)
840{
841 gdebug *p
842 = as_a <gdebug *> (
843 gimple_build_with_ops_stat (GIMPLE_DEBUG,
844 (unsigned)GIMPLE_DEBUG_SOURCE_BIND, 2
845 PASS_MEM_STAT));
846
847 gimple_debug_source_bind_set_var (p, var);
848 gimple_debug_source_bind_set_value (p, value);
849 if (stmt)
850 gimple_set_location (p, gimple_location (stmt));
851
852 return p;
853}
854
855
856/* Build a new GIMPLE_DEBUG_BEGIN_STMT statement in BLOCK at
857 LOCATION. */
858
859gdebug *
860gimple_build_debug_begin_stmt (tree block, location_t location
861 MEM_STAT_DECL)
862{
863 gdebug *p
864 = as_a <gdebug *> (
865 gimple_build_with_ops_stat (GIMPLE_DEBUG,
866 (unsigned)GIMPLE_DEBUG_BEGIN_STMT, 0
867 PASS_MEM_STAT));
868
869 gimple_set_location (p, location);
870 gimple_set_block (p, block);
871 cfun->debug_marker_count++;
872
873 return p;
874}
875
876
877/* Build a GIMPLE_OMP_CRITICAL statement.
878
879 BODY is the sequence of statements for which only one thread can execute.
880 NAME is optional identifier for this critical block.
881 CLAUSES are clauses for this critical block. */
882
883gomp_critical *
884gimple_build_omp_critical (gimple_seq body, tree name, tree clauses)
885{
886 gomp_critical *p
887 = as_a <gomp_critical *> (gimple_alloc (GIMPLE_OMP_CRITICAL, 0));
888 gimple_omp_critical_set_name (p, name);
889 gimple_omp_critical_set_clauses (p, clauses);
890 if (body)
891 gimple_omp_set_body (p, body);
892
893 return p;
894}
895
896/* Build a GIMPLE_OMP_FOR statement.
897
898 BODY is sequence of statements inside the for loop.
899 KIND is the `for' variant.
900 CLAUSES, are any of the construct's clauses.
901 COLLAPSE is the collapse count.
902 PRE_BODY is the sequence of statements that are loop invariant. */
903
904gomp_for *
905gimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse,
906 gimple_seq pre_body)
907{
908 gomp_for *p = as_a <gomp_for *> (gimple_alloc (GIMPLE_OMP_FOR, 0));
909 if (body)
910 gimple_omp_set_body (p, body);
911 gimple_omp_for_set_clauses (p, clauses);
912 gimple_omp_for_set_kind (p, kind);
913 p->collapse = collapse;
914 p->iter = ggc_cleared_vec_alloc<gimple_omp_for_iter> (collapse);
915
916 if (pre_body)
917 gimple_omp_for_set_pre_body (p, pre_body);
918
919 return p;
920}
921
922
923/* Build a GIMPLE_OMP_PARALLEL statement.
924
925 BODY is sequence of statements which are executed in parallel.
926 CLAUSES, are the OMP parallel construct's clauses.
927 CHILD_FN is the function created for the parallel threads to execute.
928 DATA_ARG are the shared data argument(s). */
929
930gomp_parallel *
931gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
932 tree data_arg)
933{
934 gomp_parallel *p
935 = as_a <gomp_parallel *> (gimple_alloc (GIMPLE_OMP_PARALLEL, 0));
936 if (body)
937 gimple_omp_set_body (p, body);
938 gimple_omp_parallel_set_clauses (p, clauses);
939 gimple_omp_parallel_set_child_fn (p, child_fn);
940 gimple_omp_parallel_set_data_arg (p, data_arg);
941
942 return p;
943}
944
945
946/* Build a GIMPLE_OMP_TASK statement.
947
948 BODY is sequence of statements which are executed by the explicit task.
949 CLAUSES, are the OMP parallel construct's clauses.
950 CHILD_FN is the function created for the parallel threads to execute.
951 DATA_ARG are the shared data argument(s).
952 COPY_FN is the optional function for firstprivate initialization.
953 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
954
955gomp_task *
956gimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn,
957 tree data_arg, tree copy_fn, tree arg_size,
958 tree arg_align)
959{
960 gomp_task *p = as_a <gomp_task *> (gimple_alloc (GIMPLE_OMP_TASK, 0));
961 if (body)
962 gimple_omp_set_body (p, body);
963 gimple_omp_task_set_clauses (p, clauses);
964 gimple_omp_task_set_child_fn (p, child_fn);
965 gimple_omp_task_set_data_arg (p, data_arg);
966 gimple_omp_task_set_copy_fn (p, copy_fn);
967 gimple_omp_task_set_arg_size (p, arg_size);
968 gimple_omp_task_set_arg_align (p, arg_align);
969
970 return p;
971}
972
973
974/* Build a GIMPLE_OMP_SECTION statement for a sections statement.
975
976 BODY is the sequence of statements in the section. */
977
978gimple *
979gimple_build_omp_section (gimple_seq body)
980{
981 gimple *p = gimple_alloc (GIMPLE_OMP_SECTION, 0);
982 if (body)
983 gimple_omp_set_body (p, body);
984
985 return p;
986}
987
988
989/* Build a GIMPLE_OMP_MASTER statement.
990
991 BODY is the sequence of statements to be executed by just the master. */
992
993gimple *
994gimple_build_omp_master (gimple_seq body)
995{
996 gimple *p = gimple_alloc (GIMPLE_OMP_MASTER, 0);
997 if (body)
998 gimple_omp_set_body (p, body);
999
1000 return p;
1001}
1002
1003/* Build a GIMPLE_OMP_GRID_BODY statement.
1004
1005 BODY is the sequence of statements to be executed by the kernel. */
1006
1007gimple *
1008gimple_build_omp_grid_body (gimple_seq body)
1009{
1010 gimple *p = gimple_alloc (GIMPLE_OMP_GRID_BODY, 0);
1011 if (body)
1012 gimple_omp_set_body (p, body);
1013
1014 return p;
1015}
1016
1017/* Build a GIMPLE_OMP_TASKGROUP statement.
1018
1019 BODY is the sequence of statements to be executed by the taskgroup
1020 construct. */
1021
1022gimple *
1023gimple_build_omp_taskgroup (gimple_seq body)
1024{
1025 gimple *p = gimple_alloc (GIMPLE_OMP_TASKGROUP, 0);
1026 if (body)
1027 gimple_omp_set_body (p, body);
1028
1029 return p;
1030}
1031
1032
1033/* Build a GIMPLE_OMP_CONTINUE statement.
1034
1035 CONTROL_DEF is the definition of the control variable.
1036 CONTROL_USE is the use of the control variable. */
1037
1038gomp_continue *
1039gimple_build_omp_continue (tree control_def, tree control_use)
1040{
1041 gomp_continue *p
1042 = as_a <gomp_continue *> (gimple_alloc (GIMPLE_OMP_CONTINUE, 0));
1043 gimple_omp_continue_set_control_def (p, control_def);
1044 gimple_omp_continue_set_control_use (p, control_use);
1045 return p;
1046}
1047
1048/* Build a GIMPLE_OMP_ORDERED statement.
1049
1050 BODY is the sequence of statements inside a loop that will executed in
1051 sequence.
1052 CLAUSES are clauses for this statement. */
1053
1054gomp_ordered *
1055gimple_build_omp_ordered (gimple_seq body, tree clauses)
1056{
1057 gomp_ordered *p
1058 = as_a <gomp_ordered *> (gimple_alloc (GIMPLE_OMP_ORDERED, 0));
1059 gimple_omp_ordered_set_clauses (p, clauses);
1060 if (body)
1061 gimple_omp_set_body (p, body);
1062
1063 return p;
1064}
1065
1066
1067/* Build a GIMPLE_OMP_RETURN statement.
1068 WAIT_P is true if this is a non-waiting return. */
1069
1070gimple *
1071gimple_build_omp_return (bool wait_p)
1072{
1073 gimple *p = gimple_alloc (GIMPLE_OMP_RETURN, 0);
1074 if (wait_p)
1075 gimple_omp_return_set_nowait (p);
1076
1077 return p;
1078}
1079
1080
1081/* Build a GIMPLE_OMP_SECTIONS statement.
1082
1083 BODY is a sequence of section statements.
1084 CLAUSES are any of the OMP sections contsruct's clauses: private,
1085 firstprivate, lastprivate, reduction, and nowait. */
1086
1087gomp_sections *
1088gimple_build_omp_sections (gimple_seq body, tree clauses)
1089{
1090 gomp_sections *p
1091 = as_a <gomp_sections *> (gimple_alloc (GIMPLE_OMP_SECTIONS, 0));
1092 if (body)
1093 gimple_omp_set_body (p, body);
1094 gimple_omp_sections_set_clauses (p, clauses);
1095
1096 return p;
1097}
1098
1099
1100/* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1101
1102gimple *
1103gimple_build_omp_sections_switch (void)
1104{
1105 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH, 0);
1106}
1107
1108
1109/* Build a GIMPLE_OMP_SINGLE statement.
1110
1111 BODY is the sequence of statements that will be executed once.
1112 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1113 copyprivate, nowait. */
1114
1115gomp_single *
1116gimple_build_omp_single (gimple_seq body, tree clauses)
1117{
1118 gomp_single *p
1119 = as_a <gomp_single *> (gimple_alloc (GIMPLE_OMP_SINGLE, 0));
1120 if (body)
1121 gimple_omp_set_body (p, body);
1122 gimple_omp_single_set_clauses (p, clauses);
1123
1124 return p;
1125}
1126
1127
1128/* Build a GIMPLE_OMP_TARGET statement.
1129
1130 BODY is the sequence of statements that will be executed.
1131 KIND is the kind of the region.
1132 CLAUSES are any of the construct's clauses. */
1133
1134gomp_target *
1135gimple_build_omp_target (gimple_seq body, int kind, tree clauses)
1136{
1137 gomp_target *p
1138 = as_a <gomp_target *> (gimple_alloc (GIMPLE_OMP_TARGET, 0));
1139 if (body)
1140 gimple_omp_set_body (p, body);
1141 gimple_omp_target_set_clauses (p, clauses);
1142 gimple_omp_target_set_kind (p, kind);
1143
1144 return p;
1145}
1146
1147
1148/* Build a GIMPLE_OMP_TEAMS statement.
1149
1150 BODY is the sequence of statements that will be executed.
1151 CLAUSES are any of the OMP teams construct's clauses. */
1152
1153gomp_teams *
1154gimple_build_omp_teams (gimple_seq body, tree clauses)
1155{
1156 gomp_teams *p = as_a <gomp_teams *> (gimple_alloc (GIMPLE_OMP_TEAMS, 0));
1157 if (body)
1158 gimple_omp_set_body (p, body);
1159 gimple_omp_teams_set_clauses (p, clauses);
1160
1161 return p;
1162}
1163
1164
1165/* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1166
1167gomp_atomic_load *
1168gimple_build_omp_atomic_load (tree lhs, tree rhs)
1169{
1170 gomp_atomic_load *p
1171 = as_a <gomp_atomic_load *> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0));
1172 gimple_omp_atomic_load_set_lhs (p, lhs);
1173 gimple_omp_atomic_load_set_rhs (p, rhs);
1174 return p;
1175}
1176
1177/* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1178
1179 VAL is the value we are storing. */
1180
1181gomp_atomic_store *
1182gimple_build_omp_atomic_store (tree val)
1183{
1184 gomp_atomic_store *p
1185 = as_a <gomp_atomic_store *> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE, 0));
1186 gimple_omp_atomic_store_set_val (p, val);
1187 return p;
1188}
1189
1190/* Build a GIMPLE_TRANSACTION statement. */
1191
1192gtransaction *
1193gimple_build_transaction (gimple_seq body)
1194{
1195 gtransaction *p
1196 = as_a <gtransaction *> (gimple_alloc (GIMPLE_TRANSACTION, 0));
1197 gimple_transaction_set_body (p, body);
1198 gimple_transaction_set_label_norm (p, 0);
1199 gimple_transaction_set_label_uninst (p, 0);
1200 gimple_transaction_set_label_over (p, 0);
1201 return p;
1202}
1203
1204#if defined ENABLE_GIMPLE_CHECKING
1205/* Complain of a gimple type mismatch and die. */
1206
1207void
1208gimple_check_failed (const gimple *gs, const char *file, int line,
1209 const char *function, enum gimple_code code,
1210 enum tree_code subcode)
1211{
1212 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1213 gimple_code_name[code],
1214 get_tree_code_name (subcode),
1215 gimple_code_name[gimple_code (gs)],
1216 gs->subcode > 0
1217 ? get_tree_code_name ((enum tree_code) gs->subcode)
1218 : "",
1219 function, trim_filename (file), line);
1220}
1221#endif /* ENABLE_GIMPLE_CHECKING */
1222
1223
1224/* Link gimple statement GS to the end of the sequence *SEQ_P. If
1225 *SEQ_P is NULL, a new sequence is allocated. */
1226
1227void
1228gimple_seq_add_stmt (gimple_seq *seq_p, gimple *gs)
1229{
1230 gimple_stmt_iterator si;
1231 if (gs == NULL)
1232 return;
1233
1234 si = gsi_last (*seq_p);
1235 gsi_insert_after (&si, gs, GSI_NEW_STMT);
1236}
1237
1238/* Link gimple statement GS to the end of the sequence *SEQ_P. If
1239 *SEQ_P is NULL, a new sequence is allocated. This function is
1240 similar to gimple_seq_add_stmt, but does not scan the operands.
1241 During gimplification, we need to manipulate statement sequences
1242 before the def/use vectors have been constructed. */
1243
1244void
1245gimple_seq_add_stmt_without_update (gimple_seq *seq_p, gimple *gs)
1246{
1247 gimple_stmt_iterator si;
1248
1249 if (gs == NULL)
1250 return;
1251
1252 si = gsi_last (*seq_p);
1253 gsi_insert_after_without_update (&si, gs, GSI_NEW_STMT);
1254}
1255
1256/* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1257 NULL, a new sequence is allocated. */
1258
1259void
1260gimple_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
1261{
1262 gimple_stmt_iterator si;
1263 if (src == NULL)
1264 return;
1265
1266 si = gsi_last (*dst_p);
1267 gsi_insert_seq_after (&si, src, GSI_NEW_STMT);
1268}
1269
1270/* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1271 NULL, a new sequence is allocated. This function is
1272 similar to gimple_seq_add_seq, but does not scan the operands. */
1273
1274void
1275gimple_seq_add_seq_without_update (gimple_seq *dst_p, gimple_seq src)
1276{
1277 gimple_stmt_iterator si;
1278 if (src == NULL)
1279 return;
1280
1281 si = gsi_last (*dst_p);
1282 gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
1283}
1284
1285/* Determine whether to assign a location to the statement GS. */
1286
1287static bool
1288should_carry_location_p (gimple *gs)
1289{
1290 /* Don't emit a line note for a label. We particularly don't want to
1291 emit one for the break label, since it doesn't actually correspond
1292 to the beginning of the loop/switch. */
1293 if (gimple_code (gs) == GIMPLE_LABEL)
1294 return false;
1295
1296 return true;
1297}
1298
1299/* Set the location for gimple statement GS to LOCATION. */
1300
1301static void
1302annotate_one_with_location (gimple *gs, location_t location)
1303{
1304 if (!gimple_has_location (gs)
1305 && !gimple_do_not_emit_location_p (gs)
1306 && should_carry_location_p (gs))
1307 gimple_set_location (gs, location);
1308}
1309
1310/* Set LOCATION for all the statements after iterator GSI in sequence
1311 SEQ. If GSI is pointing to the end of the sequence, start with the
1312 first statement in SEQ. */
1313
1314void
1315annotate_all_with_location_after (gimple_seq seq, gimple_stmt_iterator gsi,
1316 location_t location)
1317{
1318 if (gsi_end_p (gsi))
1319 gsi = gsi_start (seq);
1320 else
1321 gsi_next (&gsi);
1322
1323 for (; !gsi_end_p (gsi); gsi_next (&gsi))
1324 annotate_one_with_location (gsi_stmt (gsi), location);
1325}
1326
1327/* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1328
1329void
1330annotate_all_with_location (gimple_seq stmt_p, location_t location)
1331{
1332 gimple_stmt_iterator i;
1333
1334 if (gimple_seq_empty_p (stmt_p))
1335 return;
1336
1337 for (i = gsi_start (stmt_p); !gsi_end_p (i); gsi_next (&i))
1338 {
1339 gimple *gs = gsi_stmt (i);
1340 annotate_one_with_location (gs, location);
1341 }
1342}
1343
1344/* Helper function of empty_body_p. Return true if STMT is an empty
1345 statement. */
1346
1347static bool
1348empty_stmt_p (gimple *stmt)
1349{
1350 if (gimple_code (stmt) == GIMPLE_NOP)
1351 return true;
1352 if (gbind *bind_stmt = dyn_cast <gbind *> (stmt))
1353 return empty_body_p (gimple_bind_body (bind_stmt));
1354 return false;
1355}
1356
1357
1358/* Return true if BODY contains nothing but empty statements. */
1359
1360bool
1361empty_body_p (gimple_seq body)
1362{
1363 gimple_stmt_iterator i;
1364
1365 if (gimple_seq_empty_p (body))
1366 return true;
1367 for (i = gsi_start (body); !gsi_end_p (i); gsi_next (&i))
1368 if (!empty_stmt_p (gsi_stmt (i))
1369 && !is_gimple_debug (gsi_stmt (i)))
1370 return false;
1371
1372 return true;
1373}
1374
1375
1376/* Perform a deep copy of sequence SRC and return the result. */
1377
1378gimple_seq
1379gimple_seq_copy (gimple_seq src)
1380{
1381 gimple_stmt_iterator gsi;
1382 gimple_seq new_seq = NULL;
1383 gimple *stmt;
1384
1385 for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi))
1386 {
1387 stmt = gimple_copy (gsi_stmt (gsi));
1388 gimple_seq_add_stmt (&new_seq, stmt);
1389 }
1390
1391 return new_seq;
1392}
1393
1394
1395
1396/* Return true if calls C1 and C2 are known to go to the same function. */
1397
1398bool
1399gimple_call_same_target_p (const gimple *c1, const gimple *c2)
1400{
1401 if (gimple_call_internal_p (c1))
1402 return (gimple_call_internal_p (c2)
1403 && gimple_call_internal_fn (c1) == gimple_call_internal_fn (c2)
1404 && (!gimple_call_internal_unique_p (as_a <const gcall *> (c1))
1405 || c1 == c2));
1406 else
1407 return (gimple_call_fn (c1) == gimple_call_fn (c2)
1408 || (gimple_call_fndecl (c1)
1409 && gimple_call_fndecl (c1) == gimple_call_fndecl (c2)));
1410}
1411
1412/* Detect flags from a GIMPLE_CALL. This is just like
1413 call_expr_flags, but for gimple tuples. */
1414
1415int
1416gimple_call_flags (const gimple *stmt)
1417{
1418 int flags;
1419 tree decl = gimple_call_fndecl (stmt);
1420
1421 if (decl)
1422 flags = flags_from_decl_or_type (decl);
1423 else if (gimple_call_internal_p (stmt))
1424 flags = internal_fn_flags (gimple_call_internal_fn (stmt));
1425 else
1426 flags = flags_from_decl_or_type (gimple_call_fntype (stmt));
1427
1428 if (stmt->subcode & GF_CALL_NOTHROW)
1429 flags |= ECF_NOTHROW;
1430
1431 if (stmt->subcode & GF_CALL_BY_DESCRIPTOR)
1432 flags |= ECF_BY_DESCRIPTOR;
1433
1434 return flags;
1435}
1436
1437/* Return the "fn spec" string for call STMT. */
1438
1439static const_tree
1440gimple_call_fnspec (const gcall *stmt)
1441{
1442 tree type, attr;
1443
1444 if (gimple_call_internal_p (stmt))
1445 return internal_fn_fnspec (gimple_call_internal_fn (stmt));
1446
1447 type = gimple_call_fntype (stmt);
1448 if (!type)
1449 return NULL_TREE;
1450
1451 attr = lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type));
1452 if (!attr)
1453 return NULL_TREE;
1454
1455 return TREE_VALUE (TREE_VALUE (attr));
1456}
1457
1458/* Detects argument flags for argument number ARG on call STMT. */
1459
1460int
1461gimple_call_arg_flags (const gcall *stmt, unsigned arg)
1462{
1463 const_tree attr = gimple_call_fnspec (stmt);
1464
1465 if (!attr || 1 + arg >= (unsigned) TREE_STRING_LENGTH (attr))
1466 return 0;
1467
1468 switch (TREE_STRING_POINTER (attr)[1 + arg])
1469 {
1470 case 'x':
1471 case 'X':
1472 return EAF_UNUSED;
1473
1474 case 'R':
1475 return EAF_DIRECT | EAF_NOCLOBBER | EAF_NOESCAPE;
1476
1477 case 'r':
1478 return EAF_NOCLOBBER | EAF_NOESCAPE;
1479
1480 case 'W':
1481 return EAF_DIRECT | EAF_NOESCAPE;
1482
1483 case 'w':
1484 return EAF_NOESCAPE;
1485
1486 case '.':
1487 default:
1488 return 0;
1489 }
1490}
1491
1492/* Detects return flags for the call STMT. */
1493
1494int
1495gimple_call_return_flags (const gcall *stmt)
1496{
1497 const_tree attr;
1498
1499 if (gimple_call_flags (stmt) & ECF_MALLOC)
1500 return ERF_NOALIAS;
1501
1502 attr = gimple_call_fnspec (stmt);
1503 if (!attr || TREE_STRING_LENGTH (attr) < 1)
1504 return 0;
1505
1506 switch (TREE_STRING_POINTER (attr)[0])
1507 {
1508 case '1':
1509 case '2':
1510 case '3':
1511 case '4':
1512 return ERF_RETURNS_ARG | (TREE_STRING_POINTER (attr)[0] - '1');
1513
1514 case 'm':
1515 return ERF_NOALIAS;
1516
1517 case '.':
1518 default:
1519 return 0;
1520 }
1521}
1522
1523
1524/* Return true if GS is a copy assignment. */
1525
1526bool
1527gimple_assign_copy_p (gimple *gs)
1528{
1529 return (gimple_assign_single_p (gs)
1530 && is_gimple_val (gimple_op (gs, 1)));
1531}
1532
1533
1534/* Return true if GS is a SSA_NAME copy assignment. */
1535
1536bool
1537gimple_assign_ssa_name_copy_p (gimple *gs)
1538{
1539 return (gimple_assign_single_p (gs)
1540 && TREE_CODE (gimple_assign_lhs (gs)) == SSA_NAME
1541 && TREE_CODE (gimple_assign_rhs1 (gs)) == SSA_NAME);
1542}
1543
1544
1545/* Return true if GS is an assignment with a unary RHS, but the
1546 operator has no effect on the assigned value. The logic is adapted
1547 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1548 instances in which STRIP_NOPS was previously applied to the RHS of
1549 an assignment.
1550
1551 NOTE: In the use cases that led to the creation of this function
1552 and of gimple_assign_single_p, it is typical to test for either
1553 condition and to proceed in the same manner. In each case, the
1554 assigned value is represented by the single RHS operand of the
1555 assignment. I suspect there may be cases where gimple_assign_copy_p,
1556 gimple_assign_single_p, or equivalent logic is used where a similar
1557 treatment of unary NOPs is appropriate. */
1558
1559bool
1560gimple_assign_unary_nop_p (gimple *gs)
1561{
1562 return (is_gimple_assign (gs)
1563 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
1564 || gimple_assign_rhs_code (gs) == NON_LVALUE_EXPR)
1565 && gimple_assign_rhs1 (gs) != error_mark_node
1566 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs)))
1567 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs)))));
1568}
1569
1570/* Set BB to be the basic block holding G. */
1571
1572void
1573gimple_set_bb (gimple *stmt, basic_block bb)
1574{
1575 stmt->bb = bb;
1576
1577 if (gimple_code (stmt) != GIMPLE_LABEL)
1578 return;
1579
1580 /* If the statement is a label, add the label to block-to-labels map
1581 so that we can speed up edge creation for GIMPLE_GOTOs. */
1582 if (cfun->cfg)
1583 {
1584 tree t;
1585 int uid;
1586
1587 t = gimple_label_label (as_a <glabel *> (stmt));
1588 uid = LABEL_DECL_UID (t);
1589 if (uid == -1)
1590 {
1591 unsigned old_len =
1592 vec_safe_length (label_to_block_map_for_fn (cfun));
1593 LABEL_DECL_UID (t) = uid = cfun->cfg->last_label_uid++;
1594 if (old_len <= (unsigned) uid)
1595 {
1596 unsigned new_len = 3 * uid / 2 + 1;
1597
1598 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun),
1599 new_len);
1600 }
1601 }
1602
1603 (*label_to_block_map_for_fn (cfun))[uid] = bb;
1604 }
1605}
1606
1607
1608/* Modify the RHS of the assignment pointed-to by GSI using the
1609 operands in the expression tree EXPR.
1610
1611 NOTE: The statement pointed-to by GSI may be reallocated if it
1612 did not have enough operand slots.
1613
1614 This function is useful to convert an existing tree expression into
1615 the flat representation used for the RHS of a GIMPLE assignment.
1616 It will reallocate memory as needed to expand or shrink the number
1617 of operand slots needed to represent EXPR.
1618
1619 NOTE: If you find yourself building a tree and then calling this
1620 function, you are most certainly doing it the slow way. It is much
1621 better to build a new assignment or to use the function
1622 gimple_assign_set_rhs_with_ops, which does not require an
1623 expression tree to be built. */
1624
1625void
1626gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *gsi, tree expr)
1627{
1628 enum tree_code subcode;
1629 tree op1, op2, op3;
1630
1631 extract_ops_from_tree (expr, &subcode, &op1, &op2, &op3);
1632 gimple_assign_set_rhs_with_ops (gsi, subcode, op1, op2, op3);
1633}
1634
1635
1636/* Set the RHS of assignment statement pointed-to by GSI to CODE with
1637 operands OP1, OP2 and OP3.
1638
1639 NOTE: The statement pointed-to by GSI may be reallocated if it
1640 did not have enough operand slots. */
1641
1642void
1643gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
1644 tree op1, tree op2, tree op3)
1645{
1646 unsigned new_rhs_ops = get_gimple_rhs_num_ops (code);
1647 gimple *stmt = gsi_stmt (*gsi);
1648
1649 /* If the new CODE needs more operands, allocate a new statement. */
1650 if (gimple_num_ops (stmt) < new_rhs_ops + 1)
1651 {
1652 tree lhs = gimple_assign_lhs (stmt);
1653 gimple *new_stmt = gimple_alloc (gimple_code (stmt), new_rhs_ops + 1);
1654 memcpy (new_stmt, stmt, gimple_size (gimple_code (stmt)));
1655 gimple_init_singleton (new_stmt);
1656 gsi_replace (gsi, new_stmt, false);
1657 stmt = new_stmt;
1658
1659 /* The LHS needs to be reset as this also changes the SSA name
1660 on the LHS. */
1661 gimple_assign_set_lhs (stmt, lhs);
1662 }
1663
1664 gimple_set_num_ops (stmt, new_rhs_ops + 1);
1665 gimple_set_subcode (stmt, code);
1666 gimple_assign_set_rhs1 (stmt, op1);
1667 if (new_rhs_ops > 1)
1668 gimple_assign_set_rhs2 (stmt, op2);
1669 if (new_rhs_ops > 2)
1670 gimple_assign_set_rhs3 (stmt, op3);
1671}
1672
1673
1674/* Return the LHS of a statement that performs an assignment,
1675 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1676 for a call to a function that returns no value, or for a
1677 statement other than an assignment or a call. */
1678
1679tree
1680gimple_get_lhs (const gimple *stmt)
1681{
1682 enum gimple_code code = gimple_code (stmt);
1683
1684 if (code == GIMPLE_ASSIGN)
1685 return gimple_assign_lhs (stmt);
1686 else if (code == GIMPLE_CALL)
1687 return gimple_call_lhs (stmt);
1688 else
1689 return NULL_TREE;
1690}
1691
1692
1693/* Set the LHS of a statement that performs an assignment,
1694 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1695
1696void
1697gimple_set_lhs (gimple *stmt, tree lhs)
1698{
1699 enum gimple_code code = gimple_code (stmt);
1700
1701 if (code == GIMPLE_ASSIGN)
1702 gimple_assign_set_lhs (stmt, lhs);
1703 else if (code == GIMPLE_CALL)
1704 gimple_call_set_lhs (stmt, lhs);
1705 else
1706 gcc_unreachable ();
1707}
1708
1709
1710/* Return a deep copy of statement STMT. All the operands from STMT
1711 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1712 and VUSE operand arrays are set to empty in the new copy. The new
1713 copy isn't part of any sequence. */
1714
1715gimple *
1716gimple_copy (gimple *stmt)
1717{
1718 enum gimple_code code = gimple_code (stmt);
1719 unsigned num_ops = gimple_num_ops (stmt);
1720 gimple *copy = gimple_alloc (code, num_ops);
1721 unsigned i;
1722
1723 /* Shallow copy all the fields from STMT. */
1724 memcpy (copy, stmt, gimple_size (code));
1725 gimple_init_singleton (copy);
1726
1727 /* If STMT has sub-statements, deep-copy them as well. */
1728 if (gimple_has_substatements (stmt))
1729 {
1730 gimple_seq new_seq;
1731 tree t;
1732
1733 switch (gimple_code (stmt))
1734 {
1735 case GIMPLE_BIND:
1736 {
1737 gbind *bind_stmt = as_a <gbind *> (stmt);
1738 gbind *bind_copy = as_a <gbind *> (copy);
1739 new_seq = gimple_seq_copy (gimple_bind_body (bind_stmt));
1740 gimple_bind_set_body (bind_copy, new_seq);
1741 gimple_bind_set_vars (bind_copy,
1742 unshare_expr (gimple_bind_vars (bind_stmt)));
1743 gimple_bind_set_block (bind_copy, gimple_bind_block (bind_stmt));
1744 }
1745 break;
1746
1747 case GIMPLE_CATCH:
1748 {
1749 gcatch *catch_stmt = as_a <gcatch *> (stmt);
1750 gcatch *catch_copy = as_a <gcatch *> (copy);
1751 new_seq = gimple_seq_copy (gimple_catch_handler (catch_stmt));
1752 gimple_catch_set_handler (catch_copy, new_seq);
1753 t = unshare_expr (gimple_catch_types (catch_stmt));
1754 gimple_catch_set_types (catch_copy, t);
1755 }
1756 break;
1757
1758 case GIMPLE_EH_FILTER:
1759 {
1760 geh_filter *eh_filter_stmt = as_a <geh_filter *> (stmt);
1761 geh_filter *eh_filter_copy = as_a <geh_filter *> (copy);
1762 new_seq
1763 = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt));
1764 gimple_eh_filter_set_failure (eh_filter_copy, new_seq);
1765 t = unshare_expr (gimple_eh_filter_types (eh_filter_stmt));
1766 gimple_eh_filter_set_types (eh_filter_copy, t);
1767 }
1768 break;
1769
1770 case GIMPLE_EH_ELSE:
1771 {
1772 geh_else *eh_else_stmt = as_a <geh_else *> (stmt);
1773 geh_else *eh_else_copy = as_a <geh_else *> (copy);
1774 new_seq = gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt));
1775 gimple_eh_else_set_n_body (eh_else_copy, new_seq);
1776 new_seq = gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt));
1777 gimple_eh_else_set_e_body (eh_else_copy, new_seq);
1778 }
1779 break;
1780
1781 case GIMPLE_TRY:
1782 {
1783 gtry *try_stmt = as_a <gtry *> (stmt);
1784 gtry *try_copy = as_a <gtry *> (copy);
1785 new_seq = gimple_seq_copy (gimple_try_eval (try_stmt));
1786 gimple_try_set_eval (try_copy, new_seq);
1787 new_seq = gimple_seq_copy (gimple_try_cleanup (try_stmt));
1788 gimple_try_set_cleanup (try_copy, new_seq);
1789 }
1790 break;
1791
1792 case GIMPLE_OMP_FOR:
1793 new_seq = gimple_seq_copy (gimple_omp_for_pre_body (stmt));
1794 gimple_omp_for_set_pre_body (copy, new_seq);
1795 t = unshare_expr (gimple_omp_for_clauses (stmt));
1796 gimple_omp_for_set_clauses (copy, t);
1797 {
1798 gomp_for *omp_for_copy = as_a <gomp_for *> (copy);
1799 omp_for_copy->iter = ggc_vec_alloc<gimple_omp_for_iter>
1800 ( gimple_omp_for_collapse (stmt));
1801 }
1802 for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
1803 {
1804 gimple_omp_for_set_cond (copy, i,
1805 gimple_omp_for_cond (stmt, i));
1806 gimple_omp_for_set_index (copy, i,
1807 gimple_omp_for_index (stmt, i));
1808 t = unshare_expr (gimple_omp_for_initial (stmt, i));
1809 gimple_omp_for_set_initial (copy, i, t);
1810 t = unshare_expr (gimple_omp_for_final (stmt, i));
1811 gimple_omp_for_set_final (copy, i, t);
1812 t = unshare_expr (gimple_omp_for_incr (stmt, i));
1813 gimple_omp_for_set_incr (copy, i, t);
1814 }
1815 goto copy_omp_body;
1816
1817 case GIMPLE_OMP_PARALLEL:
1818 {
1819 gomp_parallel *omp_par_stmt = as_a <gomp_parallel *> (stmt);
1820 gomp_parallel *omp_par_copy = as_a <gomp_parallel *> (copy);
1821 t = unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt));
1822 gimple_omp_parallel_set_clauses (omp_par_copy, t);
1823 t = unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt));
1824 gimple_omp_parallel_set_child_fn (omp_par_copy, t);
1825 t = unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt));
1826 gimple_omp_parallel_set_data_arg (omp_par_copy, t);
1827 }
1828 goto copy_omp_body;
1829
1830 case GIMPLE_OMP_TASK:
1831 t = unshare_expr (gimple_omp_task_clauses (stmt));
1832 gimple_omp_task_set_clauses (copy, t);
1833 t = unshare_expr (gimple_omp_task_child_fn (stmt));
1834 gimple_omp_task_set_child_fn (copy, t);
1835 t = unshare_expr (gimple_omp_task_data_arg (stmt));
1836 gimple_omp_task_set_data_arg (copy, t);
1837 t = unshare_expr (gimple_omp_task_copy_fn (stmt));
1838 gimple_omp_task_set_copy_fn (copy, t);
1839 t = unshare_expr (gimple_omp_task_arg_size (stmt));
1840 gimple_omp_task_set_arg_size (copy, t);
1841 t = unshare_expr (gimple_omp_task_arg_align (stmt));
1842 gimple_omp_task_set_arg_align (copy, t);
1843 goto copy_omp_body;
1844
1845 case GIMPLE_OMP_CRITICAL:
1846 t = unshare_expr (gimple_omp_critical_name
1847 (as_a <gomp_critical *> (stmt)));
1848 gimple_omp_critical_set_name (as_a <gomp_critical *> (copy), t);
1849 t = unshare_expr (gimple_omp_critical_clauses
1850 (as_a <gomp_critical *> (stmt)));
1851 gimple_omp_critical_set_clauses (as_a <gomp_critical *> (copy), t);
1852 goto copy_omp_body;
1853
1854 case GIMPLE_OMP_ORDERED:
1855 t = unshare_expr (gimple_omp_ordered_clauses
1856 (as_a <gomp_ordered *> (stmt)));
1857 gimple_omp_ordered_set_clauses (as_a <gomp_ordered *> (copy), t);
1858 goto copy_omp_body;
1859
1860 case GIMPLE_OMP_SECTIONS:
1861 t = unshare_expr (gimple_omp_sections_clauses (stmt));
1862 gimple_omp_sections_set_clauses (copy, t);
1863 t = unshare_expr (gimple_omp_sections_control (stmt));
1864 gimple_omp_sections_set_control (copy, t);
1865 goto copy_omp_body;
1866
1867 case GIMPLE_OMP_SINGLE:
1868 {
1869 gomp_single *omp_single_copy = as_a <gomp_single *> (copy);
1870 t = unshare_expr (gimple_omp_single_clauses (stmt));
1871 gimple_omp_single_set_clauses (omp_single_copy, t);
1872 }
1873 goto copy_omp_body;
1874
1875 case GIMPLE_OMP_TARGET:
1876 {
1877 gomp_target *omp_target_stmt = as_a <gomp_target *> (stmt);
1878 gomp_target *omp_target_copy = as_a <gomp_target *> (copy);
1879 t = unshare_expr (gimple_omp_target_clauses (omp_target_stmt));
1880 gimple_omp_target_set_clauses (omp_target_copy, t);
1881 t = unshare_expr (gimple_omp_target_data_arg (omp_target_stmt));
1882 gimple_omp_target_set_data_arg (omp_target_copy, t);
1883 }
1884 goto copy_omp_body;
1885
1886 case GIMPLE_OMP_TEAMS:
1887 {
1888 gomp_teams *omp_teams_copy = as_a <gomp_teams *> (copy);
1889 t = unshare_expr (gimple_omp_teams_clauses (stmt));
1890 gimple_omp_teams_set_clauses (omp_teams_copy, t);
1891 }
1892 /* FALLTHRU */
1893
1894 case GIMPLE_OMP_SECTION:
1895 case GIMPLE_OMP_MASTER:
1896 case GIMPLE_OMP_TASKGROUP:
1897 case GIMPLE_OMP_GRID_BODY:
1898 copy_omp_body:
1899 new_seq = gimple_seq_copy (gimple_omp_body (stmt));
1900 gimple_omp_set_body (copy, new_seq);
1901 break;
1902
1903 case GIMPLE_TRANSACTION:
1904 new_seq = gimple_seq_copy (gimple_transaction_body (
1905 as_a <gtransaction *> (stmt)));
1906 gimple_transaction_set_body (as_a <gtransaction *> (copy),
1907 new_seq);
1908 break;
1909
1910 case GIMPLE_WITH_CLEANUP_EXPR:
1911 new_seq = gimple_seq_copy (gimple_wce_cleanup (stmt));
1912 gimple_wce_set_cleanup (copy, new_seq);
1913 break;
1914
1915 default:
1916 gcc_unreachable ();
1917 }
1918 }
1919
1920 /* Make copy of operands. */
1921 for (i = 0; i < num_ops; i++)
1922 gimple_set_op (copy, i, unshare_expr (gimple_op (stmt, i)));
1923
1924 if (gimple_has_mem_ops (stmt))
1925 {
1926 gimple_set_vdef (copy, gimple_vdef (stmt));
1927 gimple_set_vuse (copy, gimple_vuse (stmt));
1928 }
1929
1930 /* Clear out SSA operand vectors on COPY. */
1931 if (gimple_has_ops (stmt))
1932 {
1933 gimple_set_use_ops (copy, NULL);
1934
1935 /* SSA operands need to be updated. */
1936 gimple_set_modified (copy, true);
1937 }
1938
1939 if (gimple_debug_nonbind_marker_p (stmt))
1940 cfun->debug_marker_count++;
1941
1942 return copy;
1943}
1944
1945
1946/* Return true if statement S has side-effects. We consider a
1947 statement to have side effects if:
1948
1949 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
1950 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
1951
1952bool
1953gimple_has_side_effects (const gimple *s)
1954{
1955 if (is_gimple_debug (s))
1956 return false;
1957
1958 /* We don't have to scan the arguments to check for
1959 volatile arguments, though, at present, we still
1960 do a scan to check for TREE_SIDE_EFFECTS. */
1961 if (gimple_has_volatile_ops (s))
1962 return true;
1963
1964 if (gimple_code (s) == GIMPLE_ASM
1965 && gimple_asm_volatile_p (as_a <const gasm *> (s)))
1966 return true;
1967
1968 if (is_gimple_call (s))
1969 {
1970 int flags = gimple_call_flags (s);
1971
1972 /* An infinite loop is considered a side effect. */
1973 if (!(flags & (ECF_CONST | ECF_PURE))
1974 || (flags & ECF_LOOPING_CONST_OR_PURE))
1975 return true;
1976
1977 return false;
1978 }
1979
1980 return false;
1981}
1982
1983/* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
1984 Return true if S can trap. When INCLUDE_MEM is true, check whether
1985 the memory operations could trap. When INCLUDE_STORES is true and
1986 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
1987
1988bool
1989gimple_could_trap_p_1 (gimple *s, bool include_mem, bool include_stores)
1990{
1991 tree t, div = NULL_TREE;
1992 enum tree_code op;
1993
1994 if (include_mem)
1995 {
1996 unsigned i, start = (is_gimple_assign (s) && !include_stores) ? 1 : 0;
1997
1998 for (i = start; i < gimple_num_ops (s); i++)
1999 if (tree_could_trap_p (gimple_op (s, i)))
2000 return true;
2001 }
2002
2003 switch (gimple_code (s))
2004 {
2005 case GIMPLE_ASM:
2006 return gimple_asm_volatile_p (as_a <gasm *> (s));
2007
2008 case GIMPLE_CALL:
2009 t = gimple_call_fndecl (s);
2010 /* Assume that calls to weak functions may trap. */
2011 if (!t || !DECL_P (t) || DECL_WEAK (t))
2012 return true;
2013 return false;
2014
2015 case GIMPLE_ASSIGN:
2016 t = gimple_expr_type (s);
2017 op = gimple_assign_rhs_code (s);
2018 if (get_gimple_rhs_class (op) == GIMPLE_BINARY_RHS)
2019 div = gimple_assign_rhs2 (s);
2020 return (operation_could_trap_p (op, FLOAT_TYPE_P (t),
2021 (INTEGRAL_TYPE_P (t)
2022 && TYPE_OVERFLOW_TRAPS (t)),
2023 div));
2024
2025 case GIMPLE_COND:
2026 t = TREE_TYPE (gimple_cond_lhs (s));
2027 return operation_could_trap_p (gimple_cond_code (s),
2028 FLOAT_TYPE_P (t), false, NULL_TREE);
2029
2030 default:
2031 break;
2032 }
2033
2034 return false;
2035}
2036
2037/* Return true if statement S can trap. */
2038
2039bool
2040gimple_could_trap_p (gimple *s)
2041{
2042 return gimple_could_trap_p_1 (s, true, true);
2043}
2044
2045/* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
2046
2047bool
2048gimple_assign_rhs_could_trap_p (gimple *s)
2049{
2050 gcc_assert (is_gimple_assign (s));
2051 return gimple_could_trap_p_1 (s, true, false);
2052}
2053
2054
2055/* Print debugging information for gimple stmts generated. */
2056
2057void
2058dump_gimple_statistics (void)
2059{
2060 int i, total_tuples = 0, total_bytes = 0;
2061
2062 if (! GATHER_STATISTICS)
2063 {
2064 fprintf (stderr, "No gimple statistics\n");
2065 return;
2066 }
2067
2068 fprintf (stderr, "\nGIMPLE statements\n");
2069 fprintf (stderr, "Kind Stmts Bytes\n");
2070 fprintf (stderr, "---------------------------------------\n");
2071 for (i = 0; i < (int) gimple_alloc_kind_all; ++i)
2072 {
2073 fprintf (stderr, "%-20s %7d %10d\n", gimple_alloc_kind_names[i],
2074 gimple_alloc_counts[i], gimple_alloc_sizes[i]);
2075 total_tuples += gimple_alloc_counts[i];
2076 total_bytes += gimple_alloc_sizes[i];
2077 }
2078 fprintf (stderr, "---------------------------------------\n");
2079 fprintf (stderr, "%-20s %7d %10d\n", "Total", total_tuples, total_bytes);
2080 fprintf (stderr, "---------------------------------------\n");
2081}
2082
2083
2084/* Return the number of operands needed on the RHS of a GIMPLE
2085 assignment for an expression with tree code CODE. */
2086
2087unsigned
2088get_gimple_rhs_num_ops (enum tree_code code)
2089{
2090 enum gimple_rhs_class rhs_class = get_gimple_rhs_class (code);
2091
2092 if (rhs_class == GIMPLE_UNARY_RHS || rhs_class == GIMPLE_SINGLE_RHS)
2093 return 1;
2094 else if (rhs_class == GIMPLE_BINARY_RHS)
2095 return 2;
2096 else if (rhs_class == GIMPLE_TERNARY_RHS)
2097 return 3;
2098 else
2099 gcc_unreachable ();
2100}
2101
2102#define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2103 (unsigned char) \
2104 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2105 : ((TYPE) == tcc_binary \
2106 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2107 : ((TYPE) == tcc_constant \
2108 || (TYPE) == tcc_declaration \
2109 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2110 : ((SYM) == TRUTH_AND_EXPR \
2111 || (SYM) == TRUTH_OR_EXPR \
2112 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2113 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2114 : ((SYM) == COND_EXPR \
2115 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2116 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2117 || (SYM) == DOT_PROD_EXPR \
2118 || (SYM) == SAD_EXPR \
2119 || (SYM) == REALIGN_LOAD_EXPR \
2120 || (SYM) == VEC_COND_EXPR \
2121 || (SYM) == VEC_PERM_EXPR \
2122 || (SYM) == BIT_INSERT_EXPR \
2123 || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS \
2124 : ((SYM) == CONSTRUCTOR \
2125 || (SYM) == OBJ_TYPE_REF \
2126 || (SYM) == ASSERT_EXPR \
2127 || (SYM) == ADDR_EXPR \
2128 || (SYM) == WITH_SIZE_EXPR \
2129 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2130 : GIMPLE_INVALID_RHS),
2131#define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2132
2133const unsigned char gimple_rhs_class_table[] = {
2134#include "all-tree.def"
2135};
2136
2137#undef DEFTREECODE
2138#undef END_OF_BASE_TREE_CODES
2139
2140/* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
2141 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2142 we failed to create one. */
2143
2144tree
2145canonicalize_cond_expr_cond (tree t)
2146{
2147 /* Strip conversions around boolean operations. */
2148 if (CONVERT_EXPR_P (t)
2149 && (truth_value_p (TREE_CODE (TREE_OPERAND (t, 0)))
2150 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0)))
2151 == BOOLEAN_TYPE))
2152 t = TREE_OPERAND (t, 0);
2153
2154 /* For !x use x == 0. */
2155 if (TREE_CODE (t) == TRUTH_NOT_EXPR)
2156 {
2157 tree top0 = TREE_OPERAND (t, 0);
2158 t = build2 (EQ_EXPR, TREE_TYPE (t),
2159 top0, build_int_cst (TREE_TYPE (top0), 0));
2160 }
2161 /* For cmp ? 1 : 0 use cmp. */
2162 else if (TREE_CODE (t) == COND_EXPR
2163 && COMPARISON_CLASS_P (TREE_OPERAND (t, 0))
2164 && integer_onep (TREE_OPERAND (t, 1))
2165 && integer_zerop (TREE_OPERAND (t, 2)))
2166 {
2167 tree top0 = TREE_OPERAND (t, 0);
2168 t = build2 (TREE_CODE (top0), TREE_TYPE (t),
2169 TREE_OPERAND (top0, 0), TREE_OPERAND (top0, 1));
2170 }
2171 /* For x ^ y use x != y. */
2172 else if (TREE_CODE (t) == BIT_XOR_EXPR)
2173 t = build2 (NE_EXPR, TREE_TYPE (t),
2174 TREE_OPERAND (t, 0), TREE_OPERAND (t, 1));
2175
2176 if (is_gimple_condexpr (t))
2177 return t;
2178
2179 return NULL_TREE;
2180}
2181
2182/* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2183 the positions marked by the set ARGS_TO_SKIP. */
2184
2185gcall *
2186gimple_call_copy_skip_args (gcall *stmt, bitmap args_to_skip)
2187{
2188 int i;
2189 int nargs = gimple_call_num_args (stmt);
2190 auto_vec<tree> vargs (nargs);
2191 gcall *new_stmt;
2192
2193 for (i = 0; i < nargs; i++)
2194 if (!bitmap_bit_p (args_to_skip, i))
2195 vargs.quick_push (gimple_call_arg (stmt, i));
2196
2197 if (gimple_call_internal_p (stmt))
2198 new_stmt = gimple_build_call_internal_vec (gimple_call_internal_fn (stmt),
2199 vargs);
2200 else
2201 new_stmt = gimple_build_call_vec (gimple_call_fn (stmt), vargs);
2202
2203 if (gimple_call_lhs (stmt))
2204 gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
2205
2206 gimple_set_vuse (new_stmt, gimple_vuse (stmt));
2207 gimple_set_vdef (new_stmt, gimple_vdef (stmt));
2208
2209 if (gimple_has_location (stmt))
2210 gimple_set_location (new_stmt, gimple_location (stmt));
2211 gimple_call_copy_flags (new_stmt, stmt);
2212 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
2213
2214 gimple_set_modified (new_stmt, true);
2215
2216 return new_stmt;
2217}
2218
2219
2220
2221/* Return true if the field decls F1 and F2 are at the same offset.
2222
2223 This is intended to be used on GIMPLE types only. */
2224
2225bool
2226gimple_compare_field_offset (tree f1, tree f2)
2227{
2228 if (DECL_OFFSET_ALIGN (f1) == DECL_OFFSET_ALIGN (f2))
2229 {
2230 tree offset1 = DECL_FIELD_OFFSET (f1);
2231 tree offset2 = DECL_FIELD_OFFSET (f2);
2232 return ((offset1 == offset2
2233 /* Once gimplification is done, self-referential offsets are
2234 instantiated as operand #2 of the COMPONENT_REF built for
2235 each access and reset. Therefore, they are not relevant
2236 anymore and fields are interchangeable provided that they
2237 represent the same access. */
2238 || (TREE_CODE (offset1) == PLACEHOLDER_EXPR
2239 && TREE_CODE (offset2) == PLACEHOLDER_EXPR
2240 && (DECL_SIZE (f1) == DECL_SIZE (f2)
2241 || (TREE_CODE (DECL_SIZE (f1)) == PLACEHOLDER_EXPR
2242 && TREE_CODE (DECL_SIZE (f2)) == PLACEHOLDER_EXPR)
2243 || operand_equal_p (DECL_SIZE (f1), DECL_SIZE (f2), 0))
2244 && DECL_ALIGN (f1) == DECL_ALIGN (f2))
2245 || operand_equal_p (offset1, offset2, 0))
2246 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1),
2247 DECL_FIELD_BIT_OFFSET (f2)));
2248 }
2249
2250 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2251 should be, so handle differing ones specially by decomposing
2252 the offset into a byte and bit offset manually. */
2253 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1))
2254 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2)))
2255 {
2256 unsigned HOST_WIDE_INT byte_offset1, byte_offset2;
2257 unsigned HOST_WIDE_INT bit_offset1, bit_offset2;
2258 bit_offset1 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1));
2259 byte_offset1 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1))
2260 + bit_offset1 / BITS_PER_UNIT);
2261 bit_offset2 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2));
2262 byte_offset2 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2))
2263 + bit_offset2 / BITS_PER_UNIT);
2264 if (byte_offset1 != byte_offset2)
2265 return false;
2266 return bit_offset1 % BITS_PER_UNIT == bit_offset2 % BITS_PER_UNIT;
2267 }
2268
2269 return false;
2270}
2271
2272
2273/* Return a type the same as TYPE except unsigned or
2274 signed according to UNSIGNEDP. */
2275
2276static tree
2277gimple_signed_or_unsigned_type (bool unsignedp, tree type)
2278{
2279 tree type1;
2280 int i;
2281
2282 type1 = TYPE_MAIN_VARIANT (type);
2283 if (type1 == signed_char_type_node
2284 || type1 == char_type_node
2285 || type1 == unsigned_char_type_node)
2286 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2287 if (type1 == integer_type_node || type1 == unsigned_type_node)
2288 return unsignedp ? unsigned_type_node : integer_type_node;
2289 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
2290 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2291 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
2292 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2293 if (type1 == long_long_integer_type_node
2294 || type1 == long_long_unsigned_type_node)
2295 return unsignedp
2296 ? long_long_unsigned_type_node
2297 : long_long_integer_type_node;
2298
2299 for (i = 0; i < NUM_INT_N_ENTS; i ++)
2300 if (int_n_enabled_p[i]
2301 && (type1 == int_n_trees[i].unsigned_type
2302 || type1 == int_n_trees[i].signed_type))
2303 return unsignedp
2304 ? int_n_trees[i].unsigned_type
2305 : int_n_trees[i].signed_type;
2306
2307#if HOST_BITS_PER_WIDE_INT >= 64
2308 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
2309 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2310#endif
2311 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
2312 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2313 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
2314 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2315 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
2316 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2317 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
2318 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2319
2320#define GIMPLE_FIXED_TYPES(NAME) \
2321 if (type1 == short_ ## NAME ## _type_node \
2322 || type1 == unsigned_short_ ## NAME ## _type_node) \
2323 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2324 : short_ ## NAME ## _type_node; \
2325 if (type1 == NAME ## _type_node \
2326 || type1 == unsigned_ ## NAME ## _type_node) \
2327 return unsignedp ? unsigned_ ## NAME ## _type_node \
2328 : NAME ## _type_node; \
2329 if (type1 == long_ ## NAME ## _type_node \
2330 || type1 == unsigned_long_ ## NAME ## _type_node) \
2331 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2332 : long_ ## NAME ## _type_node; \
2333 if (type1 == long_long_ ## NAME ## _type_node \
2334 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2335 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2336 : long_long_ ## NAME ## _type_node;
2337
2338#define GIMPLE_FIXED_MODE_TYPES(NAME) \
2339 if (type1 == NAME ## _type_node \
2340 || type1 == u ## NAME ## _type_node) \
2341 return unsignedp ? u ## NAME ## _type_node \
2342 : NAME ## _type_node;
2343
2344#define GIMPLE_FIXED_TYPES_SAT(NAME) \
2345 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2346 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2347 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2348 : sat_ ## short_ ## NAME ## _type_node; \
2349 if (type1 == sat_ ## NAME ## _type_node \
2350 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2351 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2352 : sat_ ## NAME ## _type_node; \
2353 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2354 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2355 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2356 : sat_ ## long_ ## NAME ## _type_node; \
2357 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2358 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2359 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2360 : sat_ ## long_long_ ## NAME ## _type_node;
2361
2362#define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2363 if (type1 == sat_ ## NAME ## _type_node \
2364 || type1 == sat_ ## u ## NAME ## _type_node) \
2365 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2366 : sat_ ## NAME ## _type_node;
2367
2368 GIMPLE_FIXED_TYPES (fract);
2369 GIMPLE_FIXED_TYPES_SAT (fract);
2370 GIMPLE_FIXED_TYPES (accum);
2371 GIMPLE_FIXED_TYPES_SAT (accum);
2372
2373 GIMPLE_FIXED_MODE_TYPES (qq);
2374 GIMPLE_FIXED_MODE_TYPES (hq);
2375 GIMPLE_FIXED_MODE_TYPES (sq);
2376 GIMPLE_FIXED_MODE_TYPES (dq);
2377 GIMPLE_FIXED_MODE_TYPES (tq);
2378 GIMPLE_FIXED_MODE_TYPES_SAT (qq);
2379 GIMPLE_FIXED_MODE_TYPES_SAT (hq);
2380 GIMPLE_FIXED_MODE_TYPES_SAT (sq);
2381 GIMPLE_FIXED_MODE_TYPES_SAT (dq);
2382 GIMPLE_FIXED_MODE_TYPES_SAT (tq);
2383 GIMPLE_FIXED_MODE_TYPES (ha);
2384 GIMPLE_FIXED_MODE_TYPES (sa);
2385 GIMPLE_FIXED_MODE_TYPES (da);
2386 GIMPLE_FIXED_MODE_TYPES (ta);
2387 GIMPLE_FIXED_MODE_TYPES_SAT (ha);
2388 GIMPLE_FIXED_MODE_TYPES_SAT (sa);
2389 GIMPLE_FIXED_MODE_TYPES_SAT (da);
2390 GIMPLE_FIXED_MODE_TYPES_SAT (ta);
2391
2392 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2393 the precision; they have precision set to match their range, but
2394 may use a wider mode to match an ABI. If we change modes, we may
2395 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2396 the precision as well, so as to yield correct results for
2397 bit-field types. C++ does not have these separate bit-field
2398 types, and producing a signed or unsigned variant of an
2399 ENUMERAL_TYPE may cause other problems as well. */
2400 if (!INTEGRAL_TYPE_P (type)
2401 || TYPE_UNSIGNED (type) == unsignedp)
2402 return type;
2403
2404#define TYPE_OK(node) \
2405 (TYPE_MODE (type) == TYPE_MODE (node) \
2406 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2407 if (TYPE_OK (signed_char_type_node))
2408 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2409 if (TYPE_OK (integer_type_node))
2410 return unsignedp ? unsigned_type_node : integer_type_node;
2411 if (TYPE_OK (short_integer_type_node))
2412 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2413 if (TYPE_OK (long_integer_type_node))
2414 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2415 if (TYPE_OK (long_long_integer_type_node))
2416 return (unsignedp
2417 ? long_long_unsigned_type_node
2418 : long_long_integer_type_node);
2419
2420 for (i = 0; i < NUM_INT_N_ENTS; i ++)
2421 if (int_n_enabled_p[i]
2422 && TYPE_MODE (type) == int_n_data[i].m
2423 && TYPE_PRECISION (type) == int_n_data[i].bitsize)
2424 return unsignedp
2425 ? int_n_trees[i].unsigned_type
2426 : int_n_trees[i].signed_type;
2427
2428#if HOST_BITS_PER_WIDE_INT >= 64
2429 if (TYPE_OK (intTI_type_node))
2430 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2431#endif
2432 if (TYPE_OK (intDI_type_node))
2433 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2434 if (TYPE_OK (intSI_type_node))
2435 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2436 if (TYPE_OK (intHI_type_node))
2437 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2438 if (TYPE_OK (intQI_type_node))
2439 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2440
2441#undef GIMPLE_FIXED_TYPES
2442#undef GIMPLE_FIXED_MODE_TYPES
2443#undef GIMPLE_FIXED_TYPES_SAT
2444#undef GIMPLE_FIXED_MODE_TYPES_SAT
2445#undef TYPE_OK
2446
2447 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2448}
2449
2450
2451/* Return an unsigned type the same as TYPE in other respects. */
2452
2453tree
2454gimple_unsigned_type (tree type)
2455{
2456 return gimple_signed_or_unsigned_type (true, type);
2457}
2458
2459
2460/* Return a signed type the same as TYPE in other respects. */
2461
2462tree
2463gimple_signed_type (tree type)
2464{
2465 return gimple_signed_or_unsigned_type (false, type);
2466}
2467
2468
2469/* Return the typed-based alias set for T, which may be an expression
2470 or a type. Return -1 if we don't do anything special. */
2471
2472alias_set_type
2473gimple_get_alias_set (tree t)
2474{
2475 /* That's all the expressions we handle specially. */
2476 if (!TYPE_P (t))
2477 return -1;
2478
2479 /* For convenience, follow the C standard when dealing with
2480 character types. Any object may be accessed via an lvalue that
2481 has character type. */
2482 if (t == char_type_node
2483 || t == signed_char_type_node
2484 || t == unsigned_char_type_node)
2485 return 0;
2486
2487 /* Allow aliasing between signed and unsigned variants of the same
2488 type. We treat the signed variant as canonical. */
2489 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2490 {
2491 tree t1 = gimple_signed_type (t);
2492
2493 /* t1 == t can happen for boolean nodes which are always unsigned. */
2494 if (t1 != t)
2495 return get_alias_set (t1);
2496 }
2497
2498 return -1;
2499}
2500
2501
2502/* Helper for gimple_ior_addresses_taken_1. */
2503
2504static bool
2505gimple_ior_addresses_taken_1 (gimple *, tree addr, tree, void *data)
2506{
2507 bitmap addresses_taken = (bitmap)data;
2508 addr = get_base_address (addr);
2509 if (addr
2510 && DECL_P (addr))
2511 {
2512 bitmap_set_bit (addresses_taken, DECL_UID (addr));
2513 return true;
2514 }
2515 return false;
2516}
2517
2518/* Set the bit for the uid of all decls that have their address taken
2519 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2520 were any in this stmt. */
2521
2522bool
2523gimple_ior_addresses_taken (bitmap addresses_taken, gimple *stmt)
2524{
2525 return walk_stmt_load_store_addr_ops (stmt, addresses_taken, NULL, NULL,
2526 gimple_ior_addresses_taken_1);
2527}
2528
2529
2530/* Return true when STMTs arguments and return value match those of FNDECL,
2531 a decl of a builtin function. */
2532
2533bool
2534gimple_builtin_call_types_compatible_p (const gimple *stmt, tree fndecl)
2535{
2536 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN);
2537
2538 tree ret = gimple_call_lhs (stmt);
2539 if (ret
2540 && !useless_type_conversion_p (TREE_TYPE (ret),
2541 TREE_TYPE (TREE_TYPE (fndecl))))
2542 return false;
2543
2544 tree targs = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2545 unsigned nargs = gimple_call_num_args (stmt);
2546 for (unsigned i = 0; i < nargs; ++i)
2547 {
2548 /* Variadic args follow. */
2549 if (!targs)
2550 return true;
2551 tree arg = gimple_call_arg (stmt, i);
2552 tree type = TREE_VALUE (targs);
2553 if (!useless_type_conversion_p (type, TREE_TYPE (arg))
2554 /* char/short integral arguments are promoted to int
2555 by several frontends if targetm.calls.promote_prototypes
2556 is true. Allow such promotion too. */
2557 && !(INTEGRAL_TYPE_P (type)
2558 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
2559 && targetm.calls.promote_prototypes (TREE_TYPE (fndecl))
2560 && useless_type_conversion_p (integer_type_node,
2561 TREE_TYPE (arg))))
2562 return false;
2563 targs = TREE_CHAIN (targs);
2564 }
2565 if (targs && !VOID_TYPE_P (TREE_VALUE (targs)))
2566 return false;
2567 return true;
2568}
2569
2570/* Return true when STMT is builtins call. */
2571
2572bool
2573gimple_call_builtin_p (const gimple *stmt)
2574{
2575 tree fndecl;
2576 if (is_gimple_call (stmt)
2577 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2578 && DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN)
2579 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2580 return false;
2581}
2582
2583/* Return true when STMT is builtins call to CLASS. */
2584
2585bool
2586gimple_call_builtin_p (const gimple *stmt, enum built_in_class klass)
2587{
2588 tree fndecl;
2589 if (is_gimple_call (stmt)
2590 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2591 && DECL_BUILT_IN_CLASS (fndecl) == klass)
2592 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2593 return false;
2594}
2595
2596/* Return true when STMT is builtins call to CODE of CLASS. */
2597
2598bool
2599gimple_call_builtin_p (const gimple *stmt, enum built_in_function code)
2600{
2601 tree fndecl;
2602 if (is_gimple_call (stmt)
2603 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2604 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
2605 && DECL_FUNCTION_CODE (fndecl) == code)
2606 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2607 return false;
2608}
2609
2610/* If CALL is a call to a combined_fn (i.e. an internal function or
2611 a normal built-in function), return its code, otherwise return
2612 CFN_LAST. */
2613
2614combined_fn
2615gimple_call_combined_fn (const gimple *stmt)
2616{
2617 if (const gcall *call = dyn_cast <const gcall *> (stmt))
2618 {
2619 if (gimple_call_internal_p (call))
2620 return as_combined_fn (gimple_call_internal_fn (call));
2621
2622 tree fndecl = gimple_call_fndecl (stmt);
2623 if (fndecl
2624 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
2625 && gimple_builtin_call_types_compatible_p (stmt, fndecl))
2626 return as_combined_fn (DECL_FUNCTION_CODE (fndecl));
2627 }
2628 return CFN_LAST;
2629}
2630
2631/* Return true if STMT clobbers memory. STMT is required to be a
2632 GIMPLE_ASM. */
2633
2634bool
2635gimple_asm_clobbers_memory_p (const gasm *stmt)
2636{
2637 unsigned i;
2638
2639 for (i = 0; i < gimple_asm_nclobbers (stmt); i++)
2640 {
2641 tree op = gimple_asm_clobber_op (stmt, i);
2642 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op)), "memory") == 0)
2643 return true;
2644 }
2645
2646 /* Non-empty basic ASM implicitly clobbers memory. */
2647 if (gimple_asm_input_p (stmt) && strlen (gimple_asm_string (stmt)) != 0)
2648 return true;
2649
2650 return false;
2651}
2652
2653/* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2654
2655void
2656dump_decl_set (FILE *file, bitmap set)
2657{
2658 if (set)
2659 {
2660 bitmap_iterator bi;
2661 unsigned i;
2662
2663 fprintf (file, "{ ");
2664
2665 EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi)
2666 {
2667 fprintf (file, "D.%u", i);
2668 fprintf (file, " ");
2669 }
2670
2671 fprintf (file, "}");
2672 }
2673 else
2674 fprintf (file, "NIL");
2675}
2676
2677/* Return true when CALL is a call stmt that definitely doesn't
2678 free any memory or makes it unavailable otherwise. */
2679bool
2680nonfreeing_call_p (gimple *call)
2681{
2682 if (gimple_call_builtin_p (call, BUILT_IN_NORMAL)
2683 && gimple_call_flags (call) & ECF_LEAF)
2684 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call)))
2685 {
2686 /* Just in case these become ECF_LEAF in the future. */
2687 case BUILT_IN_FREE:
2688 case BUILT_IN_TM_FREE:
2689 case BUILT_IN_REALLOC:
2690 case BUILT_IN_STACK_RESTORE:
2691 return false;
2692 default:
2693 return true;
2694 }
2695 else if (gimple_call_internal_p (call))
2696 switch (gimple_call_internal_fn (call))
2697 {
2698 case IFN_ABNORMAL_DISPATCHER:
2699 return true;
2700 case IFN_ASAN_MARK:
2701 return tree_to_uhwi (gimple_call_arg (call, 0)) == ASAN_MARK_UNPOISON;
2702 default:
2703 if (gimple_call_flags (call) & ECF_LEAF)
2704 return true;
2705 return false;
2706 }
2707
2708 tree fndecl = gimple_call_fndecl (call);
2709 if (!fndecl)
2710 return false;
2711 struct cgraph_node *n = cgraph_node::get (fndecl);
2712 if (!n)
2713 return false;
2714 enum availability availability;
2715 n = n->function_symbol (&availability);
2716 if (!n || availability <= AVAIL_INTERPOSABLE)
2717 return false;
2718 return n->nonfreeing_fn;
2719}
2720
2721/* Return true when CALL is a call stmt that definitely need not
2722 be considered to be a memory barrier. */
2723bool
2724nonbarrier_call_p (gimple *call)
2725{
2726 if (gimple_call_flags (call) & (ECF_PURE | ECF_CONST))
2727 return true;
2728 /* Should extend this to have a nonbarrier_fn flag, just as above in
2729 the nonfreeing case. */
2730 return false;
2731}
2732
2733/* Callback for walk_stmt_load_store_ops.
2734
2735 Return TRUE if OP will dereference the tree stored in DATA, FALSE
2736 otherwise.
2737
2738 This routine only makes a superficial check for a dereference. Thus
2739 it must only be used if it is safe to return a false negative. */
2740static bool
2741check_loadstore (gimple *, tree op, tree, void *data)
2742{
2743 if (TREE_CODE (op) == MEM_REF || TREE_CODE (op) == TARGET_MEM_REF)
2744 {
2745 /* Some address spaces may legitimately dereference zero. */
2746 addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (op));
2747 if (targetm.addr_space.zero_address_valid (as))
2748 return false;
2749
2750 return operand_equal_p (TREE_OPERAND (op, 0), (tree)data, 0);
2751 }
2752 return false;
2753}
2754
2755
2756/* Return true if OP can be inferred to be non-NULL after STMT executes,
2757 either by using a pointer dereference or attributes. */
2758bool
2759infer_nonnull_range (gimple *stmt, tree op)
2760{
2761 return infer_nonnull_range_by_dereference (stmt, op)
2762 || infer_nonnull_range_by_attribute (stmt, op);
2763}
2764
2765/* Return true if OP can be inferred to be non-NULL after STMT
2766 executes by using a pointer dereference. */
2767bool
2768infer_nonnull_range_by_dereference (gimple *stmt, tree op)
2769{
2770 /* We can only assume that a pointer dereference will yield
2771 non-NULL if -fdelete-null-pointer-checks is enabled. */
2772 if (!flag_delete_null_pointer_checks
2773 || !POINTER_TYPE_P (TREE_TYPE (op))
2774 || gimple_code (stmt) == GIMPLE_ASM)
2775 return false;
2776
2777 if (walk_stmt_load_store_ops (stmt, (void *)op,
2778 check_loadstore, check_loadstore))
2779 return true;
2780
2781 return false;
2782}
2783
2784/* Return true if OP can be inferred to be a non-NULL after STMT
2785 executes by using attributes. */
2786bool
2787infer_nonnull_range_by_attribute (gimple *stmt, tree op)
2788{
2789 /* We can only assume that a pointer dereference will yield
2790 non-NULL if -fdelete-null-pointer-checks is enabled. */
2791 if (!flag_delete_null_pointer_checks
2792 || !POINTER_TYPE_P (TREE_TYPE (op))
2793 || gimple_code (stmt) == GIMPLE_ASM)
2794 return false;
2795
2796 if (is_gimple_call (stmt) && !gimple_call_internal_p (stmt))
2797 {
2798 tree fntype = gimple_call_fntype (stmt);
2799 tree attrs = TYPE_ATTRIBUTES (fntype);
2800 for (; attrs; attrs = TREE_CHAIN (attrs))
2801 {
2802 attrs = lookup_attribute ("nonnull", attrs);
2803
2804 /* If "nonnull" wasn't specified, we know nothing about
2805 the argument. */
2806 if (attrs == NULL_TREE)
2807 return false;
2808
2809 /* If "nonnull" applies to all the arguments, then ARG
2810 is non-null if it's in the argument list. */
2811 if (TREE_VALUE (attrs) == NULL_TREE)
2812 {
2813 for (unsigned int i = 0; i < gimple_call_num_args (stmt); i++)
2814 {
2815 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt, i)))
2816 && operand_equal_p (op, gimple_call_arg (stmt, i), 0))
2817 return true;
2818 }
2819 return false;
2820 }
2821
2822 /* Now see if op appears in the nonnull list. */
2823 for (tree t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t))
2824 {
2825 unsigned int idx = TREE_INT_CST_LOW (TREE_VALUE (t)) - 1;
2826 if (idx < gimple_call_num_args (stmt))
2827 {
2828 tree arg = gimple_call_arg (stmt, idx);
2829 if (operand_equal_p (op, arg, 0))
2830 return true;
2831 }
2832 }
2833 }
2834 }
2835
2836 /* If this function is marked as returning non-null, then we can
2837 infer OP is non-null if it is used in the return statement. */
2838 if (greturn *return_stmt = dyn_cast <greturn *> (stmt))
2839 if (gimple_return_retval (return_stmt)
2840 && operand_equal_p (gimple_return_retval (return_stmt), op, 0)
2841 && lookup_attribute ("returns_nonnull",
2842 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
2843 return true;
2844
2845 return false;
2846}
2847
2848/* Compare two case labels. Because the front end should already have
2849 made sure that case ranges do not overlap, it is enough to only compare
2850 the CASE_LOW values of each case label. */
2851
2852static int
2853compare_case_labels (const void *p1, const void *p2)
2854{
2855 const_tree const case1 = *(const_tree const*)p1;
2856 const_tree const case2 = *(const_tree const*)p2;
2857
2858 /* The 'default' case label always goes first. */
2859 if (!CASE_LOW (case1))
2860 return -1;
2861 else if (!CASE_LOW (case2))
2862 return 1;
2863 else
2864 return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
2865}
2866
2867/* Sort the case labels in LABEL_VEC in place in ascending order. */
2868
2869void
2870sort_case_labels (vec<tree> label_vec)
2871{
2872 label_vec.qsort (compare_case_labels);
2873}
2874
2875/* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2876
2877 LABELS is a vector that contains all case labels to look at.
2878
2879 INDEX_TYPE is the type of the switch index expression. Case labels
2880 in LABELS are discarded if their values are not in the value range
2881 covered by INDEX_TYPE. The remaining case label values are folded
2882 to INDEX_TYPE.
2883
2884 If a default case exists in LABELS, it is removed from LABELS and
2885 returned in DEFAULT_CASEP. If no default case exists, but the
2886 case labels already cover the whole range of INDEX_TYPE, a default
2887 case is returned pointing to one of the existing case labels.
2888 Otherwise DEFAULT_CASEP is set to NULL_TREE.
2889
2890 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2891 apply and no action is taken regardless of whether a default case is
2892 found or not. */
2893
2894void
2895preprocess_case_label_vec_for_gimple (vec<tree> labels,
2896 tree index_type,
2897 tree *default_casep)
2898{
2899 tree min_value, max_value;
2900 tree default_case = NULL_TREE;
2901 size_t i, len;
2902
2903 i = 0;
2904 min_value = TYPE_MIN_VALUE (index_type);
2905 max_value = TYPE_MAX_VALUE (index_type);
2906 while (i < labels.length ())
2907 {
2908 tree elt = labels[i];
2909 tree low = CASE_LOW (elt);
2910 tree high = CASE_HIGH (elt);
2911 bool remove_element = FALSE;
2912
2913 if (low)
2914 {
2915 gcc_checking_assert (TREE_CODE (low) == INTEGER_CST);
2916 gcc_checking_assert (!high || TREE_CODE (high) == INTEGER_CST);
2917
2918 /* This is a non-default case label, i.e. it has a value.
2919
2920 See if the case label is reachable within the range of
2921 the index type. Remove out-of-range case values. Turn
2922 case ranges into a canonical form (high > low strictly)
2923 and convert the case label values to the index type.
2924
2925 NB: The type of gimple_switch_index() may be the promoted
2926 type, but the case labels retain the original type. */
2927
2928 if (high)
2929 {
2930 /* This is a case range. Discard empty ranges.
2931 If the bounds or the range are equal, turn this
2932 into a simple (one-value) case. */
2933 int cmp = tree_int_cst_compare (high, low);
2934 if (cmp < 0)
2935 remove_element = TRUE;
2936 else if (cmp == 0)
2937 high = NULL_TREE;
2938 }
2939
2940 if (! high)
2941 {
2942 /* If the simple case value is unreachable, ignore it. */
2943 if ((TREE_CODE (min_value) == INTEGER_CST
2944 && tree_int_cst_compare (low, min_value) < 0)
2945 || (TREE_CODE (max_value) == INTEGER_CST
2946 && tree_int_cst_compare (low, max_value) > 0))
2947 remove_element = TRUE;
2948 else
2949 low = fold_convert (index_type, low);
2950 }
2951 else
2952 {
2953 /* If the entire case range is unreachable, ignore it. */
2954 if ((TREE_CODE (min_value) == INTEGER_CST
2955 && tree_int_cst_compare (high, min_value) < 0)
2956 || (TREE_CODE (max_value) == INTEGER_CST
2957 && tree_int_cst_compare (low, max_value) > 0))
2958 remove_element = TRUE;
2959 else
2960 {
2961 /* If the lower bound is less than the index type's
2962 minimum value, truncate the range bounds. */
2963 if (TREE_CODE (min_value) == INTEGER_CST
2964 && tree_int_cst_compare (low, min_value) < 0)
2965 low = min_value;
2966 low = fold_convert (index_type, low);
2967
2968 /* If the upper bound is greater than the index type's
2969 maximum value, truncate the range bounds. */
2970 if (TREE_CODE (max_value) == INTEGER_CST
2971 && tree_int_cst_compare (high, max_value) > 0)
2972 high = max_value;
2973 high = fold_convert (index_type, high);
2974
2975 /* We may have folded a case range to a one-value case. */
2976 if (tree_int_cst_equal (low, high))
2977 high = NULL_TREE;
2978 }
2979 }
2980
2981 CASE_LOW (elt) = low;
2982 CASE_HIGH (elt) = high;
2983 }
2984 else
2985 {
2986 gcc_assert (!default_case);
2987 default_case = elt;
2988 /* The default case must be passed separately to the
2989 gimple_build_switch routine. But if DEFAULT_CASEP
2990 is NULL, we do not remove the default case (it would
2991 be completely lost). */
2992 if (default_casep)
2993 remove_element = TRUE;
2994 }
2995
2996 if (remove_element)
2997 labels.ordered_remove (i);
2998 else
2999 i++;
3000 }
3001 len = i;
3002
3003 if (!labels.is_empty ())
3004 sort_case_labels (labels);
3005
3006 if (default_casep && !default_case)
3007 {
3008 /* If the switch has no default label, add one, so that we jump
3009 around the switch body. If the labels already cover the whole
3010 range of the switch index_type, add the default label pointing
3011 to one of the existing labels. */
3012 if (len
3013 && TYPE_MIN_VALUE (index_type)
3014 && TYPE_MAX_VALUE (index_type)
3015 && tree_int_cst_equal (CASE_LOW (labels[0]),
3016 TYPE_MIN_VALUE (index_type)))
3017 {
3018 tree low, high = CASE_HIGH (labels[len - 1]);
3019 if (!high)
3020 high = CASE_LOW (labels[len - 1]);
3021 if (tree_int_cst_equal (high, TYPE_MAX_VALUE (index_type)))
3022 {
3023 tree widest_label = labels[0];
3024 for (i = 1; i < len; i++)
3025 {
3026 high = CASE_LOW (labels[i]);
3027 low = CASE_HIGH (labels[i - 1]);
3028 if (!low)
3029 low = CASE_LOW (labels[i - 1]);
3030
3031 if (CASE_HIGH (labels[i]) != NULL_TREE
3032 && (CASE_HIGH (widest_label) == NULL_TREE
3033 || (wi::gtu_p
3034 (wi::to_wide (CASE_HIGH (labels[i]))
3035 - wi::to_wide (CASE_LOW (labels[i])),
3036 wi::to_wide (CASE_HIGH (widest_label))
3037 - wi::to_wide (CASE_LOW (widest_label))))))
3038 widest_label = labels[i];
3039
3040 if (wi::to_wide (low) + 1 != wi::to_wide (high))
3041 break;
3042 }
3043 if (i == len)
3044 {
3045 /* Designate the label with the widest range to be the
3046 default label. */
3047 tree label = CASE_LABEL (widest_label);
3048 default_case = build_case_label (NULL_TREE, NULL_TREE,
3049 label);
3050 }
3051 }
3052 }
3053 }
3054
3055 if (default_casep)
3056 *default_casep = default_case;
3057}
3058
3059/* Set the location of all statements in SEQ to LOC. */
3060
3061void
3062gimple_seq_set_location (gimple_seq seq, location_t loc)
3063{
3064 for (gimple_stmt_iterator i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
3065 gimple_set_location (gsi_stmt (i), loc);
3066}
3067
3068/* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
3069
3070void
3071gimple_seq_discard (gimple_seq seq)
3072{
3073 gimple_stmt_iterator gsi;
3074
3075 for (gsi = gsi_start (seq); !gsi_end_p (gsi); )
3076 {
3077 gimple *stmt = gsi_stmt (gsi);
3078 gsi_remove (&gsi, true);
3079 release_defs (stmt);
3080 ggc_free (stmt);
3081 }
3082}
3083
3084/* See if STMT now calls function that takes no parameters and if so, drop
3085 call arguments. This is used when devirtualization machinery redirects
3086 to __builtin_unreachable or __cxa_pure_virtual. */
3087
3088void
3089maybe_remove_unused_call_args (struct function *fn, gimple *stmt)
3090{
3091 tree decl = gimple_call_fndecl (stmt);
3092 if (TYPE_ARG_TYPES (TREE_TYPE (decl))
3093 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))) == void_type_node
3094 && gimple_call_num_args (stmt))
3095 {
3096 gimple_set_num_ops (stmt, 3);
3097 update_stmt_fn (fn, stmt);
3098 }
3099}
3100
3101/* Return false if STMT will likely expand to real function call. */
3102
3103bool
3104gimple_inexpensive_call_p (gcall *stmt)
3105{
3106 if (gimple_call_internal_p (stmt))
3107 return true;
3108 tree decl = gimple_call_fndecl (stmt);
3109 if (decl && is_inexpensive_builtin (decl))
3110 return true;
3111 return false;
3112}
3113
3114#if CHECKING_P
3115
3116namespace selftest {
3117
3118/* Selftests for core gimple structures. */
3119
3120/* Verify that STMT is pretty-printed as EXPECTED.
3121 Helper function for selftests. */
3122
3123static void
3124verify_gimple_pp (const char *expected, gimple *stmt)
3125{
3126 pretty_printer pp;
3127 pp_gimple_stmt_1 (&pp, stmt, 0 /* spc */, 0 /* flags */);
3128 ASSERT_STREQ (expected, pp_formatted_text (&pp));
3129}
3130
3131/* Build a GIMPLE_ASSIGN equivalent to
3132 tmp = 5;
3133 and verify various properties of it. */
3134
3135static void
3136test_assign_single ()
3137{
3138 tree type = integer_type_node;
3139 tree lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3140 get_identifier ("tmp"),
3141 type);
3142 tree rhs = build_int_cst (type, 5);
3143 gassign *stmt = gimple_build_assign (lhs, rhs);
3144 verify_gimple_pp ("tmp = 5;", stmt);
3145
3146 ASSERT_TRUE (is_gimple_assign (stmt));
3147 ASSERT_EQ (lhs, gimple_assign_lhs (stmt));
3148 ASSERT_EQ (lhs, gimple_get_lhs (stmt));
3149 ASSERT_EQ (rhs, gimple_assign_rhs1 (stmt));
3150 ASSERT_EQ (NULL, gimple_assign_rhs2 (stmt));
3151 ASSERT_EQ (NULL, gimple_assign_rhs3 (stmt));
3152 ASSERT_TRUE (gimple_assign_single_p (stmt));
3153 ASSERT_EQ (INTEGER_CST, gimple_assign_rhs_code (stmt));
3154}
3155
3156/* Build a GIMPLE_ASSIGN equivalent to
3157 tmp = a * b;
3158 and verify various properties of it. */
3159
3160static void
3161test_assign_binop ()
3162{
3163 tree type = integer_type_node;
3164 tree lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3165 get_identifier ("tmp"),
3166 type);
3167 tree a = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3168 get_identifier ("a"),
3169 type);
3170 tree b = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3171 get_identifier ("b"),
3172 type);
3173 gassign *stmt = gimple_build_assign (lhs, MULT_EXPR, a, b);
3174 verify_gimple_pp ("tmp = a * b;", stmt);
3175
3176 ASSERT_TRUE (is_gimple_assign (stmt));
3177 ASSERT_EQ (lhs, gimple_assign_lhs (stmt));
3178 ASSERT_EQ (lhs, gimple_get_lhs (stmt));
3179 ASSERT_EQ (a, gimple_assign_rhs1 (stmt));
3180 ASSERT_EQ (b, gimple_assign_rhs2 (stmt));
3181 ASSERT_EQ (NULL, gimple_assign_rhs3 (stmt));
3182 ASSERT_FALSE (gimple_assign_single_p (stmt));
3183 ASSERT_EQ (MULT_EXPR, gimple_assign_rhs_code (stmt));
3184}
3185
3186/* Build a GIMPLE_NOP and verify various properties of it. */
3187
3188static void
3189test_nop_stmt ()
3190{
3191 gimple *stmt = gimple_build_nop ();
3192 verify_gimple_pp ("GIMPLE_NOP", stmt);
3193 ASSERT_EQ (GIMPLE_NOP, gimple_code (stmt));
3194 ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3195 ASSERT_FALSE (gimple_assign_single_p (stmt));
3196}
3197
3198/* Build a GIMPLE_RETURN equivalent to
3199 return 7;
3200 and verify various properties of it. */
3201
3202static void
3203test_return_stmt ()
3204{
3205 tree type = integer_type_node;
3206 tree val = build_int_cst (type, 7);
3207 greturn *stmt = gimple_build_return (val);
3208 verify_gimple_pp ("return 7;", stmt);
3209
3210 ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt));
3211 ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3212 ASSERT_EQ (val, gimple_return_retval (stmt));
3213 ASSERT_FALSE (gimple_assign_single_p (stmt));
3214}
3215
3216/* Build a GIMPLE_RETURN equivalent to
3217 return;
3218 and verify various properties of it. */
3219
3220static void
3221test_return_without_value ()
3222{
3223 greturn *stmt = gimple_build_return (NULL);
3224 verify_gimple_pp ("return;", stmt);
3225
3226 ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt));
3227 ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3228 ASSERT_EQ (NULL, gimple_return_retval (stmt));
3229 ASSERT_FALSE (gimple_assign_single_p (stmt));
3230}
3231
3232/* Run all of the selftests within this file. */
3233
3234void
3235gimple_c_tests ()
3236{
3237 test_assign_single ();
3238 test_assign_binop ();
3239 test_nop_stmt ();
3240 test_return_stmt ();
3241 test_return_without_value ();
3242}
3243
3244} // namespace selftest
3245
3246
3247#endif /* CHECKING_P */
3248