In particular, you should do the `switch op` at https://github.com/skx/simple-vm/blob/b3917aef0bd6c4178eed0c... outside the closure, and create a different, specialised closure for each case. Otherwise the "fast interpreter" may be almost as slow as a vanilla AST walker.

The most efficient control flow is one that describes only what your algorithm needs, coupled with an optimiser that can exploit the particular flow you're describing.

Among the many things discovered by the author of https://blog.nelhage.com/post/cpython-tail-call/, Clang/LLVM was able to optimise the standard switch based interpreter loop as if it had been written with computed gotos.

    bool function_with_cleanup(void) {
        // Allocate first resource
        int* buffer1 __attribute__((__cleanup__(free))) =  malloc(sizeof(int) * 100);
        if(!buffer1) { return false; }

        // Allocate second resource
        int* buffer2 __attribute__((__cleanup__(free))) = malloc(sizeof(int) * 200);
        if(!buffer2) { return false; }

        // Open a file
        FILE* file __attribute__((__cleanup__(fclose))) = fopen("data.txt", "r");
        if (!file) { return false; }

        return true;
    }

  bool function_with_cleanup(void) {
      int *buffer1 = NULL;
      int *buffer2 = NULL;
      FILE *file = NULL;
      bool success = false;
  
      // Allocate first resource
      buffer1 = malloc(sizeof(int) * 100);
      if (buffer1) {
          // Allocate second resource
          buffer2 = malloc(sizeof(int) * 200);
          if (buffer2) {
              // Open a file
              file = fopen("data.txt", "r");
              if (file) {
                  // Do work with all resources...
                  fclose(file);
                  success = true;  // Only set to true if everything succeeded
              }
              free(buffer2);
          }
          free(buffer1);
      }
  
      return success;
  }

One-time loops with break also work if you're not doing the resource allocation in another loop:

  bool function_with_cleanup(void) {
      int *buffer1 = NULL;
      int *buffer2 = NULL;
      FILE *file = NULL;
      bool success = false;
  
      do { // One-time loop to break out of on error
          // Allocate first resource
          buffer1 = malloc(sizeof(int) * 100);
          if (!buffer1) {
              break;  // Error, jump to cleanup
          }
  
          // Allocate second resource
          buffer2 = malloc(sizeof(int) * 200);
          if (!buffer2) {
              break;  // Error, jump to cleanup
          }
  
          // Open a file
          file = fopen("data.txt", "r");
          if (!file) {
              break;  // Error, jump to cleanup
          }
  
          // Do work with all resources...
  
          success = true;  // Only set to true if everything succeeded
      } while(false);
  
      // Free resources in reverse order of acquisition
      if (file) fclose(file);
      free(buffer2);  // free() is safe on NULL pointers
      free(buffer1);
  
      return success;
  }

It can get quite hilly, which doesn't look great. It does have the advantage that each resource is explicitly only valid in a visible scope, and there's a marker at the end to denote the valid region of the resource is ending.

EDIT: you mentioned early return, this style forbids early return (at least, any early return after the first resource acquisition)

And in such case, the C compiler doesn't have a limit to write functions and better modularize their implementations.

    bool function_with_cleanup(void) {
        int *buffer1 = NULL;
        int *buffer2 = NULL;
        FILE *file = NULL;        
        // Allocate first resource
        buffer1 = malloc(sizeof(int) * 100);
        if (!buffer1) {
            return false;
        }
        
        // Allocate second resource
        buffer2 = malloc(sizeof(int) * 200);
        if (!buffer2) {
            free(buffer1);
            return false;
        }
        
        // Open a file
        file = fopen("data.txt", "r");
        if (!file) {
            free(buffer1);
            free(buffer1);
            return false;
        }
        
        // Do work with all resources...
        fclose(file);
        free(buffer1);
        free(buffer1);

        return true;
    }

    bool function_with_cleanup(void) {
        int *buffer1 = NULL;
        int *buffer2 = NULL;
        FILE *file = NULL;        
        // Allocate first resource
        buffer1 = arena_alloc(&current_arena, sizeof(int) * 100);
        if (!buffer1) {
            return false;
        }
        
        // Allocate second resource
        buffer2 = arena_alloc(&current_arena, sizeof(int) * 200);
        if (!buffer2) {
            arena_reset(&current_arena); 
            return false;
        }
        
        // Open a file
        file = fopen("data.txt", "r");
        if (!file) {
            arena_reset(&current_arena);
            return false;
        }
        
        // Do work with all resources...
        fclose(file);
        arena_reset(&current_arena);
        return true;
     }

Or if using language extensions is a thing, the various ways to do defer in C.