# 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:

    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:

    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:

    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.