| /* A copy of infinite-recursion-2.c, to see what inlining does to the IR |
| when we see it. |
| |
| Many cases get converted by the optimizer into iteration, and |
| into infinite loops, sometimes trivial ones. |
| |
| Right now this is a documented limitation of the warning, but perhaps |
| could be readdressed by moving the analyzer earlier. */ |
| |
| /* { dg-additional-options "-O3" } */ |
| |
| void test_direct (void) |
| { |
| test_direct (); /* Ideally would warn here, but it becomes an infinite loop. */ |
| } |
| |
| void test_guarded (int flag) |
| { |
| if (flag) |
| test_guarded (flag); /* Ideally would warn here, but it becomes an infinite loop. */ |
| } |
| |
| void test_flipped_guard (int flag) |
| { |
| if (flag) |
| test_guarded (!flag); |
| } |
| |
| void test_param_variant (int depth) |
| { |
| if (depth > 0) |
| test_param_variant (depth - 1); |
| } |
| |
| void test_unguarded_param_variant (int depth) |
| { |
| test_unguarded_param_variant (depth - 1); /* Ideally would warn here, but it becomes an infinite loop. */ |
| } |
| |
| int g; |
| |
| void test_global_variant () |
| { |
| if (g-- > 0) |
| test_global_variant (); |
| } |
| |
| /* This is a bounded recursion, as "n" is decremented before recursing... */ |
| |
| int test_while_do_predecrement_param (int n) |
| { |
| int x = 0; |
| while (n) |
| x += test_while_do_predecrement_param (--n); |
| return x; |
| } |
| |
| /* ...whereas this one is unbounded, as "n" is decremented *after* the |
| recursive call, and so is repeatedly called with the same value. */ |
| |
| int test_while_do_postdecrement_param (int n) |
| { |
| int x = 0; |
| while (n) |
| x += test_while_do_postdecrement_param (n--); /* { dg-warning "infinite recursion" } */ |
| return x; |
| } |
| /* This is a bounded recursion, as "n" is decremented before recursing... */ |
| |
| int test_do_while_predecrement_param (int n) |
| { |
| int x = 0; |
| do |
| x += test_do_while_predecrement_param (--n); |
| while (--n); |
| return x; |
| } |
| |
| /* ...whereas this one is unbounded, as "n" is decremented *after* the |
| recursive call, and so is repeatedly called with the same value. */ |
| |
| int test_do_while_postdecrement_param (int n) |
| { |
| int x = 0; |
| do |
| x += test_do_while_postdecrement_param (n--); /* { dg-warning "infinite recursion" } */ |
| while (--n); |
| return x; |
| } |
| |
| /* Various cases of decrementing "n" as the recursion proceeds where |
| not every path recurses, but we're not actually checking "n", so |
| if "flag" is true it's an infinite recursion. */ |
| |
| void test_partially_guarded_postdecrement (int flag, int n) |
| { |
| /* Ideally we'd catch this, but it becomes an infinite loop. */ |
| if (flag) |
| test_partially_guarded_postdecrement (flag, n--); |
| } |
| |
| void test_partially_guarded_predecrement (int flag, int n) |
| { |
| /* We fail to report this; we see that "n" is changing, |
| though it isn't relevant to whether we recurse. */ |
| if (flag) |
| test_partially_guarded_predecrement (flag, --n); /* { dg-warning "infinite recursion" "TODO" { xfail *-*-* } } */ |
| } |
| |
| void test_partially_guarded_subtract (int flag, int n) |
| { |
| /* We fail to report this; we see that "n" is changing, |
| though it isn't relevant to whether we recurse. */ |
| if (flag) |
| test_partially_guarded_subtract (flag, n - 1); /* { dg-warning "infinite recursion" "TODO" { xfail *-*-* } } */ |
| } |