Without using recursion how can a stack overflow exception be thrown?

Question

Without using recursion how can a stack overflow exception be thrown?

Answer 1

int main()
{
  //something on the stack
  int foo = 0;
  for (
    //pointer to an address on the stack
    int* p = &foo;
    //forever
    ;
    //ever lower on the stack (assuming that the stack grows downwards)
    --p)
  {
    //write to the stack
    *p = 42;
  }
}

Answer 2

The following applies to Windows, but most OSs implement this in a similar fashion.

The short answer is: if you touch the last guard page, it will throw.

An exception of type EXCEPTION_STACK_OVERFLOW (C00000FD) is raised when your application touches the bottom page of the stack, that is marked a PAGE_GUARD protection flag, and there is no room to grow the stack (commit one more page), see How to trap stack overflow in a Visual C++ application.
The typical case when this happens is when the stack has grown as the result of many function frames on the stack (ie. out of control recursion), as the result of fewer frames but very large frame sizes (functions with a very large local scoped object) or by explicitly allocating from the stack with _alloca.
Another way to cause the exception is to simply intentionally touch the guard page, eg. by dereferencing a pointer that points into that page. This can happen due to a variable initializion bug.

Stack overflows can occur on valid execution paths if the input causes a very deep nesting level. For instance see Stack overflow occurs when you run a query that contains a large number of arguments inside an IN or a NOT IN clause in SQL Server.

Answer 3

Easiest way to make a StackOverflowException is the following:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            SomeClass instance = new SomeClass();
            string name = instance.Name;
        }
    }

    public class SomeClass
    {
        public string Name
        {
            get
            {
                return Name;
            }
        }
    }
}

Answer 4

If you're talking about C++ with a reasonable standard library, I image that this would work:

while (true) {
    alloca(1024 * 1024); // arbitrary - 1M per iteration.
}

Details on alloca.

Answer 5

You can allocate a few bytes in the stack as well.

static void Main(string[] args)
{
    Span<byte> b = stackalloc byte[1024 * 1024 * 1024]; // Process is terminating due to StackOverflowException.
}

Answer 6

Since no one else has mentioned it:

throw new System.StackOverflowException();

You might do this when testing or doing fault-injection.