|
111
|
1 /* Handling of compile-time options that influence the library.
|
|
145
|
2 Copyright (C) 2005-2020 Free Software Foundation, Inc.
|
|
111
|
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 #include <signal.h>
|
|
|
27
|
|
|
28
|
|
|
29 /* Useful compile-time options will be stored in here. */
|
|
|
30 compile_options_t compile_options;
|
|
|
31
|
|
|
32 #ifndef LIBGFOR_MINIMAL
|
|
|
33 static volatile sig_atomic_t fatal_error_in_progress = 0;
|
|
|
34
|
|
|
35
|
|
|
36 /* Helper function for backtrace_handler to write information about the
|
|
|
37 received signal to stderr before actually giving the backtrace. */
|
|
|
38 static void
|
|
|
39 show_signal (int signum)
|
|
|
40 {
|
|
|
41 const char * name = NULL, * desc = NULL;
|
|
|
42
|
|
|
43 switch (signum)
|
|
|
44 {
|
|
|
45 #if defined(SIGQUIT)
|
|
|
46 case SIGQUIT:
|
|
|
47 name = "SIGQUIT";
|
|
|
48 desc = "Terminal quit signal";
|
|
|
49 break;
|
|
|
50 #endif
|
|
|
51
|
|
|
52 /* The following 4 signals are defined by C89. */
|
|
|
53 case SIGILL:
|
|
|
54 name = "SIGILL";
|
|
|
55 desc = "Illegal instruction";
|
|
|
56 break;
|
|
|
57
|
|
|
58 case SIGABRT:
|
|
|
59 name = "SIGABRT";
|
|
|
60 desc = "Process abort signal";
|
|
|
61 break;
|
|
|
62
|
|
|
63 case SIGFPE:
|
|
|
64 name = "SIGFPE";
|
|
|
65 desc = "Floating-point exception - erroneous arithmetic operation";
|
|
|
66 break;
|
|
|
67
|
|
|
68 case SIGSEGV:
|
|
|
69 name = "SIGSEGV";
|
|
|
70 desc = "Segmentation fault - invalid memory reference";
|
|
|
71 break;
|
|
|
72
|
|
|
73 #if defined(SIGBUS)
|
|
|
74 case SIGBUS:
|
|
|
75 name = "SIGBUS";
|
|
|
76 desc = "Access to an undefined portion of a memory object";
|
|
|
77 break;
|
|
|
78 #endif
|
|
|
79
|
|
|
80 #if defined(SIGSYS)
|
|
|
81 case SIGSYS:
|
|
|
82 name = "SIGSYS";
|
|
|
83 desc = "Bad system call";
|
|
|
84 break;
|
|
|
85 #endif
|
|
|
86
|
|
|
87 #if defined(SIGTRAP)
|
|
|
88 case SIGTRAP:
|
|
|
89 name = "SIGTRAP";
|
|
|
90 desc = "Trace/breakpoint trap";
|
|
|
91 break;
|
|
|
92 #endif
|
|
|
93
|
|
|
94 #if defined(SIGXCPU)
|
|
|
95 case SIGXCPU:
|
|
|
96 name = "SIGXCPU";
|
|
|
97 desc = "CPU time limit exceeded";
|
|
|
98 break;
|
|
|
99 #endif
|
|
|
100
|
|
|
101 #if defined(SIGXFSZ)
|
|
|
102 case SIGXFSZ:
|
|
|
103 name = "SIGXFSZ";
|
|
|
104 desc = "File size limit exceeded";
|
|
|
105 break;
|
|
|
106 #endif
|
|
|
107 }
|
|
|
108
|
|
|
109 if (name)
|
|
|
110 st_printf ("\nProgram received signal %s: %s.\n", name, desc);
|
|
|
111 else
|
|
|
112 st_printf ("\nProgram received signal %d.\n", signum);
|
|
|
113 }
|
|
|
114
|
|
|
115
|
|
|
116 /* A signal handler to allow us to output a backtrace. */
|
|
|
117 void
|
|
|
118 backtrace_handler (int signum)
|
|
|
119 {
|
|
|
120 /* Since this handler is established for more than one kind of signal,
|
|
|
121 it might still get invoked recursively by delivery of some other kind
|
|
|
122 of signal. Use a static variable to keep track of that. */
|
|
|
123 if (fatal_error_in_progress)
|
|
|
124 raise (signum);
|
|
|
125 fatal_error_in_progress = 1;
|
|
|
126
|
|
|
127 show_signal (signum);
|
|
|
128 estr_write ("\nBacktrace for this error:\n");
|
|
|
129 show_backtrace (true);
|
|
|
130
|
|
|
131 /* Now reraise the signal. We reactivate the signal's
|
|
|
132 default handling, which is to terminate the process.
|
|
|
133 We could just call exit or abort,
|
|
|
134 but reraising the signal sets the return status
|
|
|
135 from the process correctly. */
|
|
|
136 signal (signum, SIG_DFL);
|
|
|
137 raise (signum);
|
|
|
138 }
|
|
|
139 #endif
|
|
|
140
|
|
|
141 /* Set the usual compile-time options. */
|
|
|
142 extern void set_options (int , int []);
|
|
|
143 export_proto(set_options);
|
|
|
144
|
|
|
145 void
|
|
|
146 set_options (int num, int options[])
|
|
|
147 {
|
|
|
148 if (num >= 1)
|
|
|
149 compile_options.warn_std = options[0];
|
|
|
150 if (num >= 2)
|
|
|
151 compile_options.allow_std = options[1];
|
|
|
152 if (num >= 3)
|
|
|
153 compile_options.pedantic = options[2];
|
|
|
154 if (num >= 4)
|
|
|
155 compile_options.backtrace = options[3];
|
|
|
156 if (num >= 5)
|
|
|
157 compile_options.sign_zero = options[4];
|
|
|
158 if (num >= 6)
|
|
|
159 compile_options.bounds_check = options[5];
|
|
|
160 if (num >= 7)
|
|
|
161 compile_options.fpe_summary = options[6];
|
|
|
162
|
|
|
163 #ifndef LIBGFOR_MINIMAL
|
|
|
164 /* If backtrace is required, we set signal handlers on the POSIX
|
|
|
165 2001 signals with core action. */
|
|
|
166 if (compile_options.backtrace)
|
|
|
167 {
|
|
|
168 #if defined(SIGQUIT)
|
|
|
169 signal (SIGQUIT, backtrace_handler);
|
|
|
170 #endif
|
|
|
171
|
|
|
172 /* The following 4 signals are defined by C89. */
|
|
|
173 signal (SIGILL, backtrace_handler);
|
|
|
174 signal (SIGABRT, backtrace_handler);
|
|
|
175 signal (SIGFPE, backtrace_handler);
|
|
|
176 signal (SIGSEGV, backtrace_handler);
|
|
|
177
|
|
|
178 #if defined(SIGBUS)
|
|
|
179 signal (SIGBUS, backtrace_handler);
|
|
|
180 #endif
|
|
|
181
|
|
|
182 #if defined(SIGSYS)
|
|
|
183 signal (SIGSYS, backtrace_handler);
|
|
|
184 #endif
|
|
|
185
|
|
|
186 #if defined(SIGTRAP)
|
|
|
187 signal (SIGTRAP, backtrace_handler);
|
|
|
188 #endif
|
|
|
189
|
|
|
190 #if defined(SIGXCPU)
|
|
|
191 signal (SIGXCPU, backtrace_handler);
|
|
|
192 #endif
|
|
|
193
|
|
|
194 #if defined(SIGXFSZ)
|
|
|
195 signal (SIGXFSZ, backtrace_handler);
|
|
|
196 #endif
|
|
|
197 }
|
|
|
198 #endif
|
|
|
199 }
|
|
|
200
|
|
|
201
|
|
|
202 /* Default values for the compile-time options. Keep in sync with
|
|
|
203 gcc/fortran/options.c (gfc_init_options). */
|
|
|
204 void
|
|
|
205 init_compile_options (void)
|
|
|
206 {
|
|
|
207 compile_options.warn_std = GFC_STD_F95_DEL | GFC_STD_LEGACY;
|
|
|
208 compile_options.allow_std = GFC_STD_F95_OBS | GFC_STD_F95_DEL
|
|
|
209 | GFC_STD_F2003 | GFC_STD_F2008 | GFC_STD_F95 | GFC_STD_F77
|
|
|
210 | GFC_STD_F2008_OBS | GFC_STD_GNU | GFC_STD_LEGACY;
|
|
|
211 compile_options.pedantic = 0;
|
|
|
212 compile_options.backtrace = 0;
|
|
|
213 compile_options.sign_zero = 1;
|
|
|
214 compile_options.fpe_summary = 0;
|
|
|
215 }
|
|
|
216
|
|
|
217 /* Function called by the front-end to tell us the
|
|
|
218 default for unformatted data conversion. */
|
|
|
219
|
|
|
220 extern void set_convert (int);
|
|
|
221 export_proto (set_convert);
|
|
|
222
|
|
|
223 void
|
|
|
224 set_convert (int conv)
|
|
|
225 {
|
|
|
226 compile_options.convert = conv;
|
|
|
227 }
|
|
|
228
|
|
|
229 extern void set_record_marker (int);
|
|
|
230 export_proto (set_record_marker);
|
|
|
231
|
|
|
232
|
|
|
233 void
|
|
|
234 set_record_marker (int val)
|
|
|
235 {
|
|
|
236
|
|
|
237 switch(val)
|
|
|
238 {
|
|
|
239 case 4:
|
|
|
240 compile_options.record_marker = sizeof (GFC_INTEGER_4);
|
|
|
241 break;
|
|
|
242
|
|
|
243 case 8:
|
|
|
244 compile_options.record_marker = sizeof (GFC_INTEGER_8);
|
|
|
245 break;
|
|
|
246
|
|
|
247 default:
|
|
|
248 runtime_error ("Invalid value for record marker");
|
|
|
249 break;
|
|
|
250 }
|
|
|
251 }
|
|
|
252
|
|
|
253 extern void set_max_subrecord_length (int);
|
|
|
254 export_proto (set_max_subrecord_length);
|
|
|
255
|
|
|
256 void set_max_subrecord_length(int val)
|
|
|
257 {
|
|
|
258 if (val > GFC_MAX_SUBRECORD_LENGTH || val < 1)
|
|
|
259 {
|
|
|
260 runtime_error ("Invalid value for maximum subrecord length");
|
|
|
261 return;
|
|
|
262 }
|
|
|
263
|
|
|
264 compile_options.max_subrecord_length = val;
|
|
|
265 }
|
