title: The Impossible Happened! What does this mean?
body: <p>I have experienced an interesting runtime error. I assume it is some sort of memory leak. I wrote the following program:</p>
  
  <p><strong><code>C</code> Code:</strong></p>
  
  <pre><code>#include &lt;gmp.h&gt;
  #include &lt;stdio.h&gt;
  #include &lt;stdint.h&gt;
  #include &lt;stdlib.h&gt;
  #include &lt;string.h&gt;
  #define  PRECISION 4096
  #define  DECIMAL_POINT 1
  #define  NULL_TERMINATOR 1
  
  void     gatherSquares(const uint32_t limit, uint32_t ** const arr, uint32_t * const count);
  uint32_t inList(const uint32_t n, const uint32_t * const arr, const uint32_t count);
  void     print_help(const char * const str);
  
  int main(int argc, char* argv[]) {
    uint32_t limit  = 100; /* default */
    uint32_t digits = 100; /* default */
    uint32_t i,j,sum,bufLen,charCount,sqCount=10;
    uint32_t *squares;
    char     *buffer;
    mpf_t    irrational;
  
    if(argc &gt; 1 &amp;&amp; !strcmp(argv[1],"--help"))
      return print_help(argv[0]), EXIT_SUCCESS;
    if(argc &gt; 1)    sscanf(argv[1],"%u",&amp;limit );
    if(argc &gt; 2)    sscanf(argv[2],"%u",&amp;digits);
  
    mpf_set_default_prec(PRECISION);
    mpf_init(irrational);
  
    charCount = digits + DECIMAL_POINT;
    bufLen    = charCount + NULL_TERMINATOR;
  
    gatherSquares(limit,&amp;squares,&amp;sqCount);
    buffer  = malloc(bufLen * sizeof *buffer);
  
    for(i=sum=0; i&lt;=limit; ++i) {
      if(inList(i,squares,sqCount))
        continue;
      mpf_sqrt_ui(irrational,i);
      gmp_snprintf(buffer,bufLen,"%.*Ff",charCount,irrational);
      for(j=0; j&lt;digits+DECIMAL_POINT; ++j)
        if(buffer[j]!='.')
          sum += buffer[j]-'0';
    }
    printf("%u\n",sum);
    return EXIT_SUCCESS;
  }
  
  void gatherSquares(const uint32_t limit, uint32_t ** const arr, uint32_t * const count) {
    uint32_t i,sq,size;
    size=10;
    *arr   = malloc(size * sizeof **arr);
    for(i=0; (sq=i*i)&lt;=limit; ++i) {
      if(*count &gt; size)
        *arr = realloc(*arr, (size*=2) * sizeof **arr);
      (*arr)[i] = sq;
    }
    *arr = realloc(*arr, i * sizeof **arr);
    *count = i;
  }
  
  uint32_t inList(const uint32_t n, const uint32_t * const arr, const uint32_t count) {
    uint32_t hi,mid,low;
    hi  = count; /* exclusive upper bound */
    low = 0;     /* inclusive lower bound */
    while(low &lt; hi) {
      mid = low/2 + hi/2;
      if(arr[mid]==n)
        return 1;
      if(arr[mid] &gt;n)
        hi  = mid;
      else
        low = mid + 1;
    }
    return 0;
  }
  
  void print_help(const char * const str) {
    printf("  Usage: %s &lt;limit&gt; &lt;digits&gt;\n",str);
    printf("  Calculates the digital sum of the first &lt;digits&gt; digits \n");
    printf("  of each irrational square root &lt;= &lt;limit&gt;\n");
    printf("  * limit    : a decimal number\n");
    printf("             : default = 100\n");
    printf("  * digits   : a decimal number\n");
    printf("             : default = 100\n");
  }
  </code></pre>
  
  <p>I ran the program with the default settings <code>./a.out</code> and everything ran correctly. I then decided to try running the program with a higher search space <code>./a.out 1000</code>. This produced the following output:</p>
  
  <pre><code>user@comp:~/Current/Working/Directory ./a.out 1000 
  a.out: malloc.c:2369: sysmalloc: Assertion `(old_top == (((mbinptr) (((char *)
  &amp;((av)-&gt;bins[((1) - 1) * 2])) - __builtin_offsetof (struct malloc_chunk,fd)))) &amp;&amp;
  old_size == 0) || ((unsigned long) (old_size) &gt;= 
  (unsigned long)((((__builtin_offsetof (struct malloc_chunk, fd_nextsize))+
  ((2 * (sizeof(size_t))) - 1)) &amp; ~((2 * (sizeof(size_t))) - 1))) &amp;&amp; 
  ((old_top)-&gt;size &amp; 0x1) &amp;&amp; ((unsigned long)old_end &amp; pagemask) == 0)' failed.
  Aborted (core dumped)
  </code></pre>
  
  <p>I assumed there must be some memory leak so I fired up <code>valgrind</code> to help locate the issue. I was dumbstruck by the output:</p>
  
  <pre><code>user@comp:~/Current/Working/Directory valgrind ./a.out 1000 
  ==4032== Memcheck, a memory error detector
  ==4032== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al.
  ==4032== Using Valgrind-3.8.1 and LibVEX; rerun with -h for copyright info
  ==4032== Command: ./ans-0080 1000
  ==4032== 
  ==4032== Invalid write of size 4
  ==4032==    at 0x8048920: gatherSquares (prog.c:59)
  ==4032==    by 0x80486C4: main (prog.c:36)
  ==4032==  Address 0x427b288 is 0 bytes after a block of size 40 alloc'd
  ==4032==    at 0x402C418: malloc (in /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so)
  ==4032==    by 0x804890F: gatherSquares (prog.c:55)
  ==4032==    by 0x80486C4: main (prog.c:36)
  ==4032== 
  --4032-- VALGRIND INTERNAL ERROR: Valgrind received a signal 11 (SIGSEGV) - exiting
  --4032-- si_code=1;  Faulting address: 0x66656220;  sp: 0x625b8a80
  
  valgrind: the 'impossible' happened:
     Killed by fatal signal
  ==4032==    at 0x380DA208: ??? (in /usr/lib/valgrind/memcheck-x86-linux)
  ==4032==    by 0x380DAAB1: ??? (in /usr/lib/valgrind/memcheck-x86-linux)
  ==4032==    by 0x38054133: ??? (in /usr/lib/valgrind/memcheck-x86-linux)
  ==4032==    by 0x38054206: ??? (in /usr/lib/valgrind/memcheck-x86-linux)
  ==4032==    by 0x38052115: ??? (in /usr/lib/valgrind/memcheck-x86-linux)
  ==4032==    by 0x20657360: ???
  
  sched status:
    running_tid=1
  
  Thread 1: status = VgTs_Runnable
  ==4032==    at 0x402C63E: realloc (in /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so)
  ==4032==    by 0x8048979: gatherSquares (prog.c:61)
  ==4032==    by 0x80486C4: main (prog.c:36)
  </code></pre>
  
  <p>Note the line <code>valgrind: the 'impossible' happened:</code>! What impossible thing happened? What does this mean?</p>
  
  <hr>
  
  <p><em><strong>PS:</em></strong><br>
  <em>If you know what the program was written for, don't post references to that for search engines to index!</em></p>