libgfortran/runtime/backtrace.c

   1 /* Copyright (C) 2006-2018 Free Software Foundation, Inc.
   2    Contributed by François-Xavier Coudert
   3
   4 This file is part of the GNU Fortran runtime library (libgfortran).
   5
   6 Libgfortran is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 3, or (at your option)
   9 any later version.
  10
  11 Libgfortran is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 Under Section 7 of GPL version 3, you are granted additional
  17 permissions described in the GCC Runtime Library Exception, version
  18 3.1, as published by the Free Software Foundation.
  19
  20 You should have received a copy of the GNU General Public License and
  21 a copy of the GCC Runtime Library Exception along with this program;
  22 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 <http://www.gnu.org/licenses/>.  */
  24
  25 #include "libgfortran.h"
  26
  27 #include <gthr.h>
  28
  29 #include <string.h>
  30 #include <errno.h>
  31
  32 #ifdef HAVE_UNISTD_H
  33 #include <unistd.h>
  34 #endif
  35
  36 #include "backtrace-supported.h"
  37 #include "backtrace.h"
  38
  39
  40 /* Store our own state while backtracing.  */
  41 struct mystate
  42 {
  43   int frame;
  44   bool try_simple;
  45   bool in_signal_handler;
  46 };
  47
  48
  49 /* Does a function name have "_gfortran_" or "_gfortrani_" prefix, possibly
  50    with additional underscore(s) at the beginning?  Cannot use strncmp()
  51    because we might be called from a signal handler.  */
  52
  53 static int
  54 has_gfortran_prefix (const char *s)
  55 {
  56   if (!s)
  57     return 0;
  58
  59   while (*s == '_')
  60     s++;
  61
  62   return (s[0] == 'g' && s[1] == 'f' && s[2] == 'o' && s[3] == 'r'
  63           && s[4] == 't' && s[5] == 'r' && s[6] == 'a' && s[7] == 'n'
  64           && (s[8] == '_' || (s[8] == 'i' && s[9] == '_')));
  65 }
  66
  67 static void
  68 error_callback (void *data, const char *msg, int errnum)
  69 {
  70   struct mystate *state = (struct mystate *) data;
  71   struct iovec iov[5];
  72 #define ERRHDR "\nCould not print backtrace: "
  73
  74   if (errnum < 0)
  75     {
  76       state->try_simple = true;
  77       return;
  78     }
  79   else if (errnum == 0)
  80     {
  81       iov[0].iov_base = (char*) ERRHDR;
  82       iov[0].iov_len = strlen (ERRHDR);
  83       iov[1].iov_base = (char*) msg;
  84       iov[1].iov_len = strlen (msg);
  85       iov[2].iov_base = (char*) "\n";
  86       iov[2].iov_len = 1;
  87       estr_writev (iov, 3);
  88     }
  89   else
  90     {
  91       char errbuf[256];
  92       if (state->in_signal_handler)
  93         {
  94           iov[0].iov_base = (char*) ERRHDR;
  95           iov[0].iov_len = strlen (ERRHDR);
  96           iov[1].iov_base = (char*) msg;
  97           iov[1].iov_len = strlen (msg);
  98           iov[2].iov_base = (char*) ", errno: ";
  99           iov[2].iov_len = strlen (iov[2].iov_base);
 100           const char *p = gfc_itoa (errnum, errbuf, sizeof (errbuf));
 101           iov[3].iov_base = (char*) p;
 102           iov[3].iov_len = strlen (p);
 103           iov[4].iov_base = (char*) "\n";
 104           iov[4].iov_len = 1;
 105           estr_writev (iov, 5);
 106         }
 107       else
 108         st_printf (ERRHDR "%s: %s\n", msg,
 109                   gf_strerror (errnum, errbuf, sizeof (errbuf)));
 110     }
 111 }
 112
 113 static int
 114 simple_callback (void *data, uintptr_t pc)
 115 {
 116   struct mystate *state = (struct mystate *) data;
 117   st_printf ("#%d  0x%lx\n", state->frame, (unsigned long) pc);
 118   (state->frame)++;
 119   return 0;
 120 }
 121
 122 static int
 123 full_callback (void *data, uintptr_t pc, const char *filename,
 124                int lineno, const char *function)
 125 {
 126   struct mystate *state = (struct mystate *) data;
 127
 128   if (has_gfortran_prefix (function))
 129     return 0;
 130
 131   st_printf ("#%d  0x%lx in %s\n", state->frame,
 132              (unsigned long) pc, function == NULL ? "???" : function);
 133   if (filename || lineno != 0)
 134     st_printf ("\tat %s:%d\n", filename == NULL ? "???" : filename, lineno);
 135   (state->frame)++;
 136
 137   if (function != NULL && strcmp (function, "main") == 0)
 138     return 1;
 139
 140   return 0;
 141 }
 142
 143
 144 /* Display the backtrace.  */
 145
 146 void
 147 show_backtrace (bool in_signal_handler)
 148 {
 149   struct backtrace_state *lbstate;
 150   struct mystate state = { 0, false, in_signal_handler };
 151
 152   lbstate = backtrace_create_state (NULL, __gthread_active_p (),
 153                                     error_callback, NULL);
 154
 155   if (lbstate == NULL)
 156     return;
 157
 158   if (!BACKTRACE_SUPPORTED || (in_signal_handler && BACKTRACE_USES_MALLOC))
 159     {
 160       /* If symbolic backtrace is not supported on this target, or would
 161          require malloc() and we are in a signal handler, go with a
 162          simple backtrace.  */
 163
 164       backtrace_simple (lbstate, 0, simple_callback, error_callback, &state);
 165     }
 166   else
 167     {
 168       /* libbacktrace uses mmap, which is safe to call from a signal handler
 169          (in practice, if not in theory).  Thus we can generate a symbolic
 170          backtrace, if debug symbols are available.  */
 171
 172       backtrace_full (lbstate, 0, full_callback, error_callback, &state);
 173       if (state.try_simple)
 174         backtrace_simple (lbstate, 0, simple_callback, error_callback, &state);
 175     }
 176 }
 177
 178
 179
 180 /* Function called by the front-end translating the BACKTRACE intrinsic.  */
 181
 182 extern void backtrace (void);
 183 export_proto (backtrace);
 184
 185 void
 186 backtrace (void)
 187 {
 188   show_backtrace (false);
 189 }
 190