0

For example, If my program segaults, instead of gcc printing to the console "Segmentation Fault" can I have it print "Ya dun goofed"?

Grant Seltzer
  • 113
  • 6
  • 1
    You'll want to look into signal handling, specifically `SIGSEGV`. – Qwerty01 Nov 17 '15 at 02:39
  • 3
    [Segmentation fault handling](https://stackoverflow.com/questions/10202941/segmentation-fault-handling). Not an exact match but close enough - contains code on how to catch a seg fault. But take note that `printf` is not async safe so don't call it in your signal handler. Use `write` instead. – kaylum Nov 17 '15 at 02:41

2 Answers2

1

Segfaults are generally caused by dereferencing a garbage pointer. Therefore, while the literal answer to what you asked is that, as kaylum said, you can catch SIGSEGV in a signal handler, the better answer is that, before you use a pointer, you should ask yourself, “How do I know that this pointer is valid and that I am staying within the bounds of my array?"

If you don’t know that, your program has a bug. If you think you do, you can turn the assumption into an assertion which, since your pointer is valid, will always pass. For example:

void fill_array( unsigned fill_this_many,
                 size_t array_size,
                 int a[array_size] )
{
  assert(a);
  assert( array_size >= fill_this_many );
  for ( unsigned i = 0; i < fill_this_many; ++i )
    a[i] = f(i);

  return;
}

You’ll now get a detailed message when you’re about to dereference a null pointer or write past the end of your array, which will contain more useful information for debugging than, "There was a segfault somewhere," and it might even save you from silent memory corruption too.

If you want to write your own message, you can define a wrapper such as:

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

void fatal_error_helper( const char* file, int line, const char* restrict message )
{
  fflush(stdout);  // Don’t cross the streams!
  fprintf( stderr, "\nError in %s, line %d: %s\n", file, line, message );
  exit(EXIT_FAILURE);
}

#define fatal_error(message) fatal_error_helper( __FILE__, __LINE__, (message) )


int main(void)
{
  int *big_array = calloc( 1073741824UL, sizeof(int) );
  if (!big_array)
    fatal_error("Not enough memory.");

  return EXIT_SUCCESS;
}

And a contrived example of how to do bounds-checking at compile time, so as to fail gracefully if your constants change:

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

#define LENGTH 14U
#define M      5U

int main(void)
{
    char message[LENGTH] = "hello, world!";

    static_assert( M < LENGTH, "Tried to capitalize more letters than the array can hold." );

    for ( unsigned i = 0; i < M; ++i )
      message[i] = toupper(message[i]);

    printf( "%s\n", message );

    return EXIT_SUCCESS;
}
Davislor
  • 14,674
  • 2
  • 34
  • 49
0
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

void segv_handler(int sig)
{
    (void)sig;
    const char *msg = "Hello signal handler!";
    size_t len = strlen(msg);
    write(STDERR_FILENO, msg, len);
    abort();
}

int main()
{
    struct sigaction act;

    act.sa_handler = segv_handler;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;

    sigaction(SIGSEGV, &act, NULL);

    int *nullint = 0;

    *nullint = 4;

    return 0;
}

EDIT: I tough code is pretty much explanation how to do it. Of course there is a lot details that needs to be taken into account when writing signal handlers.

Basic limitation is that signal handler can't access any variable/structure that isn't written to atomically because handler could be called between any two instructions in your program. That means no calls to heap memory management, buffered io like printf, etc.

More details what the code does can be found from man pages stdout, sigaction and write.

Pauli Nieminen
  • 1,100
  • 8
  • 7