| void test_direct (void) |
| { |
| test_direct (); /* { dg-warning "infinite recursion" } */ |
| } |
| |
| void test_guarded (int flag) |
| { |
| if (flag) |
| test_guarded (flag); /* { dg-warning "infinite recursion" } */ |
| } |
| |
| void test_flipped_guard (int flag) |
| { |
| if (flag) |
| test_guarded (!flag); /* { dg-bogus "infinite recursion" } */ |
| } |
| |
| void test_param_variant (int depth) |
| { |
| if (depth > 0) |
| test_param_variant (depth - 1); /* { dg-bogus "infinite recursion" } */ |
| } |
| |
| void test_unguarded_param_variant (int depth) |
| { |
| /* We fail to report this: we see that depth is being decremented, |
| but don't notice that every path through the function is |
| recursing. */ |
| test_unguarded_param_variant (depth - 1); /* { dg-warning "infinite recursion" "TODO" { xfail *-*-* } } */ |
| } |
| |
| int g; |
| |
| void test_global_variant () |
| { |
| if (g-- > 0) |
| test_global_variant (); /* { dg-bogus "infinite recursion" } */ |
| } |
| |
| /* 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); /* { dg-bogus "infinite recursion" } */ |
| 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); /* { dg-bogus "infinite recursion" } */ |
| 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) |
| { |
| /* We catch this; the "n--" means we recurse with the |
| same value for the 2nd param. */ |
| if (flag) /* { dg-message "when 'flag != 0'" } */ |
| test_partially_guarded_postdecrement (flag, n--); /* { dg-warning "infinite recursion" } */ |
| } |
| |
| 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 *-*-* } } */ |
| } |