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 #define ERRHDR "\nCould not print backtrace: "
  72
  73   if (errnum < 0)
  74     {
  75       state->try_simple = true;
  76       return;
  77     }
  78   else if (errnum == 0)
  79     {
  80       estr_write (ERRHDR);
  81       estr_write (msg);
  82       estr_write ("\n");
  83     }
  84   else
  85     {
  86       char errbuf[256];
  87       if (state->in_signal_handler)
  88         {
  89           estr_write (ERRHDR);
  90           estr_write (msg);
  91           estr_write (", errno: ");
  92           const char *p = gfc_itoa (errnum, errbuf, sizeof (errbuf));
  93           estr_write (p);
  94           estr_write ("\n");
  95         }
  96       else
  97         st_printf (ERRHDR "%s: %s\n", msg,
  98                   gf_strerror (errnum, errbuf, sizeof (errbuf)));
  99     }
 100 }
 101
 102 static int
 103 simple_callback (void *data, uintptr_t pc)
 104 {
 105   struct mystate *state = (struct mystate *) data;
 106   st_printf ("#%d  0x%lx\n", state->frame, (unsigned long) pc);
 107   (state->frame)++;
 108   return 0;
 109 }
 110
 111 static int
 112 full_callback (void *data, uintptr_t pc, const char *filename,
 113                int lineno, const char *function)
 114 {
 115   struct mystate *state = (struct mystate *) data;
 116
 117   if (has_gfortran_prefix (function))
 118     return 0;
 119
 120   st_printf ("#%d  0x%lx in %s\n", state->frame,
 121              (unsigned long) pc, function == NULL ? "???" : function);
 122   if (filename || lineno != 0)
 123     st_printf ("\tat %s:%d\n", filename == NULL ? "???" : filename, lineno);
 124   (state->frame)++;
 125
 126   if (function != NULL && strcmp (function, "main") == 0)
 127     return 1;
 128
 129   return 0;
 130 }
 131
 132
 133 /* Display the backtrace.  */
 134
 135 void
 136 show_backtrace (bool in_signal_handler)
 137 {
 138   struct backtrace_state *lbstate;
 139   struct mystate state = { 0, false, in_signal_handler };
 140
 141   lbstate = backtrace_create_state (NULL, __gthread_active_p (),
 142                                     error_callback, NULL);
 143
 144   if (lbstate == NULL)
 145     return;
 146
 147   if (!BACKTRACE_SUPPORTED || (in_signal_handler && BACKTRACE_USES_MALLOC))
 148     {
 149       /* If symbolic backtrace is not supported on this target, or would
 150          require malloc() and we are in a signal handler, go with a
 151          simple backtrace.  */
 152
 153       backtrace_simple (lbstate, 0, simple_callback, error_callback, &state);
 154     }
 155   else
 156     {
 157       /* libbacktrace uses mmap, which is safe to call from a signal handler
 158          (in practice, if not in theory).  Thus we can generate a symbolic
 159          backtrace, if debug symbols are available.  */
 160
 161       backtrace_full (lbstate, 0, full_callback, error_callback, &state);
 162       if (state.try_simple)
 163         backtrace_simple (lbstate, 0, simple_callback, error_callback, &state);
 164     }
 165 }
 166
 167
 168
 169 /* Function called by the front-end translating the BACKTRACE intrinsic.  */
 170
 171 extern void backtrace (void);
 172 export_proto (backtrace);
 173
 174 void
 175 backtrace (void)
 176 {
 177   show_backtrace (false);
 178 }
 179