1/* Unit tests for function-handling.
2 Copyright (C) 2015-2023 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20#include "config.h"
21#include "system.h"
22#include "coretypes.h"
23#include "tm.h"
24#include "opts.h"
25#include "hash-set.h"
26#include "fixed-value.h"
27#include "alias.h"
28#include "flags.h"
29#include "symtab.h"
30#include "tree-core.h"
31#include "stor-layout.h"
32#include "tree.h"
33#include "stringpool.h"
34#include "stor-layout.h"
35#include "rtl.h"
36#include "predict.h"
37#include "vec.h"
38#include "hashtab.h"
39#include "hash-set.h"
40#include "hard-reg-set.h"
41#include "input.h"
42#include "function.h"
43#include "dominance.h"
44#include "cfg.h"
45#include "bitmap.h"
46#include "cfganal.h"
47#include "basic-block.h"
48#include "tree-ssa-alias.h"
49#include "internal-fn.h"
50#include "gimple.h"
51#include "gimple-iterator.h"
52#include "gimple-fold.h"
53#include "gimple-expr.h"
54#include "toplev.h"
55#include "print-tree.h"
56#include "tree-iterator.h"
57#include "gimplify.h"
58#include "tree-cfg.h"
59#include "basic-block.h"
60#include "alias.h"
61#include "symtab.h"
62#include "inchash.h"
63#include "tree.h"
64#include "fold-const.h"
65#include "stor-layout.h"
66#include "stmt.h"
67#include "hash-table.h"
68#include "tree-ssa-alias.h"
69#include "internal-fn.h"
70#include "gimple-expr.h"
71#include "is-a.h"
72#include "tree-pass.h"
73#include "context.h"
74#include "hash-map.h"
75#include "plugin-api.h"
76#include "ipa-ref.h"
77#include "cgraph.h"
78#include "selftest.h"
79#include "print-rtl.h"
80
81#if CHECKING_P
82
83namespace selftest {
84
85/* Helper function for selftests of function-creation. */
86
87tree
88make_fndecl (tree return_type,
89 const char *name,
90 vec <tree> &param_types,
91 bool is_variadic)
92{
93 tree fn_type;
94 if (is_variadic)
95 fn_type = build_varargs_function_type_array (return_type,
96 param_types.length (),
97 param_types.address ());
98 else
99 fn_type = build_function_type_array (return_type,
100 param_types.length (),
101 param_types.address ());
102 /* FIXME: this uses input_location: */
103 tree fndecl = build_fn_decl (name, fn_type);
104
105 return fndecl;
106}
107
108/* Verify creating a function declaration equivalent to the following
109 int test_fndecl_int_void (void);
110 C declaration. */
111
112static void
113test_fndecl_int_void ()
114{
115 auto_vec <tree> param_types;
116 const char *name = "test_fndecl_int_void";
117 tree fndecl = make_fndecl (integer_type_node,
118 name,
119 param_types);
120 ASSERT_TRUE (fndecl != NULL);
121
122 /* Verify name of decl. */
123 tree declname = DECL_NAME (fndecl);
124 ASSERT_TRUE (declname != NULL);
125 ASSERT_EQ (IDENTIFIER_NODE, TREE_CODE (declname));
126 /* We expect it to use a *copy* of the string we passed in. */
127 const char *identifier_ptr = IDENTIFIER_POINTER (declname);
128 ASSERT_NE (name, identifier_ptr);
129 ASSERT_EQ (0, strcmp ("test_fndecl_int_void", identifier_ptr));
130
131 /* Verify type of fndecl. */
132 ASSERT_EQ (FUNCTION_DECL, TREE_CODE (fndecl));
133 tree fntype = TREE_TYPE (fndecl);
134 ASSERT_EQ (FUNCTION_TYPE, TREE_CODE (fntype));
135
136 /* Verify return type. */
137 ASSERT_EQ (integer_type_node, TREE_TYPE (fntype));
138
139 /* Verify "void" args. */
140 tree argtypes = TYPE_ARG_TYPES (fntype);
141 ASSERT_EQ (TREE_LIST, TREE_CODE (argtypes));
142 ASSERT_EQ (void_type_node, TREE_VALUE (argtypes));
143 ASSERT_EQ (NULL, TREE_CHAIN (argtypes));
144}
145
146/* Verify creating a function declaration equivalent to the following
147 float test_fndecl_float_intchar (int, char);
148 C declaration. */
149
150static void
151test_fndecl_float_intchar ()
152{
153 auto_vec <tree> param_types;
154 param_types.safe_push (integer_type_node);
155 param_types.safe_push (char_type_node);
156 const char *name = "test_fndecl_float_intchar";
157 tree fndecl = make_fndecl (float_type_node,
158 name,
159 param_types);
160 ASSERT_TRUE (fndecl != NULL);
161
162 /* Verify name of decl. */
163 tree declname = DECL_NAME (fndecl);
164 ASSERT_TRUE (declname != NULL);
165 ASSERT_EQ (IDENTIFIER_NODE, TREE_CODE (declname));
166 /* We expect it to use a *copy* of the string we passed in. */
167 const char *identifier_ptr = IDENTIFIER_POINTER (declname);
168 ASSERT_NE (name, identifier_ptr);
169 ASSERT_EQ (0, strcmp (name, identifier_ptr));
170
171 /* Verify type of fndecl. */
172 ASSERT_EQ (FUNCTION_DECL, TREE_CODE (fndecl));
173 tree fntype = TREE_TYPE (fndecl);
174 ASSERT_EQ (FUNCTION_TYPE, TREE_CODE (fntype));
175
176 /* Verify return type. */
177 ASSERT_EQ (float_type_node, TREE_TYPE (fntype));
178
179 /* Verify "(int, char)" args. */
180 tree arg0 = TYPE_ARG_TYPES (fntype);
181 ASSERT_EQ (TREE_LIST, TREE_CODE (arg0));
182 ASSERT_EQ (integer_type_node, TREE_VALUE (arg0));
183 tree arg1 = TREE_CHAIN (arg0);
184 ASSERT_TRUE (arg1 != NULL);
185 ASSERT_EQ (TREE_LIST, TREE_CODE (arg1));
186 ASSERT_EQ (char_type_node, TREE_VALUE (arg1));
187 tree argterm = TREE_CHAIN (arg1);
188 ASSERT_TRUE (argterm != NULL);
189 ASSERT_EQ (TREE_LIST, TREE_CODE (argterm));
190 ASSERT_EQ (void_type_node, TREE_VALUE (argterm));
191 ASSERT_EQ (NULL, TREE_CHAIN (argterm));
192}
193
194/* The test cases using these helper functions take a trivial function:
195
196 int test_fn (void) { return 42; }
197
198 and test various conversions done to it:
199
200 - gimplification
201 - construction of the CFG
202 - conversion to SSA form
203 - expansion to RTL form
204
205 In avoid having one overlong test case, this is broken
206 up into separate test cases for each stage, with helper functions
207 to minimize code duplication.
208
209 Another approach would be to attempt to directly construct a function
210 in the appropriate representation at each stage, though presumably
211 that would exhibit different kinds of failure compared to this
212 approach. */
213
214/* Construct this function:
215 int test_fn (void) { return 42; }
216 in generic tree form. Return the fndecl. */
217
218static tree
219build_trivial_generic_function ()
220{
221 auto_vec <tree> param_types;
222 tree fndecl = make_fndecl (integer_type_node,
223 name: "test_fn",
224 param_types);
225 ASSERT_TRUE (fndecl != NULL);
226
227 /* Populate the function. */
228 tree retval = build_decl (UNKNOWN_LOCATION, RESULT_DECL,
229 NULL_TREE, integer_type_node);
230 DECL_ARTIFICIAL (retval) = 1;
231 DECL_IGNORED_P (retval) = 1;
232 DECL_RESULT (fndecl) = retval;
233
234 /* Create a BIND_EXPR, and within it, a statement list. */
235 tree stmt_list = alloc_stmt_list ();
236 tree_stmt_iterator stmt_iter = tsi_start (t: stmt_list);
237 tree block = make_node (BLOCK);
238 tree bind_expr
239 = build3 (BIND_EXPR, void_type_node, NULL, stmt_list, block);
240
241 tree modify_retval = build2 (MODIFY_EXPR,
242 integer_type_node,
243 retval,
244 build_int_cst (integer_type_node, 42));
245 tree return_stmt = build1 (RETURN_EXPR,
246 integer_type_node,
247 modify_retval);
248 tsi_link_after (&stmt_iter, return_stmt, TSI_CONTINUE_LINKING);
249
250 DECL_INITIAL (fndecl) = block;
251 BLOCK_SUPERCONTEXT (block) = fndecl;
252
253 /* how to add to function? the following appears to be how to
254 set the body of a fndecl: */
255 DECL_SAVED_TREE(fndecl) = bind_expr;
256
257 /* Ensure that locals appear in the debuginfo. */
258 BLOCK_VARS (block) = BIND_EXPR_VARS (bind_expr);
259
260 return fndecl;
261}
262
263/* Construct this function:
264 int test_fn (void) { return 42; }
265 in "high gimple" form. Return the fndecl. */
266
267static tree
268build_trivial_high_gimple_function ()
269{
270 /* Construct a trivial function, and gimplify it: */
271 tree fndecl = build_trivial_generic_function ();
272 gimplify_function_tree (fndecl);
273 return fndecl;
274}
275
276/* Build a CFG for a function in gimple form. */
277
278static void
279build_cfg (tree fndecl)
280{
281 function *fun = DECL_STRUCT_FUNCTION (fndecl);
282 ASSERT_TRUE (fun != NULL);
283 ASSERT_EQ (fndecl, fun->decl);
284
285 /* We first have to lower control flow; for our trivial test function
286 this gives us:
287 test_fn ()
288 {
289 D.56 = 42;
290 goto <D.57>;
291 <D.57>:
292 return D.56;
293 }
294 */
295 gimple_opt_pass *lower_cf_pass = make_pass_lower_cf (ctxt: g);
296 push_cfun (new_cfun: fun);
297 lower_cf_pass->execute (fun);
298 pop_cfun ();
299 delete lower_cf_pass;
300
301 /* We can now convert to CFG form; for our trivial test function this
302 gives us:
303 test_fn ()
304 {
305 <bb 2>:
306 D.56 = 42;
307 return D.56;
308 }
309 */
310 gimple_opt_pass *build_cfg_pass = make_pass_build_cfg (ctxt: g);
311 push_cfun (new_cfun: fun);
312 build_cfg_pass->execute (fun);
313 pop_cfun ();
314 delete build_cfg_pass;
315}
316
317/* Convert a gimple+CFG function to SSA form. */
318
319static void
320convert_to_ssa (tree fndecl)
321{
322 function *fun = DECL_STRUCT_FUNCTION (fndecl);
323 ASSERT_TRUE (fun != NULL);
324 ASSERT_EQ (fndecl, fun->decl);
325
326 gimple_opt_pass *build_ssa_pass = make_pass_build_ssa (ctxt: g);
327 push_cfun (new_cfun: fun);
328 build_ssa_pass->execute (fun);
329 pop_cfun ();
330 delete build_ssa_pass;
331}
332
333/* Assuming we have a simple 3-block CFG like this:
334 [ENTRY] -> [block2] -> [EXIT]
335 get the "real" basic block (block 2). */
336
337static basic_block
338get_real_block (function *fun)
339{
340 ASSERT_TRUE (fun->cfg != NULL);
341 ASSERT_EQ (3, n_basic_blocks_for_fn (fun));
342 basic_block bb2 = (*fun->cfg->x_basic_block_info)[2];
343 ASSERT_TRUE (bb2 != NULL);
344 return bb2;
345}
346
347/* Verify that we have a simple 3-block CFG: the two "fake" ones, and
348 a "real" one:
349 [ENTRY] -> [block2] -> [EXIT]. */
350
351static void
352verify_three_block_cfg (function *fun)
353{
354 ASSERT_TRUE (fun->cfg != NULL);
355 ASSERT_EQ (3, n_basic_blocks_for_fn (fun));
356 ASSERT_EQ (2, n_edges_for_fn (fun));
357
358 /* The "fake" basic blocks. */
359 basic_block entry = ENTRY_BLOCK_PTR_FOR_FN (fun);
360 ASSERT_TRUE (entry != NULL);
361 ASSERT_EQ (ENTRY_BLOCK, entry->index);
362
363 basic_block exit = EXIT_BLOCK_PTR_FOR_FN (fun);
364 ASSERT_TRUE (exit != NULL);
365 ASSERT_EQ (EXIT_BLOCK, exit->index);
366
367 /* The "real" basic block. */
368 basic_block bb2 = get_real_block (fun);
369 ASSERT_TRUE (bb2 != NULL);
370 ASSERT_EQ (2, bb2->index);
371
372 /* Verify connectivity. */
373 ASSERT_EQ (NULL, entry->preds);
374 ASSERT_EQ (1, entry->succs->length ());
375
376 edge from_entry_to_bb2 = (*entry->succs)[0];
377 ASSERT_EQ (entry, from_entry_to_bb2->src);
378 ASSERT_EQ (bb2, from_entry_to_bb2->dest);
379
380 ASSERT_EQ (1, bb2->preds->length ());
381 ASSERT_EQ (from_entry_to_bb2, (*bb2->preds)[0]);
382 ASSERT_EQ (1, bb2->succs->length ());
383
384 edge from_bb2_to_exit = (*bb2->succs)[0];
385 ASSERT_EQ (bb2, from_bb2_to_exit->src);
386 ASSERT_EQ (exit, from_bb2_to_exit->dest);
387
388 ASSERT_EQ (1, exit->preds->length ());
389 ASSERT_EQ (from_bb2_to_exit, (*exit->preds)[0]);
390 ASSERT_EQ (NULL, exit->succs);
391}
392
393/* As above, but additionally verify the gimple statements are sane. */
394
395static void
396verify_three_block_gimple_cfg (function *fun)
397{
398 verify_three_block_cfg (fun);
399
400 /* The "fake" basic blocks should be flagged as gimple, but with have no
401 statements. */
402 basic_block entry = ENTRY_BLOCK_PTR_FOR_FN (fun);
403 ASSERT_TRUE (entry != NULL);
404 ASSERT_EQ (0, entry->flags & BB_RTL);
405 ASSERT_EQ (NULL, bb_seq (entry));
406
407 basic_block exit = EXIT_BLOCK_PTR_FOR_FN (fun);
408 ASSERT_TRUE (exit != NULL);
409 ASSERT_EQ (0, entry->flags & BB_RTL);
410 ASSERT_EQ (NULL, bb_seq (exit));
411
412 /* The "real" basic block should be flagged as gimple, and have one
413 or more statements. */
414 basic_block bb2 = get_real_block (fun);
415 ASSERT_TRUE (bb2 != NULL);
416 ASSERT_EQ (0, entry->flags & BB_RTL);
417 ASSERT_TRUE (bb_seq (bb2) != NULL);
418}
419
420/* As above, but additionally verify the RTL insns are sane. */
421
422void
423verify_three_block_rtl_cfg (function *fun)
424{
425 verify_three_block_cfg (fun);
426
427 /* The "fake" basic blocks should be flagged as RTL, but with no
428 insns. */
429 basic_block entry = ENTRY_BLOCK_PTR_FOR_FN (fun);
430 ASSERT_TRUE (entry != NULL);
431 ASSERT_EQ (BB_RTL, entry->flags & BB_RTL);
432 ASSERT_EQ (NULL, BB_HEAD (entry));
433
434 basic_block exit = EXIT_BLOCK_PTR_FOR_FN (fun);
435 ASSERT_TRUE (exit != NULL);
436 ASSERT_EQ (BB_RTL, exit->flags & BB_RTL);
437 ASSERT_EQ (NULL, BB_HEAD (exit));
438
439 /* The "real" basic block should be flagged as RTL, and have one
440 or more insns. */
441 basic_block bb2 = get_real_block (fun);
442 ASSERT_TRUE (bb2 != NULL);
443 ASSERT_EQ (BB_RTL, bb2->flags & BB_RTL);
444 ASSERT_TRUE (BB_HEAD (bb2) != NULL);
445}
446
447/* Test converting our trivial function:
448 int test_fn (void) { return 42; }
449 to gimple form. */
450
451static void
452test_gimplification ()
453{
454 tree fndecl = build_trivial_generic_function ();
455
456 /* Convert to gimple: */
457 gimplify_function_tree (fndecl);
458
459 /* Verify that we got gimple out of it. */
460
461 /* The function is now in GIMPLE form but the CFG has not been
462 built yet. */
463
464 /* We should have a struct function for the decl. */
465 function *fun = DECL_STRUCT_FUNCTION (fndecl);
466 ASSERT_TRUE (fun != NULL);
467 ASSERT_EQ (fndecl, fun->decl);
468
469 /* We expect a GIMPLE_BIND, with two gimple statements within it:
470 tmp = 42;
471 return tmp; */
472
473 gimple_seq seq_fn_body = gimple_body (fndecl);
474 ASSERT_TRUE (seq_fn_body != NULL);
475 gimple *bind_stmt = gimple_seq_first_stmt (s: seq_fn_body);
476 ASSERT_EQ (GIMPLE_BIND, gimple_code (bind_stmt));
477 ASSERT_EQ (NULL, bind_stmt->next);
478
479 gimple_seq seq_bind_body = gimple_bind_body (gs: as_a <gbind *> (p: bind_stmt));
480
481 /* Verify that we have the 2 statements we expect. */
482 ASSERT_TRUE (seq_bind_body != NULL);
483 gimple *stmt1 = gimple_seq_first_stmt (s: seq_bind_body);
484 ASSERT_TRUE (stmt1 != NULL);
485 ASSERT_EQ (GIMPLE_ASSIGN, gimple_code (stmt1));
486 gimple *stmt2 = stmt1->next;
487 ASSERT_TRUE (stmt2 != NULL);
488 ASSERT_EQ (stmt1, stmt2->prev);
489 ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt2));
490}
491
492/* Test of building a CFG for a function in high gimple form. */
493
494static void
495test_building_cfg ()
496{
497 /* Construct a trivial function, and gimplify it: */
498 tree fndecl = build_trivial_high_gimple_function ();
499 function *fun = DECL_STRUCT_FUNCTION (fndecl);
500 ASSERT_TRUE (fun != NULL);
501
502 /* Build a CFG. */
503 build_cfg (fndecl);
504
505 /* The CFG-building code constructs a 4-block cfg (with
506 ENTRY and EXIT):
507 test_fn ()
508 {
509 <bb 2>:
510 D.65 = 42;
511
512 <bb 3>:
513 return D.65;
514 }
515 and then ought to merge blocks 2 and 3 in cleanup_tree_cfg.
516
517 Hence we should end up with a simple 3-block cfg, the two "fake" ones,
518 and a "real" one:
519 [ENTRY] -> [block2] -> [EXIT]
520 with code like this:
521 test_fn ()
522 {
523 <bb 2>:
524 D.56 = 42;
525 return D.56;
526 }
527 */
528 verify_three_block_gimple_cfg (fun);
529
530 /* Verify the statements within the "real" block. */
531 basic_block bb2 = get_real_block (fun);
532 gimple *stmt_a = gimple_seq_first_stmt (s: bb_seq (bb: bb2));
533 ASSERT_EQ (GIMPLE_ASSIGN, gimple_code (stmt_a));
534 gimple *stmt_b = stmt_a->next;
535 ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt_b));
536 ASSERT_EQ (NULL, stmt_b->next);
537}
538
539/* Test of conversion of gimple to SSA form. */
540
541static void
542test_conversion_to_ssa ()
543{
544 /* As above, construct a trivial function, gimplify it, and build a CFG: */
545 tree fndecl = build_trivial_high_gimple_function ();
546 function *fun = DECL_STRUCT_FUNCTION (fndecl);
547 ASSERT_TRUE (fun != NULL);
548 build_cfg (fndecl);
549
550 convert_to_ssa (fndecl);
551
552 verify_three_block_gimple_cfg (fun);
553
554 /* For out trivial test function we should now have something like
555 this:
556 test_fn ()
557 {
558 <bb 2>:
559 _1 = 42;
560 return _1;
561 }
562 */
563 basic_block bb2 = get_real_block (fun);
564 gimple *stmt_a = gimple_seq_first_stmt (s: bb_seq (bb: bb2));
565 ASSERT_EQ (GIMPLE_ASSIGN, gimple_code (stmt_a));
566
567 gimple *stmt_b = stmt_a->next;
568 ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt_b));
569 ASSERT_EQ (NULL, stmt_b->next);
570
571 greturn *return_stmt = as_a <greturn *> (p: stmt_b);
572 ASSERT_EQ (SSA_NAME, TREE_CODE (gimple_return_retval (return_stmt)));
573}
574
575/* Test range folding. We must start this here because we need cfun
576 set. */
577
578static void
579test_ranges ()
580{
581 tree fndecl = build_trivial_high_gimple_function ();
582 function *fun = DECL_STRUCT_FUNCTION (fndecl);
583 push_cfun (new_cfun: fun);
584 range_tests ();
585 range_op_tests ();
586 relation_tests ();
587
588 build_cfg (fndecl);
589 convert_to_ssa (fndecl);
590 gimple_range_tests ();
591
592 pop_cfun ();
593}
594
595/* Test of expansion from gimple-ssa to RTL. */
596
597static void
598test_expansion_to_rtl ()
599{
600 /* As above, construct a trivial function, gimplify it, build a CFG,
601 and convert to SSA: */
602 tree fndecl = build_trivial_high_gimple_function ();
603 function *fun = DECL_STRUCT_FUNCTION (fndecl);
604 ASSERT_TRUE (fun != NULL);
605 build_cfg (fndecl);
606 convert_to_ssa (fndecl);
607
608 /* We need a cgraph_node for it. */
609 cgraph_node::get_create (fndecl);
610 /* Normally, cgraph_node::expand () would call
611 init_function_start (and a bunch of other stuff),
612 and invoke the expand pass, but it also runs
613 all of the other passes. So just do the minimum
614 needed to get from gimple-SSA to RTL. */
615 rtl_opt_pass *expand_pass = make_pass_expand (ctxt: g);
616 push_cfun (new_cfun: fun);
617 init_function_start (fndecl);
618 expand_pass->execute (fun);
619 pop_cfun ();
620 delete expand_pass;
621
622 /* On x86_64, I get this:
623 (note 3 1 2 2 [bb 2] NOTE_INSN_BASIC_BLOCK)
624 (note 2 3 5 2 NOTE_INSN_FUNCTION_BEG)
625 (insn 5 2 6 2 (set (reg:SI 87 [ D.59 ])
626 (const_int 42 [0x2a])) -1 (nil))
627 (insn 6 5 10 2 (set (reg:SI 88 [ <retval> ])
628 (reg:SI 87 [ D.59 ])) -1 (nil))
629 (insn 10 6 11 2 (set (reg/i:SI 0 ax)
630 (reg:SI 88 [ <retval> ])) -1 (nil))
631 (insn 11 10 0 2 (use (reg/i:SI 0 ax)) -1 (nil)). */
632 verify_three_block_rtl_cfg (fun);
633
634 /* Verify as much of the RTL as we can whilst avoiding
635 target-specific behavior. */
636 basic_block bb2 = get_real_block (fun);
637
638 /* Expect a NOTE_INSN_BASIC_BLOCK... */
639 rtx_insn *insn = BB_HEAD (bb2);
640 ASSERT_TRUE (insn != NULL);
641 ASSERT_EQ (NOTE, insn->code);
642 ASSERT_EQ (NOTE_INSN_BASIC_BLOCK, NOTE_KIND (insn));
643 ASSERT_EQ (bb2, NOTE_BASIC_BLOCK (insn));
644
645 /* ...etc; any further checks are likely to over-specify things
646 and run us into target dependencies. */
647
648 /* Verify that print_rtl_function is sane. */
649 named_temp_file tmp_out (".rtl");
650 FILE *outfile = fopen (filename: tmp_out.get_filename (), modes: "w");
651 print_rtx_function (file: outfile, fn: fun, compact: true);
652 fclose (stream: outfile);
653
654 char *dump = read_file (SELFTEST_LOCATION, path: tmp_out.get_filename ());
655 ASSERT_STR_CONTAINS (dump, "(function \"test_fn\"\n");
656 ASSERT_STR_CONTAINS (dump, " (insn-chain\n");
657 ASSERT_STR_CONTAINS (dump, " (block 2\n");
658 ASSERT_STR_CONTAINS (dump, " (edge-from entry (flags \"FALLTHRU\"))\n");
659 ASSERT_STR_CONTAINS (dump, " (cinsn "); /* ...etc. */
660 ASSERT_STR_CONTAINS (dump, " (edge-to exit (flags \"FALLTHRU\"))\n");
661 ASSERT_STR_CONTAINS (dump, " ) ;; block 2\n");
662 ASSERT_STR_CONTAINS (dump, " ) ;; insn-chain\n");
663 ASSERT_STR_CONTAINS (dump, " (crtl\n");
664 ASSERT_STR_CONTAINS (dump, " ) ;; crtl\n");
665 ASSERT_STR_CONTAINS (dump, ") ;; function \"test_fn\"\n");
666
667 free (ptr: dump);
668 free_after_compilation (fun);
669}
670
671/* Run all of the selftests within this file. */
672
673void
674function_tests_cc_tests ()
675{
676 test_fndecl_int_void ();
677 test_fndecl_float_intchar ();
678 test_gimplification ();
679 test_building_cfg ();
680 test_conversion_to_ssa ();
681 test_ranges ();
682 test_expansion_to_rtl ();
683}
684
685} // namespace selftest
686
687#endif /* #if CHECKING_P */
688

source code of gcc/function-tests.cc