Viewing file:  Winfinite-recursion-3.C (1.6 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/* PR middle-end/88232 - Please implement -Winfinite-recursion
{ dg-do compile }
{ dg-options "-Wall -Winfinite-recursion" } */
typedef __SIZE_TYPE__ size_t;
/* Might throw. */
void f ();
/* Verify a warning is issued even though a call to f() might throw,
breaking the infinite recursion. */
void warn_f_call_r (int n) // { dg-warning "-Winfinite-recursion" }
{
if (n > 7)
f ();
warn_f_call_r (n - 1); // { dg-message "recursive call" }
}
void warn_f_do_while_call_r (int n) // { dg-warning "-Winfinite-recursion" }
{
f ();
do
{
f ();
warn_f_do_while_call_r (n - 1); // { dg-message "recursive call" }
}
while (1);
}
struct X
{
X (int);
~X ();
};
/* Verify a warning even though the X ctor might throw, breaking
the recursion. Using possible throwing to suppress the warning
would make it pretty much useless in C++. */
int warn_class_with_ctor (int n) // { dg-warning "-Winfinite-recursion" }
{
X x (n);
return n + warn_class_with_ctor (n - 1);
}
int nowarn_throw (int n)
{
if (n > 7)
throw "argument too big";
return n + nowarn_throw (n - 1);
}
/* Verify call operator new doesn't suppress the warning even though
it might throw. */
extern int* eipa[];
void warn_call_new (int i) // { dg-warning "-Winfinite-recursion" }
{
eipa[i] = new int;
warn_call_new (i - 1);
}
/* Verify a recursive call to operator new. */
void* operator new[] (size_t n) // { dg-warning "-Winfinite-recursion" }
{
char *p = new char[n + sizeof (n)]; // { dg-message "recursive call" }
*(size_t*)p = n;
return p + sizeof n;
}
|
