Can I find how much stack memory is currently used in a Mac thread?

Question

When I try to google this, all I find is stuff about getting and setting the stack limit, such as -[NSThread stackSize], but that's NOT what I want. I want to know how much memory is in actually in use on the stack in the current thread, or equivalently how much stack space remains available.

I'm hoping to figure out a stack overflow in a crash report submitted by a user. In my previous experience, a stack overflow has usually been caused by an infinite recursion, but not this time. So I'm wondering if some of my C++ functions are really using a heck of a lot more stack space than they should.

---

A comment suggested that I get the stack pointer at the start of the thread, and compare its value later. I happened across the question Print out value of stack pointer. It has several answers:

1. (The accepted answer) Take the address of a local variable.
2. Use a little assembly language to get the value of the stack pointer register.
3. Use the function __builtin_frame_address(0) in GCC or Clang.

I tried those techniques (Apple Clang, macOS 11.2). Methods 2 and 3 produced similar results, but method 1 produced absurdly different results. For one thing, method 1 gives values that increase as you go deeper into a call chain, while the others give values that decrease. What's up with this, are there two different kinds of stacks?

Answer 1

If you are trying to do that, I guess you want to know how much memory are you using to guess the optimum number of threads you can create of some kind.

The answer is not easy, as you normally don't have access to the stack pointer. But I'll try to devise a solution for you that will not require to access the stack pointer, while it requires to use a global variable per thread.

The idea is to force a parameter to be in the stack. Even if the ABI in your system uses register to pass parameters, if you save the address of a parameter (the actual parameter variable) into some local variable, and then after that you call a function, that takes a parameter (the type doesn't matter, as you are going to use it's address to compare both):

static char *initial_stack_pseudo_addr;

size_t save_initial_stack(char dumb)
{
    /* the & operator forces dumb to be implemented in the stack */
    initial_stack_pseudo_addr = &dumb;
}

size_t how_much_stack(int dumb)
{
    return initial_stack_pseudo_addr - &dumb;
}

So when you start the thread, you call save_initial_stack(0);. When you want to know how much stack you have consumed, just can do the following:

    size_t stack_size = how_much_stack(0);
    printf("at this point I have %zi bytes of stack\n", stack_size);

Basically, what you have done is to calculate how many bytes are between the address of the local parameter of the call to save_initial_stack() to the address of the local parameter of the call you do now to get the stack size. This is approximate, but the stack changes too quick to have a precise idea.

The following example will illustrate the thing. A recursive function is called after setting the initial pointer value, then at each recursive call the current size of the stack (approximate) is computed and printed, and a new recursive call is made. The program should run until the process gets a stack overflow.

#include <stdio.h>

char *stack_at_start;

void save_stack_pointer(char dumb)
{
    stack_at_start = &dumb;
}

size_t get_stack_size(char dumb)
{
    return stack_at_start - &dumb;
}

void recursive()
{
    printf("Stack size: %zi\n", get_stack_size(0));
    recursive();
}

int main()
{
    save_stack_pointer(0);
    recursive();
}