gcc/libgfortran/runtime/backtrace.c

341 lines
7.5 KiB
C

/* Copyright (C) 2006, 2007, 2009, 2011 Free Software Foundation, Inc.
Contributed by François-Xavier Coudert
This file is part of the GNU Fortran runtime library (libgfortran).
Libgfortran is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
Libgfortran is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.
You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>. */
#include "libgfortran.h"
#include <string.h>
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_INTTYPES_H
#include <inttypes.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_EXECINFO_H
#include <execinfo.h>
#endif
#ifdef HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif
#include <ctype.h>
/* Macros for common sets of capabilities: can we fork and exec, can
we use glibc-style backtrace functions, and can we use pipes. */
#define CAN_FORK (defined(HAVE_FORK) && defined(HAVE_EXECVP) \
&& defined(HAVE_WAIT))
#define GLIBC_BACKTRACE (defined(HAVE_BACKTRACE) \
&& defined(HAVE_BACKTRACE_SYMBOLS))
#define CAN_PIPE (CAN_FORK && defined(HAVE_PIPE) \
&& defined(HAVE_DUP2) && defined(HAVE_FDOPEN) \
&& defined(HAVE_CLOSE))
#if GLIBC_BACKTRACE && CAN_PIPE
static char *
local_strcasestr (const char *s1, const char *s2)
{
#ifdef HAVE_STRCASESTR
return strcasestr (s1, s2);
#else
const char *p = s1;
const size_t len = strlen (s2);
const char u = *s2, v = isupper((int) *s2) ? tolower((int) *s2)
: (islower((int) *s2) ? toupper((int) *s2)
: *s2);
while (1)
{
while (*p != u && *p != v && *p)
p++;
if (*p == 0)
return NULL;
if (strncasecmp (p, s2, len) == 0)
return (char *)p;
}
#endif
}
#endif
#if GLIBC_BACKTRACE
static void
dump_glibc_backtrace (int depth, char *str[])
{
int i;
for (i = 0; i < depth; i++)
{
estr_write (" + ");
estr_write (str[i]);
estr_write ("\n");
}
free (str);
}
#endif
/* show_backtrace displays the backtrace, currently obtained by means of
the glibc backtrace* functions. */
void
show_backtrace (void)
{
#if GLIBC_BACKTRACE
#define DEPTH 50
#define BUFSIZE 1024
void *trace[DEPTH];
char **str;
int depth;
depth = backtrace (trace, DEPTH);
if (depth <= 0)
return;
str = backtrace_symbols (trace, depth);
#if CAN_PIPE
#ifndef STDIN_FILENO
#define STDIN_FILENO 0
#endif
#ifndef STDOUT_FILENO
#define STDOUT_FILENO 1
#endif
#ifndef STDERR_FILENO
#define STDERR_FILENO 2
#endif
/* We attempt to extract file and line information from addr2line. */
do
{
/* Local variables. */
int f[2], pid, line, i;
FILE *output;
char addr_buf[DEPTH][GFC_XTOA_BUF_SIZE], func[BUFSIZE], file[BUFSIZE];
char *p, *end;
const char *addr[DEPTH];
/* Write the list of addresses in hexadecimal format. */
for (i = 0; i < depth; i++)
addr[i] = gfc_xtoa ((GFC_UINTEGER_LARGEST) (intptr_t) trace[i], addr_buf[i],
sizeof (addr_buf[i]));
/* Don't output an error message if something goes wrong, we'll simply
fall back to the pstack and glibc backtraces. */
if (pipe (f) != 0)
break;
if ((pid = fork ()) == -1)
break;
if (pid == 0)
{
/* Child process. */
#define NUM_FIXEDARGS 5
char *arg[DEPTH+NUM_FIXEDARGS+1];
close (f[0]);
close (STDIN_FILENO);
close (STDERR_FILENO);
if (dup2 (f[1], STDOUT_FILENO) == -1)
_exit (0);
close (f[1]);
arg[0] = (char *) "addr2line";
arg[1] = (char *) "-e";
arg[2] = full_exe_path ();
arg[3] = (char *) "-f";
arg[4] = (char *) "-s";
for (i = 0; i < depth; i++)
arg[NUM_FIXEDARGS+i] = (char *) addr[i];
arg[NUM_FIXEDARGS+depth] = NULL;
execvp (arg[0], arg);
_exit (0);
#undef NUM_FIXEDARGS
}
/* Father process. */
close (f[1]);
wait (NULL);
output = fdopen (f[0], "r");
i = -1;
if (fgets (func, sizeof(func), output))
{
estr_write ("\nBacktrace for this error:\n");
do
{
if (! fgets (file, sizeof(file), output))
goto fallback;
i++;
for (p = func; *p != '\n' && *p != '\r'; p++)
;
*p = '\0';
/* Try to recognize the internal libgfortran functions. */
if (strncasecmp (func, "*_gfortran", 10) == 0
|| strncasecmp (func, "_gfortran", 9) == 0
|| strcmp (func, "main") == 0 || strcmp (func, "_start") == 0
|| strcmp (func, "_gfortrani_backtrace_handler") == 0)
continue;
if (local_strcasestr (str[i], "libgfortran.so") != NULL
|| local_strcasestr (str[i], "libgfortran.dylib") != NULL
|| local_strcasestr (str[i], "libgfortran.a") != NULL)
continue;
/* If we only have the address, use the glibc backtrace. */
if (func[0] == '?' && func[1] == '?' && file[0] == '?'
&& file[1] == '?')
{
estr_write (" + ");
estr_write (str[i]);
estr_write ("\n");
continue;
}
/* Extract the line number. */
for (end = NULL, p = file; *p; p++)
if (*p == ':')
end = p;
if (end != NULL)
{
*end = '\0';
line = atoi (++end);
}
else
line = -1;
if (strcmp (func, "MAIN__") == 0)
estr_write (" + in the main program\n");
else
{
estr_write (" + function ");
estr_write (func);
estr_write (" (0x");
estr_write (addr[i]);
estr_write (")\n");
}
if (line <= 0 && strcmp (file, "??") == 0)
continue;
if (line <= 0)
{
estr_write (" from file ");
estr_write (file);
estr_write ("\n");
}
else
st_printf (" at line %d of file %s\n", line, file);
}
while (fgets (func, sizeof(func), output));
free (str);
return;
fallback:
estr_write ("** Something went wrong while running addr2line. **\n"
"** Falling back to a simpler backtrace scheme. **\n");
}
}
while (0);
#undef DEPTH
#undef BUFSIZE
#endif
#endif
#if CAN_FORK && defined(HAVE_GETPPID)
/* Try to call pstack. */
do
{
/* Local variables. */
int pid;
/* Don't output an error message if something goes wrong, we'll simply
fall back to the pstack and glibc backtraces. */
if ((pid = fork ()) == -1)
break;
if (pid == 0)
{
/* Child process. */
#define NUM_ARGS 2
char *arg[NUM_ARGS+1];
char buf[20];
estr_write ("\nBacktrace for this error:\n");
arg[0] = (char *) "pstack";
snprintf (buf, sizeof(buf), "%d", (int) getppid ());
arg[1] = buf;
arg[2] = NULL;
execvp (arg[0], arg);
#undef NUM_ARGS
/* pstack didn't work, so we fall back to dumping the glibc
backtrace if we can. */
#if GLIBC_BACKTRACE
dump_glibc_backtrace (depth, str);
#else
estr_write (" unable to produce a backtrace, sorry!\n");
#endif
_exit (0);
}
/* Father process. */
wait (NULL);
return;
}
while(0);
#endif
#if GLIBC_BACKTRACE
/* Fallback to the glibc backtrace. */
estr_write ("\nBacktrace for this error:\n");
dump_glibc_backtrace (depth, str);
return;
#endif
estr_write ("\nBacktrace not yet available on this platform, sorry!\n");
}