1 /* Copyright (C) 2006-2020 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 /* Note that libbacktrace allows the state to be accessed from 150 multiple threads, so we don't need to use a TLS variable for the 151 state here. */ 152 static struct backtrace_state *lbstate_saved; 153 struct backtrace_state *lbstate; 154 struct mystate state = { 0, false, in_signal_handler }; 155 156 lbstate = __atomic_load_n (&lbstate_saved, __ATOMIC_RELAXED); 157 if (!lbstate) 158 { 159 lbstate = backtrace_create_state (NULL, __gthread_active_p (), 160 error_callback, NULL); 161 if (lbstate) 162 __atomic_store_n (&lbstate_saved, lbstate, __ATOMIC_RELAXED); 163 else 164 return; 165 } 166 167 if (!BACKTRACE_SUPPORTED || (in_signal_handler && BACKTRACE_USES_MALLOC)) 168 { 169 /* If symbolic backtrace is not supported on this target, or would 170 require malloc() and we are in a signal handler, go with a 171 simple backtrace. */ 172 173 backtrace_simple (lbstate, 0, simple_callback, error_callback, &state); 174 } 175 else 176 { 177 /* libbacktrace uses mmap, which is safe to call from a signal handler 178 (in practice, if not in theory). Thus we can generate a symbolic 179 backtrace, if debug symbols are available. */ 180 181 backtrace_full (lbstate, 0, full_callback, error_callback, &state); 182 if (state.try_simple) 183 backtrace_simple (lbstate, 0, simple_callback, error_callback, &state); 184 } 185 } 186 187 188 189 /* Function called by the front-end translating the BACKTRACE intrinsic. */ 190 191 extern void backtrace (void); 192 export_proto (backtrace); 193 194 void 195 backtrace (void) 196 { 197 show_backtrace (false); 198 } 199 200