OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgfortran/] [runtime/] [compile_options.c] - Blame information for rev 867

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 733 jeremybenn
/* Handling of compile-time options that influence the library.
2
   Copyright (C) 2005, 2007, 2009, 2010, 2011, 2012
3
   Free Software Foundation, Inc.
4
 
5
This file is part of the GNU Fortran runtime library (libgfortran).
6
 
7
Libgfortran is free software; you can redistribute it and/or modify
8
it under the terms of the GNU General Public License as published by
9
the Free Software Foundation; either version 3, or (at your option)
10
any later version.
11
 
12
Libgfortran is distributed in the hope that it will be useful,
13
but WITHOUT ANY WARRANTY; without even the implied warranty of
14
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
GNU General Public License for more details.
16
 
17
Under Section 7 of GPL version 3, you are granted additional
18
permissions described in the GCC Runtime Library Exception, version
19
3.1, as published by the Free Software Foundation.
20
 
21
You should have received a copy of the GNU General Public License and
22
a copy of the GCC Runtime Library Exception along with this program;
23
see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
24
<http://www.gnu.org/licenses/>.  */
25
 
26
#include "libgfortran.h"
27
#include <signal.h>
28
 
29
 
30
/* Useful compile-time options will be stored in here.  */
31
compile_options_t compile_options;
32
 
33
 
34
volatile sig_atomic_t fatal_error_in_progress = 0;
35
 
36
 
37
/* Helper function for backtrace_handler to write information about the
38
   received signal to stderr before actually giving the backtrace.  */
39
static void
40
show_signal (int signum)
41
{
42
  const char * name = NULL, * desc = NULL;
43
 
44
  switch (signum)
45
    {
46
#if defined(SIGQUIT)
47
      case SIGQUIT:
48
        name = "SIGQUIT";
49
        desc = "Terminal quit signal";
50
        break;
51
#endif
52
 
53
      /* The following 4 signals are defined by C89.  */
54
      case SIGILL:
55
        name = "SIGILL";
56
        desc = "Illegal instruction";
57
        break;
58
 
59
      case SIGABRT:
60
        name = "SIGABRT";
61
        desc = "Process abort signal";
62
        break;
63
 
64
      case SIGFPE:
65
        name = "SIGFPE";
66
        desc = "Floating-point exception - erroneous arithmetic operation";
67
        break;
68
 
69
      case SIGSEGV:
70
        name = "SIGSEGV";
71
        desc = "Segmentation fault - invalid memory reference";
72
        break;
73
 
74
#if defined(SIGBUS)
75
      case SIGBUS:
76
        name = "SIGBUS";
77
        desc = "Access to an undefined portion of a memory object";
78
        break;
79
#endif
80
 
81
#if defined(SIGSYS)
82
      case SIGSYS:
83
        name = "SIGSYS";
84
        desc = "Bad system call";
85
        break;
86
#endif
87
 
88
#if defined(SIGTRAP)
89
      case SIGTRAP:
90
        name = "SIGTRAP";
91
        desc = "Trace/breakpoint trap";
92
        break;
93
#endif
94
 
95
#if defined(SIGXCPU)
96
      case SIGXCPU:
97
        name = "SIGXCPU";
98
        desc = "CPU time limit exceeded";
99
        break;
100
#endif
101
 
102
#if defined(SIGXFSZ)
103
      case SIGXFSZ:
104
        name = "SIGXFSZ";
105
        desc = "File size limit exceeded";
106
        break;
107
#endif
108
    }
109
 
110
  if (name)
111
    st_printf ("\nProgram received signal %s: %s.\n", name, desc);
112
  else
113
    st_printf ("\nProgram received signal %d.\n", signum);
114
}
115
 
116
 
117
/* A signal handler to allow us to output a backtrace.  */
118
void
119
backtrace_handler (int signum)
120
{
121
  /* Since this handler is established for more than one kind of signal,
122
     it might still get invoked recursively by delivery of some other kind
123
     of signal.  Use a static variable to keep track of that. */
124
  if (fatal_error_in_progress)
125
    raise (signum);
126
  fatal_error_in_progress = 1;
127
 
128
  show_signal (signum);
129
  show_backtrace();
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
 
140
 
141
/* Helper function for set_options because we need to access the
142
   global variable options which is not seen in set_options.  */
143
static void
144
maybe_find_addr2line (void)
145
{
146
  if (options.backtrace == -1)
147
    find_addr2line ();
148
}
149
 
150
/* Set the usual compile-time options.  */
151
extern void set_options (int , int []);
152
export_proto(set_options);
153
 
154
void
155
set_options (int num, int options[])
156
{
157
  if (num >= 1)
158
    compile_options.warn_std = options[0];
159
  if (num >= 2)
160
    compile_options.allow_std = options[1];
161
  if (num >= 3)
162
    compile_options.pedantic = options[2];
163
  /* options[3] is the removed -fdump-core option. It's place in the
164
     options array is retained due to ABI compatibility. Remove when
165
     bumping the library ABI.  */
166
  if (num >= 5)
167
    compile_options.backtrace = options[4];
168
  if (num >= 6)
169
    compile_options.sign_zero = options[5];
170
  if (num >= 7)
171
    compile_options.bounds_check = options[6];
172
  if (num >= 8)
173
    compile_options.range_check = options[7];
174
 
175
  /* If backtrace is required, we set signal handlers on the POSIX
176
     2001 signals with core action.  */
177
  if (compile_options.backtrace)
178
    {
179
#if defined(SIGQUIT)
180
      signal (SIGQUIT, backtrace_handler);
181
#endif
182
 
183
      /* The following 4 signals are defined by C89.  */
184
      signal (SIGILL, backtrace_handler);
185
      signal (SIGABRT, backtrace_handler);
186
      signal (SIGFPE, backtrace_handler);
187
      signal (SIGSEGV, backtrace_handler);
188
 
189
#if defined(SIGBUS)
190
      signal (SIGBUS, backtrace_handler);
191
#endif
192
 
193
#if defined(SIGSYS)
194
      signal (SIGSYS, backtrace_handler);
195
#endif
196
 
197
#if defined(SIGTRAP)
198
      signal (SIGTRAP, backtrace_handler);
199
#endif
200
 
201
#if defined(SIGXCPU)
202
      signal (SIGXCPU, backtrace_handler);
203
#endif
204
 
205
#if defined(SIGXFSZ)
206
      signal (SIGXFSZ, backtrace_handler);
207
#endif
208
 
209
      maybe_find_addr2line ();
210
    }
211
}
212
 
213
 
214
/* Default values for the compile-time options.  Keep in sync with
215
   gcc/fortran/options.c (gfc_init_options).  */
216
void
217
init_compile_options (void)
218
{
219
  compile_options.warn_std = GFC_STD_F95_DEL | GFC_STD_LEGACY;
220
  compile_options.allow_std = GFC_STD_F95_OBS | GFC_STD_F95_DEL
221
    | GFC_STD_F2003 | GFC_STD_F2008 | GFC_STD_F95 | GFC_STD_F77
222
    | GFC_STD_F2008_OBS | GFC_STD_GNU | GFC_STD_LEGACY;
223
  compile_options.pedantic = 0;
224
  compile_options.backtrace = 0;
225
  compile_options.sign_zero = 1;
226
  compile_options.range_check = 1;
227
}
228
 
229
/* Function called by the front-end to tell us the
230
   default for unformatted data conversion.  */
231
 
232
extern void set_convert (int);
233
export_proto (set_convert);
234
 
235
void
236
set_convert (int conv)
237
{
238
  compile_options.convert = conv;
239
}
240
 
241
extern void set_record_marker (int);
242
export_proto (set_record_marker);
243
 
244
 
245
void
246
set_record_marker (int val)
247
{
248
 
249
  switch(val)
250
    {
251
    case 4:
252
      compile_options.record_marker = sizeof (GFC_INTEGER_4);
253
      break;
254
 
255
    case 8:
256
      compile_options.record_marker = sizeof (GFC_INTEGER_8);
257
      break;
258
 
259
    default:
260
      runtime_error ("Invalid value for record marker");
261
      break;
262
    }
263
}
264
 
265
extern void set_max_subrecord_length (int);
266
export_proto (set_max_subrecord_length);
267
 
268
void set_max_subrecord_length(int val)
269
{
270
  if (val > GFC_MAX_SUBRECORD_LENGTH || val < 1)
271
    {
272
      runtime_error ("Invalid value for maximum subrecord length");
273
      return;
274
    }
275
 
276
  compile_options.max_subrecord_length = val;
277
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.