Avoiding stack overflow using a trampoline

Question

The trampoline function in the program below works properly. I think the program below results in stack overflow because the functions thunk_f and thunk1 call each other indefinitely, resulting in the creation of new stack frames. However, I want to write a program that behaves more similarly to a nonterminating loop, as trampolines should prevent stack overflow.

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>

void trampoline(void *(*func)()) {
  while (func) {
    void *call = func();
    func = (void *(*)())call;
  }
}

void *thunk1(int *param);
void *thunk_f(int *param);

void *thunk1(int *param)
{
  ++*param;
  trampoline(thunk_f(param));
  return NULL;
}

void *thunk_f(int *param) 
{
  return thunk1(param);
}

int main(int argc, char **argv)
{
  int a = 4;
  trampoline(thunk1(&a));
  printf("%d\n", a);
}

`thunk1` appears to call `thunk_f`, which calls `thunk1`, which calls `thunk_f`, which ... — Robert Harvey, Apr 15 '20 at 13:47
There's no legitimate use case for a non-terminating loop that I know of. Every useful instance of a loop eventually terminates. — Robert Harvey, Apr 15 '20 at 13:51
@PaulHankin The technique is well established. It’s simply misapplied here. — Konrad Rudolph, Apr 15 '20 at 13:53
https://weblambdazero.blogspot.com/2010/07/using-trampolines-in-c.html — Robert Harvey, Apr 15 '20 at 13:56
I just want to avoid producing stack frames using the trampoline function. I'm not saying nonterminating loops are useful; I just don't know of any other way to visibly see the stack frames. — , Apr 15 '20 at 13:56
@RobertHarvey I should be able to get the behaviour I want with the trampoline function I defined above. — , Apr 15 '20 at 13:59
`get the behaviour I want` what behavior do you want? What should be the output of your program? `5`? `6`? Your program just does `while(1) { a++; }` but in a recursive functions. When should the incrementing of `a` stop? — KamilCuk, Apr 15 '20 at 14:00
Two minutes isn't long enough to read that article. You really should read it. — Robert Harvey, Apr 15 '20 at 14:05

score 3 · Answer 1 · answered Apr 15 '20 at 14:13

You are using the trampoline incorrectly: rather than letting it invoke your thunk_f function, you call it with the result of the thunk_f function.

As a result, you are getting a stack overflow. You can avoid the stack overflow (but not the infinite loop) by returning thunk_f instead of calling it:

void *thunk1(int *param)
{
  ++*param;
  return thunk_f;
}

And calling trampoline in main correctly:

int main(int argc, char **argv)
{
  int a = 4;
  trampoline(thunk1, &a);
  printf("%d\n", a);
}

And of course this requires that trampoline gets an additional argument, to pass the &a parameter on:

void trampoline(void *(*func)(int *), int *arg) {
  while (func) {
    void *call = func(arg);
    func = (void *(*)())call;
  }
}

This works — but as noted, it’s just an infinite loop without output. To see what’s happening, put the printf inside thunk1:

void *thunk1(int *param)
{
  printf("%d\n", ++*param);
  return thunk_f;
}

Lastly, I should probably note that this is invalid C, because it’s illegal to convert between a object pointer and a function pointer (always compile with pedantic warnings!). To make the code legal, wrap the function pointer into an object:

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>

struct f {
    struct f (*p)(void *);
};

void trampoline(struct f f, void *args) {
    while (f.p) {
        f = (f.p)(args);
    }
}

struct f thunk1(void *param);
struct f thunk_f(void *param);

struct f thunk1(void *param) {
    printf("%d\n", ++*((int *) param));
    return (struct f) {thunk_f};
}

struct f thunk_f(void *param) {
    return thunk1(param);
}

int main() {
    int a = 4;
    trampoline((struct f) {thunk1}, &a);
}

And of course `thunk_f` could also perform continuation-passing instead of calling `thunk1` explicitly, by replacing the body with `return (struct f) {thunk1};`. — Konrad Rudolph, Apr 15 '20 at 14:22

Avoiding stack overflow using a trampoline

1 Answers1