libgfortran/runtime/compile_options.c

   1 /* Handling of compile-time options that influence the library.
   2    Copyright (C) 2005-2020 Free Software Foundation, Inc.
   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 }