Is it possible to get StackOverflowError without recursion?

Question

I have a task to get "StackOverflowError" in java without using -Xss and recursion. I really don't have ideas... Only some nonsense like generating huge java class at runtime, compile it and invoke...

Answer 1

Java stores primitive types on the stack. Objects created in local scope are allocated on the heap, with the reference to them on the stack.

You can overflow the stack without recursion by allocating too many primitive types in method scope. With normal stack size settings, you would have to allocate an excessive number of variables to overflow.

Answer 2

Here is the implementation of Eric J. idea of generating excessive number of local variables using javassist library:

class SoeNonRecursive {
    static final String generatedMethodName = "holderForVariablesMethod";

    @SneakyThrows
    Class<?> createClassWithLotsOfLocalVars(String generatedClassName, final int numberOfLocalVarsToGenerate) {
        ClassPool pool = ClassPool.getDefault();
        CtClass generatedClass = pool.makeClass(generatedClassName);
        CtMethod generatedMethod = CtNewMethod.make(getMethodBody(numberOfLocalVarsToGenerate), generatedClass);
        generatedClass.addMethod(generatedMethod);
        return generatedClass.toClass();
    }

    private String getMethodBody(final int numberOfLocalVarsToGenerate) {
        StringBuilder methodBody = new StringBuilder("public static long ")
                .append(generatedMethodName).append("() {")
                .append(System.lineSeparator());
        StringBuilder antiDeadCodeEliminationString = new StringBuilder("long result = i0");
        long i = 0;
        while (i < numberOfLocalVarsToGenerate) {
            methodBody.append("  long i").append(i)
                      .append(" = ").append(i).append(";")
                      .append(System.lineSeparator());
            antiDeadCodeEliminationString.append("+").append("i").append(i);
            i++;
        }
        antiDeadCodeEliminationString.append(";");
        methodBody.append("  ").append(antiDeadCodeEliminationString)
                  .append(System.lineSeparator())
                  .append("  return result;")
                  .append(System.lineSeparator())
                  .append("}");
        return methodBody.toString();
    }
}

and tests:

class SoeNonRecursiveTest {
    private final SoeNonRecursive soeNonRecursive = new SoeNonRecursive();
    //Should be different for every case, or once generated class become
    //"frozen" for javassist: http://www.javassist.org/tutorial/tutorial.html#read
    private String generatedClassName;

    @Test
    void stackOverflowWithoutRecursion() {
        generatedClassName = "Soe1";
        final int numberOfLocalVarsToGenerate = 6000;
        assertThrows(StackOverflowError.class, () -> soeNonRecursive
                .createClassWithLotsOfLocalVars(generatedClassName, numberOfLocalVarsToGenerate));
    }

    @SneakyThrows
    @Test
    void methodGeneratedCorrectly() {
        generatedClassName = "Soe2";
        final int numberOfLocalVarsToGenerate = 6;
        Class<?> generated = soeNonRecursive.createClassWithLotsOfLocalVars(generatedClassName, numberOfLocalVarsToGenerate);
        //Arithmetic progression
        long expected = Math.round((numberOfLocalVarsToGenerate - 1.0)/2 * numberOfLocalVarsToGenerate);
        long actual = (long) generated.getDeclaredMethod(generatedMethodName).invoke(generated);
        assertEquals(expected, actual);
    }
}