# V1092\. Recursive function call during the static/thread\_local variable initialization might occur\. This may lead to undefined behavior\.

The analyzer detected a suspicious code fragment where initialization of a variable with static storage duration or thread storage duration starts a chain of calls, leading to recursion\. According to the C\+\+ standard, this results in undefined behavior\.

Look at the example:

```cpp
int foo(int i)
{
  static int s = foo(2*i); // <= undefined behavior
  return i + 1;
}
```

When the 's' variable is initialized, the 'foo' function is called recursively\. In this case, the analyzer issues the V1092 warning\.

More often a chain of calls as in the example below can lead to recursion:

```cpp
int foo(int i);

int bar(int i)
{
  return foo(i);           // <= 
}

int foo(int i)
{
  static int s = bar(2*i); // <= V1092
  return i + 1;
}
```

The chain of calls that leads to recursion goes through 'foo \-\> bar \-\> foo'\.

The analyzer won't issue a warning if a chain of calls goes through the unreachable code\. Look at this example:

```cpp
int foo();

int bar()
{
  if (false)
  {
    return foo();       // <= unreachable
  }
    
  return 0;
}

int foo()
{
  static int x = bar(); // <= ok
  return x;
}
```

The chain of calls also goes through 'foo \-\> bar \-\> foo'\. However, the path from 'bar' to 'foo' is unreachable\.