Daily bump.
[official-gcc.git] / libgfortran / runtime / backtrace.c
blobb8246889fdeb85d04e88d90b7808bbebff276414
1 /* Copyright (C) 2006-2018 Free Software Foundation, Inc.
2 Contributed by François-Xavier Coudert
4 This file is part of the GNU Fortran runtime library (libgfortran).
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.
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.
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.
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/>. */
25 #include "libgfortran.h"
27 #include <gthr.h>
29 #include <string.h>
30 #include <errno.h>
32 #ifdef HAVE_UNISTD_H
33 #include <unistd.h>
34 #endif
36 #include "backtrace-supported.h"
37 #include "backtrace.h"
40 /* Store our own state while backtracing. */
41 struct mystate
43 int frame;
44 bool try_simple;
45 bool in_signal_handler;
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. */
53 static int
54 has_gfortran_prefix (const char *s)
56 if (!s)
57 return 0;
59 while (*s == '_')
60 s++;
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] == '_')));
67 static void
68 error_callback (void *data, const char *msg, int errnum)
70 struct mystate *state = (struct mystate *) data;
71 #define ERRHDR "\nCould not print backtrace: "
73 if (errnum < 0)
75 state->try_simple = true;
76 return;
78 else if (errnum == 0)
80 estr_write (ERRHDR);
81 estr_write (msg);
82 estr_write ("\n");
84 else
86 char errbuf[256];
87 if (state->in_signal_handler)
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");
96 else
97 st_printf (ERRHDR "%s: %s\n", msg,
98 gf_strerror (errnum, errbuf, sizeof (errbuf)));
102 static int
103 simple_callback (void *data, uintptr_t pc)
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;
111 static int
112 full_callback (void *data, uintptr_t pc, const char *filename,
113 int lineno, const char *function)
115 struct mystate *state = (struct mystate *) data;
117 if (has_gfortran_prefix (function))
118 return 0;
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)++;
126 if (function != NULL && strcmp (function, "main") == 0)
127 return 1;
129 return 0;
133 /* Display the backtrace. */
135 void
136 show_backtrace (bool in_signal_handler)
138 struct backtrace_state *lbstate;
139 struct mystate state = { 0, false, in_signal_handler };
141 lbstate = backtrace_create_state (NULL, __gthread_active_p (),
142 error_callback, NULL);
144 if (lbstate == NULL)
145 return;
147 if (!BACKTRACE_SUPPORTED || (in_signal_handler && BACKTRACE_USES_MALLOC))
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. */
153 backtrace_simple (lbstate, 0, simple_callback, error_callback, &state);
155 else
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. */
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);
169 /* Function called by the front-end translating the BACKTRACE intrinsic. */
171 extern void backtrace (void);
172 export_proto (backtrace);
174 void
175 backtrace (void)
177 show_backtrace (false);