Here's the thing, if the function was properly implemented, the recursion would eliminate to a tail call. No matter how much tail your momma has, said function should be able to calculate it.

Now, it might overflow the bounds of a machine word, in which case...

Either way, ಠ_ಠ

Edit: I made an example. Here it is on codepad: http://codepad.org/6SGGSI2d. I haven't verified that the compiler is actually eliminating the tail-call. You'll note that I gave it some dummy values: I tried to use your actual mother, but she broke the array initialization mechanics in C.

#include <stdint.h>
#include <stddef.h>
#include <stdio.h>

#define SO_MANY_FATS 6

typedef uint64_t momma[SO_MANY_FATS];

uint64_t how_fat_is_she_helper(momma a_momma,
                               size_t fat_count,
                               size_t index,
                               uint64_t so_far)
{
  if (index >= fat_count)
  {
    /* As if this branch will ever be reached. */
    return so_far;
  }
  else
  {
    return how_fat_is_she_helper(a_momma,
                                 fat_count,
                                 index + 1,
                                 so_far + a_momma[index]);
  }
}

uint64_t how_fat_is_she(momma a_momma,
                        size_t fat_count)
{
  return how_fat_is_she_helper(a_momma, fat_count, 0, 0);
}

int main(int argc, char * argv[])
{
  momma yo_momma = {1,2,3,4,5,6};

  printf("Yo momma is sooooo fat: %llu!",
    how_fat_is_she(yo_momma, SO_MANY_FATS));
  return 0;
}