|
111
|
1 /****************************************************************************
|
|
|
2 * *
|
|
|
3 * GNAT COMPILER COMPONENTS *
|
|
|
4 * *
|
|
|
5 * I N I T *
|
|
|
6 * *
|
|
|
7 * C Implementation File *
|
|
|
8 * *
|
|
145
|
9 * Copyright (C) 1992-2019, Free Software Foundation, Inc. *
|
|
111
|
10 * *
|
|
|
11 * GNAT is free software; you can redistribute it and/or modify it under *
|
|
|
12 * terms of the GNU General Public License as published by the Free Soft- *
|
|
|
13 * ware Foundation; either version 3, or (at your option) any later ver- *
|
|
|
14 * sion. GNAT is distributed in the hope that it will be useful, but WITH- *
|
|
|
15 * OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
|
|
|
16 * or FITNESS FOR A PARTICULAR PURPOSE. *
|
|
|
17 * *
|
|
|
18 * As a special exception under Section 7 of GPL version 3, you are granted *
|
|
|
19 * additional permissions described in the GCC Runtime Library Exception, *
|
|
|
20 * version 3.1, as published by the Free Software Foundation. *
|
|
|
21 * *
|
|
|
22 * You should have received a copy of the GNU General Public License and *
|
|
|
23 * a copy of the GCC Runtime Library Exception along with this program; *
|
|
|
24 * see the files COPYING3 and COPYING.RUNTIME respectively. If not, see *
|
|
|
25 * <http://www.gnu.org/licenses/>. *
|
|
|
26 * *
|
|
|
27 * GNAT was originally developed by the GNAT team at New York University. *
|
|
|
28 * Extensive contributions were provided by Ada Core Technologies Inc. *
|
|
|
29 * *
|
|
|
30 ****************************************************************************/
|
|
|
31
|
|
|
32 /* This unit contains initialization circuits that are system dependent.
|
|
|
33 A major part of the functionality involves stack overflow checking.
|
|
|
34 The GCC backend generates probe instructions to test for stack overflow.
|
|
|
35 For details on the exact approach used to generate these probes, see the
|
|
|
36 "Using and Porting GCC" manual, in particular the "Stack Checking" section
|
|
|
37 and the subsection "Specifying How Stack Checking is Done". The handlers
|
|
|
38 installed by this file are used to catch the resulting signals that come
|
|
|
39 from these probes failing (i.e. touching protected pages). */
|
|
|
40
|
|
|
41 /* This file should be kept synchronized with s-init.ads, s-init.adb and the
|
|
|
42 s-init-*.adb variants. All these files implement the required functionality
|
|
|
43 for different targets. */
|
|
|
44
|
|
|
45 /* The following include is here to meet the published VxWorks requirement
|
|
|
46 that the __vxworks header appear before any other include. */
|
|
|
47 #ifdef __vxworks
|
|
|
48 #include "vxWorks.h"
|
|
|
49 #include "version.h" /* for _WRS_VXWORKS_MAJOR */
|
|
|
50 #endif
|
|
|
51
|
|
|
52 #ifdef __ANDROID__
|
|
|
53 #undef __linux__
|
|
|
54 #endif
|
|
|
55
|
|
|
56 #ifdef IN_RTS
|
|
145
|
57
|
|
|
58 #ifdef STANDALONE
|
|
|
59 #include "runtime.h"
|
|
|
60 #else
|
|
111
|
61 #include "tconfig.h"
|
|
|
62 #include "tsystem.h"
|
|
145
|
63 #endif
|
|
|
64
|
|
111
|
65 #include <sys/stat.h>
|
|
|
66
|
|
|
67 /* We don't have libiberty, so use malloc. */
|
|
|
68 #define xmalloc(S) malloc (S)
|
|
|
69 #else
|
|
|
70 #include "config.h"
|
|
|
71 #include "system.h"
|
|
|
72 #endif
|
|
|
73
|
|
|
74 #include "adaint.h"
|
|
|
75 #include "raise.h"
|
|
|
76
|
|
|
77 #ifdef __cplusplus
|
|
|
78 extern "C" {
|
|
|
79 #endif
|
|
|
80
|
|
|
81 extern void __gnat_raise_program_error (const char *, int);
|
|
|
82
|
|
|
83 /* Addresses of exception data blocks for predefined exceptions. Tasking_Error
|
|
|
84 is not used in this unit, and the abort signal is only used on IRIX.
|
|
|
85 ??? Revisit this part since IRIX is no longer supported. */
|
|
|
86 extern struct Exception_Data constraint_error;
|
|
|
87 extern struct Exception_Data numeric_error;
|
|
|
88 extern struct Exception_Data program_error;
|
|
|
89 extern struct Exception_Data storage_error;
|
|
|
90
|
|
|
91 /* For the Cert run time we use the regular raise exception routine because
|
|
|
92 Raise_From_Signal_Handler is not available. */
|
|
|
93 #ifdef CERT
|
|
|
94 #define Raise_From_Signal_Handler \
|
|
|
95 __gnat_raise_exception
|
|
|
96 extern void Raise_From_Signal_Handler (struct Exception_Data *, const char *);
|
|
|
97 #else
|
|
|
98 #define Raise_From_Signal_Handler \
|
|
|
99 ada__exceptions__raise_from_signal_handler
|
|
|
100 extern void Raise_From_Signal_Handler (struct Exception_Data *, const char *);
|
|
|
101 #endif
|
|
|
102
|
|
|
103 /* Global values computed by the binder. Note that these variables are
|
|
|
104 declared here, not in the binder file, to avoid having unresolved
|
|
|
105 references in the shared libgnat. */
|
|
|
106 int __gl_main_priority = -1;
|
|
|
107 int __gl_main_cpu = -1;
|
|
|
108 int __gl_time_slice_val = -1;
|
|
|
109 char __gl_wc_encoding = 'n';
|
|
|
110 char __gl_locking_policy = ' ';
|
|
|
111 char __gl_queuing_policy = ' ';
|
|
|
112 char __gl_task_dispatching_policy = ' ';
|
|
|
113 char *__gl_priority_specific_dispatching = 0;
|
|
|
114 int __gl_num_specific_dispatching = 0;
|
|
|
115 char *__gl_interrupt_states = 0;
|
|
|
116 int __gl_num_interrupt_states = 0;
|
|
|
117 int __gl_unreserve_all_interrupts = 0;
|
|
|
118 int __gl_exception_tracebacks = 0;
|
|
|
119 int __gl_exception_tracebacks_symbolic = 0;
|
|
|
120 int __gl_detect_blocking = 0;
|
|
|
121 int __gl_default_stack_size = -1;
|
|
|
122 int __gl_leap_seconds_support = 0;
|
|
|
123 int __gl_canonical_streams = 0;
|
|
|
124 char *__gl_bind_env_addr = NULL;
|
|
|
125
|
|
|
126 /* This value is not used anymore, but kept for bootstrapping purpose. */
|
|
|
127 int __gl_zero_cost_exceptions = 0;
|
|
|
128
|
|
|
129 /* Indication of whether synchronous signal handler has already been
|
|
|
130 installed by a previous call to adainit. */
|
|
|
131 int __gnat_handler_installed = 0;
|
|
|
132
|
|
|
133 #ifndef IN_RTS
|
|
|
134 int __gnat_inside_elab_final_code = 0;
|
|
|
135 /* ??? This variable is obsolete since 2001-08-29 but is kept to allow
|
|
|
136 bootstrap from old GNAT versions (< 3.15). */
|
|
|
137 #endif
|
|
|
138
|
|
|
139 /* HAVE_GNAT_INIT_FLOAT must be set on every targets where a __gnat_init_float
|
|
|
140 is defined. If this is not set then a void implementation will be defined
|
|
|
141 at the end of this unit. */
|
|
|
142 #undef HAVE_GNAT_INIT_FLOAT
|
|
|
143
|
|
|
144 /******************************/
|
|
|
145 /* __gnat_get_interrupt_state */
|
|
|
146 /******************************/
|
|
|
147
|
|
|
148 char __gnat_get_interrupt_state (int);
|
|
|
149
|
|
|
150 /* This routine is called from the runtime as needed to determine the state
|
|
|
151 of an interrupt, as set by an Interrupt_State pragma appearing anywhere
|
|
|
152 in the current partition. The input argument is the interrupt number,
|
|
|
153 and the result is one of the following:
|
|
|
154
|
|
|
155 'n' this interrupt not set by any Interrupt_State pragma
|
|
|
156 'u' Interrupt_State pragma set state to User
|
|
|
157 'r' Interrupt_State pragma set state to Runtime
|
|
|
158 's' Interrupt_State pragma set state to System */
|
|
|
159
|
|
|
160 char
|
|
|
161 __gnat_get_interrupt_state (int intrup)
|
|
|
162 {
|
|
|
163 if (intrup >= __gl_num_interrupt_states)
|
|
|
164 return 'n';
|
|
|
165 else
|
|
|
166 return __gl_interrupt_states [intrup];
|
|
|
167 }
|
|
|
168
|
|
|
169 /***********************************/
|
|
|
170 /* __gnat_get_specific_dispatching */
|
|
|
171 /***********************************/
|
|
|
172
|
|
|
173 char __gnat_get_specific_dispatching (int);
|
|
|
174
|
|
|
175 /* This routine is called from the runtime as needed to determine the
|
|
|
176 priority specific dispatching policy, as set by a
|
|
|
177 Priority_Specific_Dispatching pragma appearing anywhere in the current
|
|
|
178 partition. The input argument is the priority number, and the result
|
|
|
179 is the upper case first character of the policy name, e.g. 'F' for
|
|
|
180 FIFO_Within_Priorities. A space ' ' is returned if no
|
|
|
181 Priority_Specific_Dispatching pragma is used in the partition. */
|
|
|
182
|
|
|
183 char
|
|
|
184 __gnat_get_specific_dispatching (int priority)
|
|
|
185 {
|
|
|
186 if (__gl_num_specific_dispatching == 0)
|
|
|
187 return ' ';
|
|
|
188 else if (priority >= __gl_num_specific_dispatching)
|
|
|
189 return 'F';
|
|
|
190 else
|
|
|
191 return __gl_priority_specific_dispatching [priority];
|
|
|
192 }
|
|
|
193
|
|
|
194 #ifndef IN_RTS
|
|
|
195
|
|
|
196 /**********************/
|
|
|
197 /* __gnat_set_globals */
|
|
|
198 /**********************/
|
|
|
199
|
|
|
200 /* This routine is kept for bootstrapping purposes, since the binder generated
|
|
|
201 file now sets the __gl_* variables directly. */
|
|
|
202
|
|
|
203 void
|
|
|
204 __gnat_set_globals (void)
|
|
|
205 {
|
|
|
206 }
|
|
|
207
|
|
|
208 #endif
|
|
|
209
|
|
|
210 /***************/
|
|
|
211 /* AIX Section */
|
|
|
212 /***************/
|
|
|
213
|
|
|
214 #if defined (_AIX)
|
|
|
215
|
|
|
216 #include <signal.h>
|
|
|
217 #include <sys/time.h>
|
|
|
218
|
|
|
219 /* Some versions of AIX don't define SA_NODEFER. */
|
|
|
220
|
|
|
221 #ifndef SA_NODEFER
|
|
|
222 #define SA_NODEFER 0
|
|
|
223 #endif /* SA_NODEFER */
|
|
|
224
|
|
|
225 /* Versions of AIX before 4.3 don't have nanosleep but provide
|
|
|
226 nsleep instead. */
|
|
|
227
|
|
|
228 #ifndef _AIXVERSION_430
|
|
|
229
|
|
|
230 extern int nanosleep (struct timestruc_t *, struct timestruc_t *);
|
|
|
231
|
|
|
232 int
|
|
|
233 nanosleep (struct timestruc_t *Rqtp, struct timestruc_t *Rmtp)
|
|
|
234 {
|
|
|
235 return nsleep (Rqtp, Rmtp);
|
|
|
236 }
|
|
|
237
|
|
|
238 #endif /* _AIXVERSION_430 */
|
|
|
239
|
|
|
240 static void
|
|
|
241 __gnat_error_handler (int sig,
|
|
|
242 siginfo_t *si ATTRIBUTE_UNUSED,
|
|
|
243 void *ucontext ATTRIBUTE_UNUSED)
|
|
|
244 {
|
|
|
245 struct Exception_Data *exception;
|
|
|
246 const char *msg;
|
|
|
247
|
|
|
248 switch (sig)
|
|
|
249 {
|
|
|
250 case SIGSEGV:
|
|
|
251 /* FIXME: we need to detect the case of a *real* SIGSEGV. */
|
|
|
252 exception = &storage_error;
|
|
|
253 msg = "stack overflow or erroneous memory access";
|
|
|
254 break;
|
|
|
255
|
|
|
256 case SIGBUS:
|
|
|
257 exception = &constraint_error;
|
|
|
258 msg = "SIGBUS";
|
|
|
259 break;
|
|
|
260
|
|
|
261 case SIGFPE:
|
|
|
262 exception = &constraint_error;
|
|
|
263 msg = "SIGFPE";
|
|
|
264 break;
|
|
|
265
|
|
|
266 default:
|
|
|
267 exception = &program_error;
|
|
|
268 msg = "unhandled signal";
|
|
|
269 }
|
|
|
270
|
|
|
271 Raise_From_Signal_Handler (exception, msg);
|
|
|
272 }
|
|
|
273
|
|
|
274 void
|
|
|
275 __gnat_install_handler (void)
|
|
|
276 {
|
|
|
277 struct sigaction act;
|
|
|
278
|
|
|
279 /* Set up signal handler to map synchronous signals to appropriate
|
|
|
280 exceptions. Make sure that the handler isn't interrupted by another
|
|
|
281 signal that might cause a scheduling event! */
|
|
|
282
|
|
|
283 act.sa_flags = SA_NODEFER | SA_RESTART | SA_SIGINFO;
|
|
|
284 act.sa_sigaction = __gnat_error_handler;
|
|
|
285 sigemptyset (&act.sa_mask);
|
|
|
286
|
|
|
287 /* Do not install handlers if interrupt state is "System". */
|
|
|
288 if (__gnat_get_interrupt_state (SIGABRT) != 's')
|
|
|
289 sigaction (SIGABRT, &act, NULL);
|
|
|
290 if (__gnat_get_interrupt_state (SIGFPE) != 's')
|
|
|
291 sigaction (SIGFPE, &act, NULL);
|
|
|
292 if (__gnat_get_interrupt_state (SIGILL) != 's')
|
|
|
293 sigaction (SIGILL, &act, NULL);
|
|
|
294 if (__gnat_get_interrupt_state (SIGSEGV) != 's')
|
|
|
295 sigaction (SIGSEGV, &act, NULL);
|
|
|
296 if (__gnat_get_interrupt_state (SIGBUS) != 's')
|
|
|
297 sigaction (SIGBUS, &act, NULL);
|
|
|
298
|
|
|
299 __gnat_handler_installed = 1;
|
|
|
300 }
|
|
|
301
|
|
|
302 /*****************/
|
|
|
303 /* HP-UX section */
|
|
|
304 /*****************/
|
|
|
305
|
|
|
306 #elif defined (__hpux__)
|
|
|
307
|
|
|
308 #include <signal.h>
|
|
|
309 #include <sys/ucontext.h>
|
|
|
310
|
|
|
311 #if defined (IN_RTS) && defined (__ia64__)
|
|
|
312
|
|
|
313 #include <sys/uc_access.h>
|
|
|
314
|
|
|
315 #define HAVE_GNAT_ADJUST_CONTEXT_FOR_RAISE
|
|
|
316
|
|
|
317 void
|
|
|
318 __gnat_adjust_context_for_raise (int signo ATTRIBUTE_UNUSED, void *ucontext)
|
|
|
319 {
|
|
|
320 ucontext_t *uc = (ucontext_t *) ucontext;
|
|
|
321 uint64_t ip;
|
|
|
322
|
|
|
323 /* Adjust on itanium, as GetIPInfo is not supported. */
|
|
|
324 __uc_get_ip (uc, &ip);
|
|
|
325 __uc_set_ip (uc, ip + 1);
|
|
|
326 }
|
|
|
327 #endif /* IN_RTS && __ia64__ */
|
|
|
328
|
|
|
329 /* Tasking and Non-tasking signal handler. Map SIGnal to Ada exception
|
|
|
330 propagation after the required low level adjustments. */
|
|
|
331
|
|
|
332 static void
|
|
|
333 __gnat_error_handler (int sig, siginfo_t *si ATTRIBUTE_UNUSED, void *ucontext)
|
|
|
334 {
|
|
|
335 struct Exception_Data *exception;
|
|
|
336 const char *msg;
|
|
|
337
|
|
|
338 __gnat_adjust_context_for_raise (sig, ucontext);
|
|
|
339
|
|
|
340 switch (sig)
|
|
|
341 {
|
|
|
342 case SIGSEGV:
|
|
|
343 /* FIXME: we need to detect the case of a *real* SIGSEGV. */
|
|
|
344 exception = &storage_error;
|
|
|
345 msg = "stack overflow or erroneous memory access";
|
|
|
346 break;
|
|
|
347
|
|
|
348 case SIGBUS:
|
|
|
349 exception = &constraint_error;
|
|
|
350 msg = "SIGBUS";
|
|
|
351 break;
|
|
|
352
|
|
|
353 case SIGFPE:
|
|
|
354 exception = &constraint_error;
|
|
|
355 msg = "SIGFPE";
|
|
|
356 break;
|
|
|
357
|
|
|
358 default:
|
|
|
359 exception = &program_error;
|
|
|
360 msg = "unhandled signal";
|
|
|
361 }
|
|
|
362
|
|
|
363 Raise_From_Signal_Handler (exception, msg);
|
|
|
364 }
|
|
|
365
|
|
|
366 /* This must be in keeping with System.OS_Interface.Alternate_Stack_Size. */
|
|
|
367 #if defined (__hppa__)
|
|
|
368 char __gnat_alternate_stack[16 * 1024]; /* 2 * SIGSTKSZ */
|
|
|
369 #else
|
|
|
370 char __gnat_alternate_stack[128 * 1024]; /* MINSIGSTKSZ */
|
|
|
371 #endif
|
|
|
372
|
|
|
373 void
|
|
|
374 __gnat_install_handler (void)
|
|
|
375 {
|
|
|
376 struct sigaction act;
|
|
|
377
|
|
|
378 /* Set up signal handler to map synchronous signals to appropriate
|
|
|
379 exceptions. Make sure that the handler isn't interrupted by another
|
|
|
380 signal that might cause a scheduling event! Also setup an alternate
|
|
|
381 stack region for the handler execution so that stack overflows can be
|
|
|
382 handled properly, avoiding a SEGV generation from stack usage by the
|
|
|
383 handler itself. */
|
|
|
384
|
|
|
385 stack_t stack;
|
|
|
386 stack.ss_sp = __gnat_alternate_stack;
|
|
|
387 stack.ss_size = sizeof (__gnat_alternate_stack);
|
|
|
388 stack.ss_flags = 0;
|
|
|
389 sigaltstack (&stack, NULL);
|
|
|
390
|
|
|
391 act.sa_sigaction = __gnat_error_handler;
|
|
|
392 act.sa_flags = SA_NODEFER | SA_RESTART | SA_SIGINFO;
|
|
|
393 sigemptyset (&act.sa_mask);
|
|
|
394
|
|
|
395 /* Do not install handlers if interrupt state is "System". */
|
|
|
396 if (__gnat_get_interrupt_state (SIGABRT) != 's')
|
|
|
397 sigaction (SIGABRT, &act, NULL);
|
|
|
398 if (__gnat_get_interrupt_state (SIGFPE) != 's')
|
|
|
399 sigaction (SIGFPE, &act, NULL);
|
|
|
400 if (__gnat_get_interrupt_state (SIGILL) != 's')
|
|
|
401 sigaction (SIGILL, &act, NULL);
|
|
|
402 if (__gnat_get_interrupt_state (SIGBUS) != 's')
|
|
|
403 sigaction (SIGBUS, &act, NULL);
|
|
|
404 act.sa_flags |= SA_ONSTACK;
|
|
|
405 if (__gnat_get_interrupt_state (SIGSEGV) != 's')
|
|
|
406 sigaction (SIGSEGV, &act, NULL);
|
|
|
407
|
|
|
408 __gnat_handler_installed = 1;
|
|
|
409 }
|
|
|
410
|
|
|
411 /*********************/
|
|
|
412 /* GNU/Linux Section */
|
|
|
413 /*********************/
|
|
|
414
|
|
|
415 #elif defined (__linux__)
|
|
|
416
|
|
|
417 #include <signal.h>
|
|
|
418
|
|
|
419 #define __USE_GNU 1 /* required to get REG_EIP/RIP from glibc's ucontext.h */
|
|
|
420 #include <sys/ucontext.h>
|
|
|
421
|
|
|
422 /* GNU/Linux, which uses glibc, does not define NULL in included
|
|
|
423 header files. */
|
|
|
424
|
|
|
425 #if !defined (NULL)
|
|
|
426 #define NULL ((void *) 0)
|
|
|
427 #endif
|
|
|
428
|
|
|
429 #if defined (MaRTE)
|
|
|
430
|
|
|
431 /* MaRTE OS provides its own version of sigaction, sigfillset, and
|
|
|
432 sigemptyset (overriding these symbol names). We want to make sure that
|
|
|
433 the versions provided by the underlying C library are used here (these
|
|
|
434 versions are renamed by MaRTE to linux_sigaction, fake_linux_sigfillset,
|
|
|
435 and fake_linux_sigemptyset, respectively). The MaRTE library will not
|
|
|
436 always be present (it will not be linked if no tasking constructs are
|
|
|
437 used), so we use the weak symbol mechanism to point always to the symbols
|
|
|
438 defined within the C library. */
|
|
|
439
|
|
|
440 #pragma weak linux_sigaction
|
|
|
441 int linux_sigaction (int signum, const struct sigaction *act,
|
|
|
442 struct sigaction *oldact)
|
|
|
443 {
|
|
|
444 return sigaction (signum, act, oldact);
|
|
|
445 }
|
|
|
446 #define sigaction(signum, act, oldact) linux_sigaction (signum, act, oldact)
|
|
|
447
|
|
|
448 #pragma weak fake_linux_sigfillset
|
|
|
449 void fake_linux_sigfillset (sigset_t *set)
|
|
|
450 {
|
|
|
451 sigfillset (set);
|
|
|
452 }
|
|
|
453 #define sigfillset(set) fake_linux_sigfillset (set)
|
|
|
454
|
|
|
455 #pragma weak fake_linux_sigemptyset
|
|
|
456 void fake_linux_sigemptyset (sigset_t *set)
|
|
|
457 {
|
|
|
458 sigemptyset (set);
|
|
|
459 }
|
|
|
460 #define sigemptyset(set) fake_linux_sigemptyset (set)
|
|
|
461
|
|
|
462 #endif
|
|
|
463
|
|
|
464 #if defined (__i386__) || defined (__x86_64__) || defined (__ia64__) \
|
|
|
465 || defined (__ARMEL__)
|
|
|
466
|
|
|
467 #define HAVE_GNAT_ADJUST_CONTEXT_FOR_RAISE
|
|
|
468
|
|
|
469 void
|
|
|
470 __gnat_adjust_context_for_raise (int signo ATTRIBUTE_UNUSED, void *ucontext)
|
|
|
471 {
|
|
145
|
472 #ifndef STANDALONE
|
|
111
|
473 mcontext_t *mcontext = &((ucontext_t *) ucontext)->uc_mcontext;
|
|
|
474
|
|
|
475 /* On the i386 and x86-64 architectures, stack checking is performed by
|
|
|
476 means of probes with moving stack pointer, that is to say the probed
|
|
|
477 address is always the value of the stack pointer. Upon hitting the
|
|
|
478 guard page, the stack pointer therefore points to an inaccessible
|
|
|
479 address and an alternate signal stack is needed to run the handler.
|
|
|
480 But there is an additional twist: on these architectures, the EH
|
|
|
481 return code writes the address of the handler at the target CFA's
|
|
|
482 value on the stack before doing the jump. As a consequence, if
|
|
|
483 there is an active handler in the frame whose stack has overflowed,
|
|
|
484 the stack pointer must nevertheless point to an accessible address
|
|
|
485 by the time the EH return is executed.
|
|
|
486
|
|
|
487 We therefore adjust the saved value of the stack pointer by the size
|
|
|
488 of one page + a small dope of 4 words, in order to make sure that it
|
|
|
489 points to an accessible address in case it's used as the target CFA.
|
|
|
490 The stack checking code guarantees that this address is unused by the
|
|
|
491 time this happens. */
|
|
|
492
|
|
|
493 #if defined (__i386__)
|
|
|
494 unsigned long *pc = (unsigned long *)mcontext->gregs[REG_EIP];
|
|
|
495 /* The pattern is "orl $0x0,(%esp)" for a probe in 32-bit mode. */
|
|
|
496 if (signo == SIGSEGV && pc && *pc == 0x00240c83)
|
|
|
497 mcontext->gregs[REG_ESP] += 4096 + 4 * sizeof (unsigned long);
|
|
|
498 #elif defined (__x86_64__)
|
|
|
499 unsigned long long *pc = (unsigned long long *)mcontext->gregs[REG_RIP];
|
|
|
500 if (signo == SIGSEGV && pc
|
|
|
501 /* The pattern is "orq $0x0,(%rsp)" for a probe in 64-bit mode. */
|
|
|
502 && ((*pc & 0xffffffffffLL) == 0x00240c8348LL
|
|
|
503 /* The pattern may also be "orl $0x0,(%esp)" for a probe in
|
|
|
504 x32 mode. */
|
|
|
505 || (*pc & 0xffffffffLL) == 0x00240c83LL))
|
|
|
506 mcontext->gregs[REG_RSP] += 4096 + 4 * sizeof (unsigned long);
|
|
|
507 #elif defined (__ia64__)
|
|
|
508 /* ??? The IA-64 unwinder doesn't compensate for signals. */
|
|
|
509 mcontext->sc_ip++;
|
|
|
510 #elif defined (__ARMEL__)
|
|
|
511 /* ARM Bump has to be an even number because of odd/even architecture. */
|
|
|
512 mcontext->arm_pc+=2;
|
|
|
513 #ifdef __thumb2__
|
|
|
514 #define CPSR_THUMB_BIT 5
|
|
|
515 /* For thumb, the return address much have the low order bit set, otherwise
|
|
|
516 the unwinder will reset to "arm" mode upon return. As long as the
|
|
|
517 compilation unit containing the landing pad is compiled with the same
|
|
|
518 mode (arm vs thumb) as the signaling compilation unit, this works. */
|
|
|
519 if (mcontext->arm_cpsr & (1<<CPSR_THUMB_BIT))
|
|
|
520 mcontext->arm_pc+=1;
|
|
|
521 #endif
|
|
|
522 #endif
|
|
145
|
523 #endif
|
|
111
|
524 }
|
|
|
525
|
|
|
526 #endif
|
|
|
527
|
|
|
528 static void
|
|
|
529 __gnat_error_handler (int sig, siginfo_t *si ATTRIBUTE_UNUSED, void *ucontext)
|
|
|
530 {
|
|
|
531 struct Exception_Data *exception;
|
|
|
532 const char *msg;
|
|
|
533
|
|
|
534 /* Adjusting is required for every fault context, so adjust for this one
|
|
|
535 now, before we possibly trigger a recursive fault below. */
|
|
|
536 __gnat_adjust_context_for_raise (sig, ucontext);
|
|
|
537
|
|
|
538 switch (sig)
|
|
|
539 {
|
|
|
540 case SIGSEGV:
|
|
|
541 /* Here we would like a discrimination test to see whether the page
|
|
|
542 before the faulting address is accessible. Unfortunately, Linux
|
|
|
543 seems to have no way of giving us the faulting address.
|
|
|
544
|
|
|
545 In old versions of init.c, we had a test of the page before the
|
|
|
546 stack pointer:
|
|
|
547
|
|
|
548 ((volatile char *)
|
|
|
549 ((long) si->esp_at_signal & - getpagesize ()))[getpagesize ()];
|
|
|
550
|
|
|
551 but that's wrong since it tests the stack pointer location and the
|
|
|
552 stack probing code may not move it until all probes succeed.
|
|
|
553
|
|
|
554 For now we simply do not attempt any discrimination at all. Note
|
|
|
555 that this is quite acceptable, since a "real" SIGSEGV can only
|
|
|
556 occur as the result of an erroneous program. */
|
|
|
557 exception = &storage_error;
|
|
|
558 msg = "stack overflow or erroneous memory access";
|
|
|
559 break;
|
|
|
560
|
|
|
561 case SIGBUS:
|
|
|
562 exception = &storage_error;
|
|
|
563 msg = "SIGBUS: possible stack overflow";
|
|
|
564 break;
|
|
|
565
|
|
|
566 case SIGFPE:
|
|
|
567 exception = &constraint_error;
|
|
|
568 msg = "SIGFPE";
|
|
|
569 break;
|
|
|
570
|
|
|
571 default:
|
|
|
572 exception = &program_error;
|
|
|
573 msg = "unhandled signal";
|
|
|
574 }
|
|
|
575
|
|
|
576 Raise_From_Signal_Handler (exception, msg);
|
|
|
577 }
|
|
|
578
|
|
|
579 #ifndef __ia64__
|
|
|
580 #define HAVE_GNAT_ALTERNATE_STACK 1
|
|
|
581 /* This must be in keeping with System.OS_Interface.Alternate_Stack_Size.
|
|
|
582 It must be larger than MINSIGSTKSZ and hopefully near 2 * SIGSTKSZ. */
|
|
|
583 # if 16 * 1024 < MINSIGSTKSZ
|
|
|
584 # error "__gnat_alternate_stack too small"
|
|
|
585 # endif
|
|
|
586 char __gnat_alternate_stack[16 * 1024];
|
|
|
587 #endif
|
|
|
588
|
|
|
589 #ifdef __XENO__
|
|
|
590 #include <sys/mman.h>
|
|
|
591 #include <native/task.h>
|
|
|
592
|
|
|
593 RT_TASK main_task;
|
|
|
594 #endif
|
|
|
595
|
|
|
596 void
|
|
|
597 __gnat_install_handler (void)
|
|
|
598 {
|
|
|
599 struct sigaction act;
|
|
|
600
|
|
|
601 #ifdef __XENO__
|
|
|
602 int prio;
|
|
|
603
|
|
|
604 if (__gl_main_priority == -1)
|
|
|
605 prio = 49;
|
|
|
606 else
|
|
|
607 prio = __gl_main_priority;
|
|
|
608
|
|
|
609 /* Avoid memory swapping for this program */
|
|
|
610
|
|
|
611 mlockall (MCL_CURRENT|MCL_FUTURE);
|
|
|
612
|
|
|
613 /* Turn the current Linux task into a native Xenomai task */
|
|
|
614
|
|
|
615 rt_task_shadow (&main_task, "environment_task", prio, T_FPU);
|
|
|
616 #endif
|
|
|
617
|
|
|
618 /* Set up signal handler to map synchronous signals to appropriate
|
|
|
619 exceptions. Make sure that the handler isn't interrupted by another
|
|
|
620 signal that might cause a scheduling event! Also setup an alternate
|
|
|
621 stack region for the handler execution so that stack overflows can be
|
|
|
622 handled properly, avoiding a SEGV generation from stack usage by the
|
|
|
623 handler itself. */
|
|
|
624
|
|
|
625 act.sa_sigaction = __gnat_error_handler;
|
|
|
626 act.sa_flags = SA_NODEFER | SA_RESTART | SA_SIGINFO;
|
|
|
627 sigemptyset (&act.sa_mask);
|
|
|
628
|
|
|
629 /* Do not install handlers if interrupt state is "System". */
|
|
|
630 if (__gnat_get_interrupt_state (SIGABRT) != 's')
|
|
|
631 sigaction (SIGABRT, &act, NULL);
|
|
|
632 if (__gnat_get_interrupt_state (SIGFPE) != 's')
|
|
|
633 sigaction (SIGFPE, &act, NULL);
|
|
|
634 if (__gnat_get_interrupt_state (SIGILL) != 's')
|
|
|
635 sigaction (SIGILL, &act, NULL);
|
|
|
636 if (__gnat_get_interrupt_state (SIGBUS) != 's')
|
|
|
637 sigaction (SIGBUS, &act, NULL);
|
|
|
638 if (__gnat_get_interrupt_state (SIGSEGV) != 's')
|
|
|
639 {
|
|
|
640 #ifdef HAVE_GNAT_ALTERNATE_STACK
|
|
|
641 /* Setup an alternate stack region for the handler execution so that
|
|
|
642 stack overflows can be handled properly, avoiding a SEGV generation
|
|
|
643 from stack usage by the handler itself. */
|
|
|
644 stack_t stack;
|
|
|
645
|
|
|
646 stack.ss_sp = __gnat_alternate_stack;
|
|
|
647 stack.ss_size = sizeof (__gnat_alternate_stack);
|
|
|
648 stack.ss_flags = 0;
|
|
|
649 sigaltstack (&stack, NULL);
|
|
|
650
|
|
|
651 act.sa_flags |= SA_ONSTACK;
|
|
|
652 #endif
|
|
|
653 sigaction (SIGSEGV, &act, NULL);
|
|
|
654 }
|
|
|
655
|
|
|
656 __gnat_handler_installed = 1;
|
|
|
657 }
|
|
|
658
|
|
|
659 /*******************/
|
|
|
660 /* LynxOS Section */
|
|
|
661 /*******************/
|
|
|
662
|
|
|
663 #elif defined (__Lynx__)
|
|
|
664
|
|
|
665 #include <signal.h>
|
|
|
666 #include <unistd.h>
|
|
|
667
|
|
|
668 static void
|
|
|
669 __gnat_error_handler (int sig)
|
|
|
670 {
|
|
|
671 struct Exception_Data *exception;
|
|
|
672 const char *msg;
|
|
|
673
|
|
|
674 switch(sig)
|
|
|
675 {
|
|
|
676 case SIGFPE:
|
|
|
677 exception = &constraint_error;
|
|
|
678 msg = "SIGFPE";
|
|
|
679 break;
|
|
|
680 case SIGILL:
|
|
|
681 exception = &constraint_error;
|
|
|
682 msg = "SIGILL";
|
|
|
683 break;
|
|
|
684 case SIGSEGV:
|
|
|
685 exception = &storage_error;
|
|
|
686 msg = "stack overflow or erroneous memory access";
|
|
|
687 break;
|
|
|
688 case SIGBUS:
|
|
|
689 exception = &constraint_error;
|
|
|
690 msg = "SIGBUS";
|
|
|
691 break;
|
|
|
692 default:
|
|
|
693 exception = &program_error;
|
|
|
694 msg = "unhandled signal";
|
|
|
695 }
|
|
|
696
|
|
|
697 Raise_From_Signal_Handler (exception, msg);
|
|
|
698 }
|
|
|
699
|
|
|
700 void
|
|
|
701 __gnat_install_handler (void)
|
|
|
702 {
|
|
|
703 struct sigaction act;
|
|
|
704
|
|
|
705 act.sa_handler = __gnat_error_handler;
|
|
|
706 act.sa_flags = 0x0;
|
|
|
707 sigemptyset (&act.sa_mask);
|
|
|
708
|
|
|
709 /* Do not install handlers if interrupt state is "System". */
|
|
|
710 if (__gnat_get_interrupt_state (SIGFPE) != 's')
|
|
|
711 sigaction (SIGFPE, &act, NULL);
|
|
|
712 if (__gnat_get_interrupt_state (SIGILL) != 's')
|
|
|
713 sigaction (SIGILL, &act, NULL);
|
|
|
714 if (__gnat_get_interrupt_state (SIGSEGV) != 's')
|
|
|
715 sigaction (SIGSEGV, &act, NULL);
|
|
|
716 if (__gnat_get_interrupt_state (SIGBUS) != 's')
|
|
|
717 sigaction (SIGBUS, &act, NULL);
|
|
|
718
|
|
|
719 __gnat_handler_installed = 1;
|
|
|
720 }
|
|
|
721
|
|
|
722 /*******************/
|
|
|
723 /* Solaris Section */
|
|
|
724 /*******************/
|
|
|
725
|
|
|
726 #elif defined (__sun__) && !defined (__vxworks)
|
|
|
727
|
|
|
728 #include <signal.h>
|
|
|
729 #include <siginfo.h>
|
|
|
730 #include <sys/ucontext.h>
|
|
|
731 #include <sys/regset.h>
|
|
|
732
|
|
|
733 static void
|
|
|
734 __gnat_error_handler (int sig, siginfo_t *si, void *ucontext ATTRIBUTE_UNUSED)
|
|
|
735 {
|
|
|
736 struct Exception_Data *exception;
|
|
|
737 static int recurse = 0;
|
|
|
738 const char *msg;
|
|
|
739
|
|
|
740 switch (sig)
|
|
|
741 {
|
|
|
742 case SIGSEGV:
|
|
|
743 /* If the problem was permissions, this is a constraint error.
|
|
|
744 Likewise if the failing address isn't maximally aligned or if
|
|
|
745 we've recursed.
|
|
|
746
|
|
|
747 ??? Using a static variable here isn't task-safe, but it's
|
|
|
748 much too hard to do anything else and we're just determining
|
|
|
749 which exception to raise. */
|
|
|
750 if (si->si_code == SEGV_ACCERR
|
|
|
751 || (long) si->si_addr == 0
|
|
|
752 || (((long) si->si_addr) & 3) != 0
|
|
|
753 || recurse)
|
|
|
754 {
|
|
|
755 exception = &constraint_error;
|
|
|
756 msg = "SIGSEGV";
|
|
|
757 }
|
|
|
758 else
|
|
|
759 {
|
|
|
760 /* See if the page before the faulting page is accessible. Do that
|
|
|
761 by trying to access it. We'd like to simply try to access
|
|
|
762 4096 + the faulting address, but it's not guaranteed to be
|
|
|
763 the actual address, just to be on the same page. */
|
|
|
764 recurse++;
|
|
|
765 ((volatile char *)
|
|
|
766 ((long) si->si_addr & - getpagesize ()))[getpagesize ()];
|
|
|
767 exception = &storage_error;
|
|
|
768 msg = "stack overflow or erroneous memory access";
|
|
|
769 }
|
|
|
770 break;
|
|
|
771
|
|
|
772 case SIGBUS:
|
|
|
773 exception = &program_error;
|
|
|
774 msg = "SIGBUS";
|
|
|
775 break;
|
|
|
776
|
|
|
777 case SIGFPE:
|
|
|
778 exception = &constraint_error;
|
|
|
779 msg = "SIGFPE";
|
|
|
780 break;
|
|
|
781
|
|
|
782 default:
|
|
|
783 exception = &program_error;
|
|
|
784 msg = "unhandled signal";
|
|
|
785 }
|
|
|
786
|
|
|
787 recurse = 0;
|
|
|
788 Raise_From_Signal_Handler (exception, msg);
|
|
|
789 }
|
|
|
790
|
|
|
791 void
|
|
|
792 __gnat_install_handler (void)
|
|
|
793 {
|
|
|
794 struct sigaction act;
|
|
|
795
|
|
|
796 /* Set up signal handler to map synchronous signals to appropriate
|
|
|
797 exceptions. Make sure that the handler isn't interrupted by another
|
|
|
798 signal that might cause a scheduling event! */
|
|
|
799
|
|
|
800 act.sa_sigaction = __gnat_error_handler;
|
|
|
801 act.sa_flags = SA_NODEFER | SA_RESTART | SA_SIGINFO;
|
|
|
802 sigemptyset (&act.sa_mask);
|
|
|
803
|
|
|
804 /* Do not install handlers if interrupt state is "System". */
|
|
|
805 if (__gnat_get_interrupt_state (SIGABRT) != 's')
|
|
|
806 sigaction (SIGABRT, &act, NULL);
|
|
|
807 if (__gnat_get_interrupt_state (SIGFPE) != 's')
|
|
|
808 sigaction (SIGFPE, &act, NULL);
|
|
|
809 if (__gnat_get_interrupt_state (SIGSEGV) != 's')
|
|
|
810 sigaction (SIGSEGV, &act, NULL);
|
|
|
811 if (__gnat_get_interrupt_state (SIGBUS) != 's')
|
|
|
812 sigaction (SIGBUS, &act, NULL);
|
|
|
813
|
|
|
814 __gnat_handler_installed = 1;
|
|
|
815 }
|
|
|
816
|
|
|
817 /***************/
|
|
|
818 /* VMS Section */
|
|
|
819 /***************/
|
|
|
820
|
|
|
821 #elif defined (VMS)
|
|
|
822
|
|
|
823 /* Routine called from binder to override default feature values. */
|
|
|
824 void __gnat_set_features (void);
|
|
|
825 int __gnat_features_set = 0;
|
|
|
826 void (*__gnat_ctrl_c_handler) (void) = 0;
|
|
|
827
|
|
|
828 #ifdef __IA64
|
|
|
829 #define lib_get_curr_invo_context LIB$I64_GET_CURR_INVO_CONTEXT
|
|
|
830 #define lib_get_prev_invo_context LIB$I64_GET_PREV_INVO_CONTEXT
|
|
|
831 #define lib_get_invo_handle LIB$I64_GET_INVO_HANDLE
|
|
|
832 #else
|
|
|
833 #define lib_get_curr_invo_context LIB$GET_CURR_INVO_CONTEXT
|
|
|
834 #define lib_get_prev_invo_context LIB$GET_PREV_INVO_CONTEXT
|
|
|
835 #define lib_get_invo_handle LIB$GET_INVO_HANDLE
|
|
|
836 #endif
|
|
|
837
|
|
|
838 /* Masks for facility identification. */
|
|
|
839 #define FAC_MASK 0x0fff0000
|
|
|
840 #define DECADA_M_FACILITY 0x00310000
|
|
|
841
|
|
|
842 /* Define macro symbols for the VMS conditions that become Ada exceptions.
|
|
|
843 It would be better to just include <ssdef.h> */
|
|
|
844
|
|
|
845 #define SS$_CONTINUE 1
|
|
|
846 #define SS$_ACCVIO 12
|
|
|
847 #define SS$_HPARITH 1284
|
|
|
848 #define SS$_INTDIV 1156
|
|
|
849 #define SS$_STKOVF 1364
|
|
|
850 #define SS$_CONTROLC 1617
|
|
|
851 #define SS$_RESIGNAL 2328
|
|
|
852
|
|
|
853 #define MTH$_FLOOVEMAT 1475268 /* Some ACVC_21 CXA tests */
|
|
|
854
|
|
|
855 /* The following codes must be resignalled, and not handled here. */
|
|
|
856
|
|
|
857 /* These codes are in standard message libraries. */
|
|
|
858 extern int C$_SIGKILL;
|
|
|
859 extern int C$_SIGINT;
|
|
|
860 extern int SS$_DEBUG;
|
|
|
861 extern int LIB$_KEYNOTFOU;
|
|
|
862 extern int LIB$_ACTIMAGE;
|
|
|
863
|
|
|
864 /* These codes are non standard, which is to say the author is
|
|
|
865 not sure if they are defined in the standard message libraries
|
|
|
866 so keep them as macros for now. */
|
|
|
867 #define RDB$_STREAM_EOF 20480426
|
|
|
868 #define FDL$_UNPRIKW 11829410
|
|
|
869 #define CMA$_EXIT_THREAD 4227492
|
|
|
870
|
|
|
871 struct cond_sigargs
|
|
|
872 {
|
|
|
873 unsigned int sigarg;
|
|
|
874 unsigned int sigargval;
|
|
|
875 };
|
|
|
876
|
|
|
877 struct cond_subtests
|
|
|
878 {
|
|
|
879 unsigned int num;
|
|
|
880 const struct cond_sigargs sigargs[];
|
|
|
881 };
|
|
|
882
|
|
|
883 struct cond_except
|
|
|
884 {
|
|
|
885 unsigned int cond;
|
|
|
886 const struct Exception_Data *except;
|
|
|
887 unsigned int needs_adjust; /* 1 = adjust PC, 0 = no adjust */
|
|
|
888 const struct cond_subtests *subtests;
|
|
|
889 };
|
|
|
890
|
|
|
891 struct descriptor_s
|
|
|
892 {
|
|
|
893 unsigned short len, mbz;
|
|
|
894 __char_ptr32 adr;
|
|
|
895 };
|
|
|
896
|
|
|
897 /* Conditions that don't have an Ada exception counterpart must raise
|
|
|
898 Non_Ada_Error. Since this is defined in s-auxdec, it should only be
|
|
|
899 referenced by user programs, not the compiler or tools. Hence the
|
|
|
900 #ifdef IN_RTS. */
|
|
|
901
|
|
|
902 #ifdef IN_RTS
|
|
|
903
|
|
|
904 #define Status_Error ada__io_exceptions__status_error
|
|
|
905 extern struct Exception_Data Status_Error;
|
|
|
906
|
|
|
907 #define Mode_Error ada__io_exceptions__mode_error
|
|
|
908 extern struct Exception_Data Mode_Error;
|
|
|
909
|
|
|
910 #define Name_Error ada__io_exceptions__name_error
|
|
|
911 extern struct Exception_Data Name_Error;
|
|
|
912
|
|
|
913 #define Use_Error ada__io_exceptions__use_error
|
|
|
914 extern struct Exception_Data Use_Error;
|
|
|
915
|
|
|
916 #define Device_Error ada__io_exceptions__device_error
|
|
|
917 extern struct Exception_Data Device_Error;
|
|
|
918
|
|
|
919 #define End_Error ada__io_exceptions__end_error
|
|
|
920 extern struct Exception_Data End_Error;
|
|
|
921
|
|
|
922 #define Data_Error ada__io_exceptions__data_error
|
|
|
923 extern struct Exception_Data Data_Error;
|
|
|
924
|
|
|
925 #define Layout_Error ada__io_exceptions__layout_error
|
|
|
926 extern struct Exception_Data Layout_Error;
|
|
|
927
|
|
|
928 #define Non_Ada_Error system__aux_dec__non_ada_error
|
|
|
929 extern struct Exception_Data Non_Ada_Error;
|
|
|
930
|
|
|
931 #define Coded_Exception system__vms_exception_table__coded_exception
|
|
|
932 extern struct Exception_Data *Coded_Exception (void *);
|
|
|
933
|
|
|
934 #define Base_Code_In system__vms_exception_table__base_code_in
|
|
|
935 extern void *Base_Code_In (void *);
|
|
|
936
|
|
|
937 /* DEC Ada exceptions are not defined in a header file, so they
|
|
|
938 must be declared. */
|
|
|
939
|
|
|
940 #define ADA$_ALREADY_OPEN 0x0031a594
|
|
|
941 #define ADA$_CONSTRAINT_ERRO 0x00318324
|
|
|
942 #define ADA$_DATA_ERROR 0x003192c4
|
|
|
943 #define ADA$_DEVICE_ERROR 0x003195e4
|
|
|
944 #define ADA$_END_ERROR 0x00319904
|
|
|
945 #define ADA$_FAC_MODE_MISMAT 0x0031a8b3
|
|
|
946 #define ADA$_IOSYSFAILED 0x0031af04
|
|
|
947 #define ADA$_KEYSIZERR 0x0031aa3c
|
|
|
948 #define ADA$_KEY_MISMATCH 0x0031a8e3
|
|
|
949 #define ADA$_LAYOUT_ERROR 0x00319c24
|
|
|
950 #define ADA$_LINEXCMRS 0x0031a8f3
|
|
|
951 #define ADA$_MAXLINEXC 0x0031a8eb
|
|
|
952 #define ADA$_MODE_ERROR 0x00319f44
|
|
|
953 #define ADA$_MRN_MISMATCH 0x0031a8db
|
|
|
954 #define ADA$_MRS_MISMATCH 0x0031a8d3
|
|
|
955 #define ADA$_NAME_ERROR 0x0031a264
|
|
|
956 #define ADA$_NOT_OPEN 0x0031a58c
|
|
|
957 #define ADA$_ORG_MISMATCH 0x0031a8bb
|
|
|
958 #define ADA$_PROGRAM_ERROR 0x00318964
|
|
|
959 #define ADA$_RAT_MISMATCH 0x0031a8cb
|
|
|
960 #define ADA$_RFM_MISMATCH 0x0031a8c3
|
|
|
961 #define ADA$_STAOVF 0x00318cac
|
|
|
962 #define ADA$_STATUS_ERROR 0x0031a584
|
|
|
963 #define ADA$_STORAGE_ERROR 0x00318c84
|
|
|
964 #define ADA$_UNSUPPORTED 0x0031a8ab
|
|
|
965 #define ADA$_USE_ERROR 0x0031a8a4
|
|
|
966
|
|
|
967 /* DEC Ada specific conditions. */
|
|
|
968 static const struct cond_except dec_ada_cond_except_table [] =
|
|
|
969 {
|
|
|
970 {ADA$_PROGRAM_ERROR, &program_error, 0, 0},
|
|
|
971 {ADA$_USE_ERROR, &Use_Error, 0, 0},
|
|
|
972 {ADA$_KEYSIZERR, &program_error, 0, 0},
|
|
|
973 {ADA$_STAOVF, &storage_error, 0, 0},
|
|
|
974 {ADA$_CONSTRAINT_ERRO, &constraint_error, 0, 0},
|
|
|
975 {ADA$_IOSYSFAILED, &Device_Error, 0, 0},
|
|
|
976 {ADA$_LAYOUT_ERROR, &Layout_Error, 0, 0},
|
|
|
977 {ADA$_STORAGE_ERROR, &storage_error, 0, 0},
|
|
|
978 {ADA$_DATA_ERROR, &Data_Error, 0, 0},
|
|
|
979 {ADA$_DEVICE_ERROR, &Device_Error, 0, 0},
|
|
|
980 {ADA$_END_ERROR, &End_Error, 0, 0},
|
|
|
981 {ADA$_MODE_ERROR, &Mode_Error, 0, 0},
|
|
|
982 {ADA$_NAME_ERROR, &Name_Error, 0, 0},
|
|
|
983 {ADA$_STATUS_ERROR, &Status_Error, 0, 0},
|
|
|
984 {ADA$_NOT_OPEN, &Use_Error, 0, 0},
|
|
|
985 {ADA$_ALREADY_OPEN, &Use_Error, 0, 0},
|
|
|
986 {ADA$_USE_ERROR, &Use_Error, 0, 0},
|
|
|
987 {ADA$_UNSUPPORTED, &Use_Error, 0, 0},
|
|
|
988 {ADA$_FAC_MODE_MISMAT, &Use_Error, 0, 0},
|
|
|
989 {ADA$_ORG_MISMATCH, &Use_Error, 0, 0},
|
|
|
990 {ADA$_RFM_MISMATCH, &Use_Error, 0, 0},
|
|
|
991 {ADA$_RAT_MISMATCH, &Use_Error, 0, 0},
|
|
|
992 {ADA$_MRS_MISMATCH, &Use_Error, 0, 0},
|
|
|
993 {ADA$_MRN_MISMATCH, &Use_Error, 0, 0},
|
|
|
994 {ADA$_KEY_MISMATCH, &Use_Error, 0, 0},
|
|
|
995 {ADA$_MAXLINEXC, &constraint_error, 0, 0},
|
|
|
996 {ADA$_LINEXCMRS, &constraint_error, 0, 0},
|
|
|
997
|
|
|
998 #if 0
|
|
|
999 /* Already handled by a pragma Import_Exception
|
|
|
1000 in Aux_IO_Exceptions */
|
|
|
1001 {ADA$_LOCK_ERROR, &Lock_Error, 0, 0},
|
|
|
1002 {ADA$_EXISTENCE_ERROR, &Existence_Error, 0, 0},
|
|
|
1003 {ADA$_KEY_ERROR, &Key_Error, 0, 0},
|
|
|
1004 #endif
|
|
|
1005
|
|
|
1006 {0, 0, 0, 0}
|
|
|
1007 };
|
|
|
1008
|
|
|
1009 #endif /* IN_RTS */
|
|
|
1010
|
|
|
1011 /* Non-DEC Ada specific conditions that map to Ada exceptions. */
|
|
|
1012
|
|
|
1013 /* Subtest for ACCVIO Constraint_Error, kept for compatibility,
|
|
|
1014 in hindsight should have just made ACCVIO == Storage_Error. */
|
|
|
1015 #define ACCVIO_VIRTUAL_ADDR 3
|
|
|
1016 static const struct cond_subtests accvio_c_e =
|
|
|
1017 {1, /* number of subtests below */
|
|
|
1018 {
|
|
|
1019 { ACCVIO_VIRTUAL_ADDR, 0 }
|
|
|
1020 }
|
|
|
1021 };
|
|
|
1022
|
|
|
1023 /* Macro flag to adjust PC which gets off by one for some conditions,
|
|
|
1024 not sure if this is reliably true, PC could be off by more for
|
|
|
1025 HPARITH for example, unless a trapb is inserted. */
|
|
|
1026 #define NEEDS_ADJUST 1
|
|
|
1027
|
|
|
1028 static const struct cond_except system_cond_except_table [] =
|
|
|
1029 {
|
|
|
1030 {MTH$_FLOOVEMAT, &constraint_error, 0, 0},
|
|
|
1031 {SS$_INTDIV, &constraint_error, 0, 0},
|
|
|
1032 {SS$_HPARITH, &constraint_error, NEEDS_ADJUST, 0},
|
|
|
1033 {SS$_ACCVIO, &constraint_error, NEEDS_ADJUST, &accvio_c_e},
|
|
|
1034 {SS$_ACCVIO, &storage_error, NEEDS_ADJUST, 0},
|
|
|
1035 {SS$_STKOVF, &storage_error, NEEDS_ADJUST, 0},
|
|
|
1036 {0, 0, 0, 0}
|
|
|
1037 };
|
|
|
1038
|
|
|
1039 /* To deal with VMS conditions and their mapping to Ada exceptions,
|
|
|
1040 the __gnat_error_handler routine below is installed as an exception
|
|
|
1041 vector having precedence over DEC frame handlers. Some conditions
|
|
|
1042 still need to be handled by such handlers, however, in which case
|
|
|
1043 __gnat_error_handler needs to return SS$_RESIGNAL. Consider for
|
|
|
1044 instance the use of a third party library compiled with DECAda and
|
|
|
1045 performing its own exception handling internally.
|
|
|
1046
|
|
|
1047 To allow some user-level flexibility, which conditions should be
|
|
|
1048 resignaled is controlled by a predicate function, provided with the
|
|
|
1049 condition value and returning a boolean indication stating whether
|
|
|
1050 this condition should be resignaled or not.
|
|
|
1051
|
|
|
1052 That predicate function is called indirectly, via a function pointer,
|
|
|
1053 by __gnat_error_handler, and changing that pointer is allowed to the
|
|
|
1054 user code by way of the __gnat_set_resignal_predicate interface.
|
|
|
1055
|
|
|
1056 The user level function may then implement what it likes, including
|
|
|
1057 for instance the maintenance of a dynamic data structure if the set
|
|
|
1058 of to be resignalled conditions has to change over the program's
|
|
|
1059 lifetime.
|
|
|
1060
|
|
|
1061 ??? This is not a perfect solution to deal with the possible
|
|
|
1062 interactions between the GNAT and the DECAda exception handling
|
|
|
1063 models and better (more general) schemes are studied. This is so
|
|
|
1064 just provided as a convenient workaround in the meantime, and
|
|
|
1065 should be use with caution since the implementation has been kept
|
|
|
1066 very simple. */
|
|
|
1067
|
|
|
1068 typedef int resignal_predicate (int code);
|
|
|
1069
|
|
|
1070 static const int * const cond_resignal_table [] =
|
|
|
1071 {
|
|
|
1072 &C$_SIGKILL,
|
|
|
1073 (int *)CMA$_EXIT_THREAD,
|
|
|
1074 &SS$_DEBUG,
|
|
|
1075 &LIB$_KEYNOTFOU,
|
|
|
1076 &LIB$_ACTIMAGE,
|
|
|
1077 (int *) RDB$_STREAM_EOF,
|
|
|
1078 (int *) FDL$_UNPRIKW,
|
|
|
1079 0
|
|
|
1080 };
|
|
|
1081
|
|
|
1082 static const int facility_resignal_table [] =
|
|
|
1083 {
|
|
|
1084 0x1380000, /* RDB */
|
|
|
1085 0x2220000, /* SQL */
|
|
|
1086 0
|
|
|
1087 };
|
|
|
1088
|
|
|
1089 /* Default GNAT predicate for resignaling conditions. */
|
|
|
1090
|
|
|
1091 static int
|
|
|
1092 __gnat_default_resignal_p (int code)
|
|
|
1093 {
|
|
|
1094 int i, iexcept;
|
|
|
1095
|
|
|
1096 for (i = 0; facility_resignal_table [i]; i++)
|
|
|
1097 if ((code & FAC_MASK) == facility_resignal_table [i])
|
|
|
1098 return 1;
|
|
|
1099
|
|
|
1100 for (i = 0, iexcept = 0;
|
|
|
1101 cond_resignal_table [i]
|
|
|
1102 && !(iexcept = LIB$MATCH_COND (&code, &cond_resignal_table [i]));
|
|
|
1103 i++);
|
|
|
1104
|
|
|
1105 return iexcept;
|
|
|
1106 }
|
|
|
1107
|
|
|
1108 /* Static pointer to predicate that the __gnat_error_handler exception
|
|
|
1109 vector invokes to determine if it should resignal a condition. */
|
|
|
1110
|
|
|
1111 static resignal_predicate *__gnat_resignal_p = __gnat_default_resignal_p;
|
|
|
1112
|
|
|
1113 /* User interface to change the predicate pointer to PREDICATE. Reset to
|
|
|
1114 the default if PREDICATE is null. */
|
|
|
1115
|
|
|
1116 void
|
|
|
1117 __gnat_set_resignal_predicate (resignal_predicate *predicate)
|
|
|
1118 {
|
|
|
1119 if (predicate == NULL)
|
|
|
1120 __gnat_resignal_p = __gnat_default_resignal_p;
|
|
|
1121 else
|
|
|
1122 __gnat_resignal_p = predicate;
|
|
|
1123 }
|
|
|
1124
|
|
|
1125 /* Should match System.Parameters.Default_Exception_Msg_Max_Length. */
|
|
|
1126 #define Default_Exception_Msg_Max_Length 512
|
|
|
1127
|
|
|
1128 /* Action routine for SYS$PUTMSG. There may be multiple
|
|
|
1129 conditions, each with text to be appended to MESSAGE
|
|
|
1130 and separated by line termination. */
|
|
|
1131 static int
|
|
|
1132 copy_msg (struct descriptor_s *msgdesc, char *message)
|
|
|
1133 {
|
|
|
1134 int len = strlen (message);
|
|
|
1135 int copy_len;
|
|
|
1136
|
|
|
1137 /* Check for buffer overflow and skip. */
|
|
|
1138 if (len > 0 && len <= Default_Exception_Msg_Max_Length - 3)
|
|
|
1139 {
|
|
|
1140 strcat (message, "\r\n");
|
|
|
1141 len += 2;
|
|
|
1142 }
|
|
|
1143
|
|
|
1144 /* Check for buffer overflow and truncate if necessary. */
|
|
|
1145 copy_len = (len + msgdesc->len <= Default_Exception_Msg_Max_Length - 1 ?
|
|
|
1146 msgdesc->len :
|
|
|
1147 Default_Exception_Msg_Max_Length - 1 - len);
|
|
|
1148 strncpy (&message [len], msgdesc->adr, copy_len);
|
|
|
1149 message [len + copy_len] = 0;
|
|
|
1150
|
|
|
1151 return 0;
|
|
|
1152 }
|
|
|
1153
|
|
|
1154 /* Scan TABLE for a match for the condition contained in SIGARGS,
|
|
|
1155 and return the entry, or the empty entry if no match found. */
|
|
|
1156 static const struct cond_except *
|
|
|
1157 scan_conditions ( int *sigargs, const struct cond_except *table [])
|
|
|
1158 {
|
|
|
1159 int i;
|
|
|
1160 struct cond_except entry;
|
|
|
1161
|
|
|
1162 /* Scan the exception condition table for a match and fetch
|
|
|
1163 the associated GNAT exception pointer. */
|
|
|
1164 for (i = 0; (*table) [i].cond; i++)
|
|
|
1165 {
|
|
|
1166 unsigned int match = LIB$MATCH_COND (&sigargs [1], &(*table) [i].cond);
|
|
|
1167 const struct cond_subtests *subtests = (*table) [i].subtests;
|
|
|
1168
|
|
|
1169 if (match)
|
|
|
1170 {
|
|
|
1171 if (!subtests)
|
|
|
1172 {
|
|
|
1173 return &(*table) [i];
|
|
|
1174 }
|
|
|
1175 else
|
|
|
1176 {
|
|
|
1177 unsigned int ii;
|
|
|
1178 int num = (*subtests).num;
|
|
|
1179
|
|
|
1180 /* Perform subtests to differentiate exception. */
|
|
|
1181 for (ii = 0; ii < num; ii++)
|
|
|
1182 {
|
|
|
1183 unsigned int arg = (*subtests).sigargs [ii].sigarg;
|
|
|
1184 unsigned int argval = (*subtests).sigargs [ii].sigargval;
|
|
|
1185
|
|
|
1186 if (sigargs [arg] != argval)
|
|
|
1187 {
|
|
|
1188 num = 0;
|
|
|
1189 break;
|
|
|
1190 }
|
|
|
1191 }
|
|
|
1192
|
|
|
1193 /* All subtests passed. */
|
|
|
1194 if (num == (*subtests).num)
|
|
|
1195 return &(*table) [i];
|
|
|
1196 }
|
|
|
1197 }
|
|
|
1198 }
|
|
|
1199
|
|
|
1200 /* No match, return the null terminating entry. */
|
|
|
1201 return &(*table) [i];
|
|
|
1202 }
|
|
|
1203
|
|
|
1204 /* __gnat_handle_vms_condtition is both a frame based handler
|
|
|
1205 for the runtime, and an exception vector for the compiler. */
|
|
|
1206 long
|
|
|
1207 __gnat_handle_vms_condition (int *sigargs, void *mechargs)
|
|
|
1208 {
|
|
|
1209 struct Exception_Data *exception = 0;
|
|
|
1210 unsigned int needs_adjust = 0;
|
|
|
1211 void *base_code;
|
|
|
1212 struct descriptor_s gnat_facility = {4, 0, "GNAT"};
|
|
|
1213 char message [Default_Exception_Msg_Max_Length];
|
|
|
1214
|
|
|
1215 const char *msg = "";
|
|
|
1216
|
|
|
1217 /* Check for conditions to resignal which aren't effected by pragma
|
|
|
1218 Import_Exception. */
|
|
|
1219 if (__gnat_resignal_p (sigargs [1]))
|
|
|
1220 return SS$_RESIGNAL;
|
|
|
1221 #ifndef IN_RTS
|
|
|
1222 /* toplev.c handles this for compiler. */
|
|
|
1223 if (sigargs [1] == SS$_HPARITH)
|
|
|
1224 return SS$_RESIGNAL;
|
|
|
1225 #endif
|
|
|
1226
|
|
|
1227 #ifdef IN_RTS
|
|
|
1228 /* See if it's an imported exception. Beware that registered exceptions
|
|
|
1229 are bound to their base code, with the severity bits masked off. */
|
|
|
1230 base_code = Base_Code_In ((void *) sigargs[1]);
|
|
|
1231 exception = Coded_Exception (base_code);
|
|
|
1232 #endif
|
|
|
1233
|
|
|
1234 if (exception == 0)
|
|
|
1235 #ifdef IN_RTS
|
|
|
1236 {
|
|
|
1237 int i;
|
|
|
1238 struct cond_except cond;
|
|
|
1239 const struct cond_except *cond_table;
|
|
|
1240 const struct cond_except *cond_tables [] = {dec_ada_cond_except_table,
|
|
|
1241 system_cond_except_table,
|
|
|
1242 0};
|
|
|
1243 unsigned int ctrlc = SS$_CONTROLC;
|
|
|
1244 unsigned int *sigint = &C$_SIGINT;
|
|
|
1245 int ctrlc_match = LIB$MATCH_COND (&sigargs [1], &ctrlc);
|
|
|
1246 int sigint_match = LIB$MATCH_COND (&sigargs [1], &sigint);
|
|
|
1247
|
|
|
1248 extern int SYS$DCLAST (void (*astadr)(), unsigned long long astprm,
|
|
|
1249 unsigned int acmode);
|
|
|
1250
|
|
|
1251 /* If SS$_CONTROLC has been imported as an exception, it will take
|
|
|
1252 priority over a Ctrl/C handler. See above. SIGINT has a
|
|
|
1253 different condition value due to it's DECCCRTL roots and it's
|
|
|
1254 the condition that gets raised for a "kill -INT". */
|
|
|
1255 if ((ctrlc_match || sigint_match) && __gnat_ctrl_c_handler)
|
|
|
1256 {
|
|
|
1257 SYS$DCLAST (__gnat_ctrl_c_handler, 0, 0);
|
|
|
1258 return SS$_CONTINUE;
|
|
|
1259 }
|
|
|
1260
|
|
|
1261 i = 0;
|
|
|
1262 while ((cond_table = cond_tables[i++]) && !exception)
|
|
|
1263 {
|
|
|
1264 cond = *scan_conditions (sigargs, &cond_table);
|
|
|
1265 exception = (struct Exception_Data *) cond.except;
|
|
|
1266 }
|
|
|
1267
|
|
|
1268 if (exception)
|
|
|
1269 needs_adjust = cond.needs_adjust;
|
|
|
1270 else
|
|
|
1271 /* User programs expect Non_Ada_Error to be raised if no match,
|
|
|
1272 reference DEC Ada test CXCONDHAN. */
|
|
|
1273 exception = &Non_Ada_Error;
|
|
|
1274 }
|
|
|
1275 #else
|
|
|
1276 {
|
|
|
1277 /* Pretty much everything is just a program error in the compiler */
|
|
|
1278 exception = &program_error;
|
|
|
1279 }
|
|
|
1280 #endif
|
|
|
1281
|
|
|
1282 message[0] = 0;
|
|
|
1283 /* Subtract PC & PSL fields as per ABI for SYS$PUTMSG. */
|
|
|
1284 sigargs[0] -= 2;
|
|
|
1285
|
|
|
1286 extern int SYS$PUTMSG (void *, int (*)(), void *, unsigned long long);
|
|
|
1287
|
|
|
1288 /* If it was a DEC Ada specific condtiion, make it GNAT otherwise
|
|
|
1289 keep the old facility. */
|
|
131
|
1290 if ((sigargs [1] & FAC_MASK) == DECADA_M_FACILITY)
|
|
111
|
1291 SYS$PUTMSG (sigargs, copy_msg, &gnat_facility,
|
|
|
1292 (unsigned long long ) message);
|
|
|
1293 else
|
|
|
1294 SYS$PUTMSG (sigargs, copy_msg, 0,
|
|
|
1295 (unsigned long long ) message);
|
|
|
1296
|
|
|
1297 /* Add back PC & PSL fields as per ABI for SYS$PUTMSG. */
|
|
|
1298 sigargs[0] += 2;
|
|
|
1299 msg = message;
|
|
|
1300
|
|
|
1301 if (needs_adjust)
|
|
|
1302 __gnat_adjust_context_for_raise (sigargs [1], (void *)mechargs);
|
|
|
1303
|
|
|
1304 Raise_From_Signal_Handler (exception, msg);
|
|
|
1305 }
|
|
|
1306
|
|
|
1307 #if defined (IN_RTS) && defined (__IA64)
|
|
|
1308 /* Called only from adasigio.b32. This is a band aid to avoid going
|
|
|
1309 through the VMS signal handling code which results in a 0x8000 per
|
|
|
1310 handled exception memory leak in P2 space (see VMS source listing
|
|
|
1311 sys/lis/exception.lis) due to the allocation of working space that
|
|
|
1312 is expected to be deallocated upon return from the condition handler,
|
|
|
1313 which doesn't return in GNAT compiled code. */
|
|
|
1314 void
|
|
|
1315 GNAT$STOP (int *sigargs)
|
|
|
1316 {
|
|
|
1317 /* Note that there are no mechargs. We rely on the fact that condtions
|
|
|
1318 raised from DEClib I/O do not require an "adjust". Also the count
|
|
|
1319 will be off by 2, since LIB$STOP didn't get a chance to add the
|
|
|
1320 PC and PSL fields, so we bump it so PUTMSG comes out right. */
|
|
|
1321 sigargs [0] += 2;
|
|
|
1322 __gnat_handle_vms_condition (sigargs, 0);
|
|
|
1323 }
|
|
|
1324 #endif
|
|
|
1325
|
|
|
1326 void
|
|
|
1327 __gnat_install_handler (void)
|
|
|
1328 {
|
|
|
1329 long prvhnd ATTRIBUTE_UNUSED;
|
|
|
1330
|
|
|
1331 #if !defined (IN_RTS)
|
|
|
1332 extern int SYS$SETEXV (unsigned int vector, int (*addres)(),
|
|
|
1333 unsigned int accmode, void *(*(prvhnd)));
|
|
|
1334 SYS$SETEXV (1, __gnat_handle_vms_condition, 3, &prvhnd);
|
|
|
1335 #endif
|
|
|
1336
|
|
|
1337 __gnat_handler_installed = 1;
|
|
|
1338 }
|
|
|
1339
|
|
|
1340 /* __gnat_adjust_context_for_raise for Alpha - see comments along with the
|
|
|
1341 default version later in this file. */
|
|
|
1342
|
|
|
1343 #if defined (IN_RTS) && defined (__alpha__)
|
|
|
1344
|
|
|
1345 #include <vms/chfctxdef.h>
|
|
|
1346 #include <vms/chfdef.h>
|
|
|
1347
|
|
|
1348 #define HAVE_GNAT_ADJUST_CONTEXT_FOR_RAISE
|
|
|
1349
|
|
|
1350 void
|
|
|
1351 __gnat_adjust_context_for_raise (int signo ATTRIBUTE_UNUSED, void *ucontext)
|
|
|
1352 {
|
|
|
1353 if (signo == SS$_HPARITH)
|
|
|
1354 {
|
|
|
1355 /* Sub one to the address of the instruction signaling the condition,
|
|
|
1356 located in the sigargs array. */
|
|
|
1357
|
|
|
1358 CHF$MECH_ARRAY * mechargs = (CHF$MECH_ARRAY *) ucontext;
|
|
|
1359 CHF$SIGNAL_ARRAY * sigargs
|
|
|
1360 = (CHF$SIGNAL_ARRAY *) mechargs->chf$q_mch_sig_addr;
|
|
|
1361
|
|
|
1362 int vcount = sigargs->chf$is_sig_args;
|
|
|
1363 int * pc_slot = & (&sigargs->chf$l_sig_name)[vcount-2];
|
|
|
1364
|
|
|
1365 (*pc_slot)--;
|
|
|
1366 }
|
|
|
1367 }
|
|
|
1368
|
|
|
1369 #endif
|
|
|
1370
|
|
|
1371 /* __gnat_adjust_context_for_raise for ia64. */
|
|
|
1372
|
|
|
1373 #if defined (IN_RTS) && defined (__IA64)
|
|
|
1374
|
|
|
1375 #include <vms/chfctxdef.h>
|
|
|
1376 #include <vms/chfdef.h>
|
|
|
1377
|
|
|
1378 #define HAVE_GNAT_ADJUST_CONTEXT_FOR_RAISE
|
|
|
1379
|
|
|
1380 typedef unsigned long long u64;
|
|
|
1381
|
|
|
1382 void
|
|
|
1383 __gnat_adjust_context_for_raise (int signo ATTRIBUTE_UNUSED, void *ucontext)
|
|
|
1384 {
|
|
|
1385 /* Add one to the address of the instruction signaling the condition,
|
|
|
1386 located in the 64bits sigargs array. */
|
|
|
1387
|
|
|
1388 CHF$MECH_ARRAY * mechargs = (CHF$MECH_ARRAY *) ucontext;
|
|
|
1389
|
|
|
1390 CHF64$SIGNAL_ARRAY *chfsig64
|
|
|
1391 = (CHF64$SIGNAL_ARRAY *) mechargs->chf$ph_mch_sig64_addr;
|
|
|
1392
|
|
|
1393 u64 * post_sigarray
|
|
|
1394 = (u64 *)chfsig64 + 1 + chfsig64->chf64$l_sig_args;
|
|
|
1395
|
|
|
1396 u64 * ih_pc_loc = post_sigarray - 2;
|
|
|
1397
|
|
|
1398 (*ih_pc_loc) ++;
|
|
|
1399 }
|
|
|
1400
|
|
|
1401 #endif
|
|
|
1402
|
|
|
1403 /* Easier interface for LIB$GET_LOGICAL: put the equivalence of NAME into BUF,
|
|
|
1404 always NUL terminated. In case of error or if the result is longer than
|
|
|
1405 LEN (length of BUF) an empty string is written info BUF. */
|
|
|
1406
|
|
|
1407 static void
|
|
|
1408 __gnat_vms_get_logical (const char *name, char *buf, int len)
|
|
|
1409 {
|
|
|
1410 struct descriptor_s name_desc, result_desc;
|
|
|
1411 int status;
|
|
|
1412 unsigned short rlen;
|
|
|
1413
|
|
|
1414 /* Build the descriptor for NAME. */
|
|
|
1415 name_desc.len = strlen (name);
|
|
|
1416 name_desc.mbz = 0;
|
|
|
1417 name_desc.adr = (char *)name;
|
|
|
1418
|
|
|
1419 /* Build the descriptor for the result. */
|
|
|
1420 result_desc.len = len;
|
|
|
1421 result_desc.mbz = 0;
|
|
|
1422 result_desc.adr = buf;
|
|
|
1423
|
|
|
1424 status = LIB$GET_LOGICAL (&name_desc, &result_desc, &rlen);
|
|
|
1425
|
|
|
1426 if ((status & 1) == 1 && rlen < len)
|
|
|
1427 buf[rlen] = 0;
|
|
|
1428 else
|
|
|
1429 buf[0] = 0;
|
|
|
1430 }
|
|
|
1431
|
|
|
1432 /* Size of a page on ia64 and alpha VMS. */
|
|
|
1433 #define VMS_PAGESIZE 8192
|
|
|
1434
|
|
|
1435 /* User mode. */
|
|
|
1436 #define PSL__C_USER 3
|
|
|
1437
|
|
|
1438 /* No access. */
|
|
|
1439 #define PRT__C_NA 0
|
|
|
1440
|
|
|
1441 /* Descending region. */
|
|
|
1442 #define VA__M_DESCEND 1
|
|
|
1443
|
|
|
1444 /* Get by virtual address. */
|
|
|
1445 #define VA___REGSUM_BY_VA 1
|
|
|
1446
|
|
|
1447 /* Memory region summary. */
|
|
|
1448 struct regsum
|
|
|
1449 {
|
|
|
1450 unsigned long long q_region_id;
|
|
|
1451 unsigned int l_flags;
|
|
|
1452 unsigned int l_region_protection;
|
|
|
1453 void *pq_start_va;
|
|
|
1454 unsigned long long q_region_size;
|
|
|
1455 void *pq_first_free_va;
|
|
|
1456 };
|
|
|
1457
|
|
|
1458 extern int SYS$GET_REGION_INFO (unsigned int, unsigned long long *,
|
|
|
1459 void *, void *, unsigned int,
|
|
|
1460 void *, unsigned int *);
|
|
|
1461 extern int SYS$EXPREG_64 (unsigned long long *, unsigned long long,
|
|
|
1462 unsigned int, unsigned int, void **,
|
|
|
1463 unsigned long long *);
|
|
|
1464 extern int SYS$SETPRT_64 (void *, unsigned long long, unsigned int,
|
|
|
1465 unsigned int, void **, unsigned long long *,
|
|
|
1466 unsigned int *);
|
|
|
1467
|
|
|
1468 /* Add a guard page in the memory region containing ADDR at ADDR +/- SIZE.
|
|
|
1469 (The sign depends on the kind of the memory region). */
|
|
|
1470
|
|
|
1471 static int
|
|
|
1472 __gnat_set_stack_guard_page (void *addr, unsigned long size)
|
|
|
1473 {
|
|
|
1474 int status;
|
|
|
1475 void *ret_va;
|
|
|
1476 unsigned long long ret_len;
|
|
|
1477 unsigned int ret_prot;
|
|
|
1478 void *start_va;
|
|
|
1479 unsigned long long length;
|
|
|
1480 unsigned int retlen;
|
|
|
1481 struct regsum buffer;
|
|
|
1482
|
|
|
1483 /* Get the region for ADDR. */
|
|
|
1484 status = SYS$GET_REGION_INFO
|
|
|
1485 (VA___REGSUM_BY_VA, NULL, addr, NULL, sizeof (buffer), &buffer, &retlen);
|
|
|
1486
|
|
|
1487 if ((status & 1) != 1)
|
|
|
1488 return -1;
|
|
|
1489
|
|
|
1490 /* Extend the region. */
|
|
|
1491 status = SYS$EXPREG_64 (&buffer.q_region_id,
|
|
|
1492 size, 0, 0, &start_va, &length);
|
|
|
1493
|
|
|
1494 if ((status & 1) != 1)
|
|
|
1495 return -1;
|
|
|
1496
|
|
|
1497 /* Create a guard page. */
|
|
|
1498 if (!(buffer.l_flags & VA__M_DESCEND))
|
|
|
1499 start_va = (void *)((unsigned long long)start_va + length - VMS_PAGESIZE);
|
|
|
1500
|
|
|
1501 status = SYS$SETPRT_64 (start_va, VMS_PAGESIZE, PSL__C_USER, PRT__C_NA,
|
|
|
1502 &ret_va, &ret_len, &ret_prot);
|
|
|
1503
|
|
|
1504 if ((status & 1) != 1)
|
|
|
1505 return -1;
|
|
|
1506 return 0;
|
|
|
1507 }
|
|
|
1508
|
|
|
1509 /* Read logicals to limit the stack(s) size. */
|
|
|
1510
|
|
|
1511 static void
|
|
|
1512 __gnat_set_stack_limit (void)
|
|
|
1513 {
|
|
|
1514 #ifdef __ia64__
|
|
|
1515 void *sp;
|
|
|
1516 unsigned long size;
|
|
|
1517 char value[16];
|
|
|
1518 char *e;
|
|
|
1519
|
|
|
1520 /* The main stack. */
|
|
|
1521 __gnat_vms_get_logical ("GNAT_STACK_SIZE", value, sizeof (value));
|
|
|
1522 size = strtoul (value, &e, 0);
|
|
|
1523 if (e > value && *e == 0)
|
|
|
1524 {
|
|
|
1525 asm ("mov %0=sp" : "=r" (sp));
|
|
|
1526 __gnat_set_stack_guard_page (sp, size * 1024);
|
|
|
1527 }
|
|
|
1528
|
|
|
1529 /* The register stack. */
|
|
|
1530 __gnat_vms_get_logical ("GNAT_RBS_SIZE", value, sizeof (value));
|
|
|
1531 size = strtoul (value, &e, 0);
|
|
|
1532 if (e > value && *e == 0)
|
|
|
1533 {
|
|
|
1534 asm ("mov %0=ar.bsp" : "=r" (sp));
|
|
|
1535 __gnat_set_stack_guard_page (sp, size * 1024);
|
|
|
1536 }
|
|
|
1537 #endif
|
|
|
1538 }
|
|
|
1539
|
|
|
1540 #ifdef IN_RTS
|
|
|
1541 extern int SYS$IEEE_SET_FP_CONTROL (void *, void *, void *);
|
|
|
1542 #define K_TRUE 1
|
|
|
1543 #define __int64 long long
|
|
|
1544 #define __NEW_STARLET
|
|
|
1545 #include <vms/ieeedef.h>
|
|
|
1546 #endif
|
|
|
1547
|
|
|
1548 /* Feature logical name and global variable address pair.
|
|
|
1549 If we ever add another feature logical to this list, the
|
|
|
1550 feature struct will need to be enhanced to take into account
|
|
|
1551 possible values for *gl_addr. */
|
|
|
1552 struct feature {
|
|
|
1553 const char *name;
|
|
|
1554 int *gl_addr;
|
|
|
1555 };
|
|
|
1556
|
|
|
1557 /* Default values for GNAT features set by environment or binder. */
|
|
|
1558 int __gl_heap_size = 64;
|
|
|
1559
|
|
|
1560 /* Default float format is 'I' meaning IEEE. If gnatbind detetcts that a
|
|
|
1561 VAX Float format is specified, it will set this global variable to 'V'.
|
|
|
1562 Subsequently __gnat_set_features will test the variable and if set for
|
|
|
1563 VAX Float will call a Starlet function to enable trapping for invalid
|
|
|
1564 operation, drivide by zero, and overflow. This will prevent the VMS runtime
|
|
|
1565 (specifically OTS$CHECK_FP_MODE) from complaining about inconsistent
|
|
|
1566 floating point settings in a mixed language program. Ideally the setting
|
|
145
|
1567 would be determined at link time based on settings in the object files,
|
|
111
|
1568 however the VMS linker seems to take the setting from the first object
|
|
|
1569 in the link, e.g. pcrt0.o which is float representation neutral. */
|
|
|
1570 char __gl_float_format = 'I';
|
|
|
1571
|
|
|
1572 /* Array feature logical names and global variable addresses. */
|
|
|
1573 static const struct feature features[] =
|
|
|
1574 {
|
|
|
1575 {"GNAT$NO_MALLOC_64", &__gl_heap_size},
|
|
|
1576 {0, 0}
|
|
|
1577 };
|
|
|
1578
|
|
|
1579 void
|
|
|
1580 __gnat_set_features (void)
|
|
|
1581 {
|
|
|
1582 int i;
|
|
|
1583 char buff[16];
|
|
|
1584 #ifdef IN_RTS
|
|
|
1585 IEEE clrmsk, setmsk, prvmsk;
|
|
|
1586
|
|
|
1587 clrmsk.ieee$q_flags = 0LL;
|
|
|
1588 setmsk.ieee$q_flags = 0LL;
|
|
|
1589 #endif
|
|
|
1590
|
|
|
1591 /* Loop through features array and test name for enable/disable. */
|
|
|
1592 for (i = 0; features[i].name; i++)
|
|
|
1593 {
|
|
|
1594 __gnat_vms_get_logical (features[i].name, buff, sizeof (buff));
|
|
|
1595
|
|
|
1596 if (strcmp (buff, "ENABLE") == 0
|
|
|
1597 || strcmp (buff, "TRUE") == 0
|
|
|
1598 || strcmp (buff, "1") == 0)
|
|
|
1599 *features[i].gl_addr = 32;
|
|
|
1600 else if (strcmp (buff, "DISABLE") == 0
|
|
|
1601 || strcmp (buff, "FALSE") == 0
|
|
|
1602 || strcmp (buff, "0") == 0)
|
|
|
1603 *features[i].gl_addr = 64;
|
|
|
1604 }
|
|
|
1605
|
|
|
1606 /* Features to artificially limit the stack size. */
|
|
|
1607 __gnat_set_stack_limit ();
|
|
|
1608
|
|
|
1609 #ifdef IN_RTS
|
|
|
1610 if (__gl_float_format == 'V')
|
|
|
1611 {
|
|
|
1612 setmsk.ieee$v_trap_enable_inv = K_TRUE;
|
|
|
1613 setmsk.ieee$v_trap_enable_dze = K_TRUE;
|
|
|
1614 setmsk.ieee$v_trap_enable_ovf = K_TRUE;
|
|
|
1615 SYS$IEEE_SET_FP_CONTROL (&clrmsk, &setmsk, &prvmsk);
|
|
|
1616 }
|
|
|
1617 #endif
|
|
|
1618
|
|
|
1619 __gnat_features_set = 1;
|
|
|
1620 }
|
|
|
1621
|
|
|
1622 /* Return true if the VMS version is 7.x. */
|
|
|
1623
|
|
|
1624 extern unsigned int LIB$GETSYI (int *, ...);
|
|
|
1625
|
|
|
1626 #define SYI$_VERSION 0x1000
|
|
|
1627
|
|
|
1628 int
|
|
|
1629 __gnat_is_vms_v7 (void)
|
|
|
1630 {
|
|
|
1631 struct descriptor_s desc;
|
|
|
1632 char version[8];
|
|
|
1633 int status;
|
|
|
1634 int code = SYI$_VERSION;
|
|
|
1635
|
|
|
1636 desc.len = sizeof (version);
|
|
|
1637 desc.mbz = 0;
|
|
|
1638 desc.adr = version;
|
|
|
1639
|
|
|
1640 status = LIB$GETSYI (&code, 0, &desc);
|
|
|
1641 if ((status & 1) == 1 && version[1] == '7' && version[2] == '.')
|
|
|
1642 return 1;
|
|
|
1643 else
|
|
|
1644 return 0;
|
|
|
1645 }
|
|
|
1646
|
|
|
1647 /*******************/
|
|
|
1648 /* FreeBSD Section */
|
|
|
1649 /*******************/
|
|
|
1650
|
|
|
1651 #elif defined (__FreeBSD__) || defined (__DragonFly__)
|
|
|
1652
|
|
|
1653 #include <signal.h>
|
|
|
1654 #include <sys/ucontext.h>
|
|
|
1655 #include <unistd.h>
|
|
|
1656
|
|
|
1657 static void
|
|
|
1658 __gnat_error_handler (int sig,
|
|
|
1659 siginfo_t *si ATTRIBUTE_UNUSED,
|
|
|
1660 void *ucontext ATTRIBUTE_UNUSED)
|
|
|
1661 {
|
|
|
1662 struct Exception_Data *exception;
|
|
|
1663 const char *msg;
|
|
|
1664
|
|
|
1665 switch (sig)
|
|
|
1666 {
|
|
|
1667 case SIGFPE:
|
|
|
1668 exception = &constraint_error;
|
|
|
1669 msg = "SIGFPE";
|
|
|
1670 break;
|
|
|
1671
|
|
|
1672 case SIGILL:
|
|
|
1673 exception = &constraint_error;
|
|
|
1674 msg = "SIGILL";
|
|
|
1675 break;
|
|
|
1676
|
|
|
1677 case SIGSEGV:
|
|
|
1678 exception = &storage_error;
|
|
|
1679 msg = "stack overflow or erroneous memory access";
|
|
|
1680 break;
|
|
|
1681
|
|
|
1682 case SIGBUS:
|
|
|
1683 exception = &storage_error;
|
|
|
1684 msg = "SIGBUS: possible stack overflow";
|
|
|
1685 break;
|
|
|
1686
|
|
|
1687 default:
|
|
|
1688 exception = &program_error;
|
|
|
1689 msg = "unhandled signal";
|
|
|
1690 }
|
|
|
1691
|
|
|
1692 Raise_From_Signal_Handler (exception, msg);
|
|
|
1693 }
|
|
|
1694
|
|
|
1695 void
|
|
|
1696 __gnat_install_handler (void)
|
|
|
1697 {
|
|
|
1698 struct sigaction act;
|
|
|
1699
|
|
|
1700 /* Set up signal handler to map synchronous signals to appropriate
|
|
|
1701 exceptions. Make sure that the handler isn't interrupted by another
|
|
|
1702 signal that might cause a scheduling event! */
|
|
|
1703
|
|
|
1704 act.sa_sigaction
|
|
|
1705 = (void (*)(int, struct __siginfo *, void*)) __gnat_error_handler;
|
|
|
1706 act.sa_flags = SA_NODEFER | SA_RESTART | SA_SIGINFO;
|
|
|
1707 (void) sigemptyset (&act.sa_mask);
|
|
|
1708
|
|
|
1709 (void) sigaction (SIGILL, &act, NULL);
|
|
|
1710 (void) sigaction (SIGFPE, &act, NULL);
|
|
|
1711 (void) sigaction (SIGSEGV, &act, NULL);
|
|
|
1712 (void) sigaction (SIGBUS, &act, NULL);
|
|
|
1713
|
|
|
1714 __gnat_handler_installed = 1;
|
|
|
1715 }
|
|
|
1716
|
|
|
1717 /*************************************/
|
|
|
1718 /* VxWorks Section (including Vx653) */
|
|
|
1719 /*************************************/
|
|
|
1720
|
|
|
1721 #elif defined(__vxworks)
|
|
|
1722
|
|
|
1723 #include <signal.h>
|
|
|
1724 #include <taskLib.h>
|
|
|
1725 #if (defined (__i386__) || defined (__x86_64__)) && !defined (VTHREADS)
|
|
|
1726 #include <sysLib.h>
|
|
|
1727 #endif
|
|
|
1728
|
|
|
1729 #include "sigtramp.h"
|
|
|
1730
|
|
|
1731 #ifndef __RTP__
|
|
|
1732 #include <intLib.h>
|
|
|
1733 #include <iv.h>
|
|
|
1734 #endif
|
|
|
1735
|
|
145
|
1736 #if ((defined (ARMEL) && (_WRS_VXWORKS_MAJOR == 6))) && !defined(__RTP__)
|
|
111
|
1737 #define VXWORKS_FORCE_GUARD_PAGE 1
|
|
|
1738 #include <vmLib.h>
|
|
|
1739 extern size_t vxIntStackOverflowSize;
|
|
|
1740 #define INT_OVERFLOW_SIZE vxIntStackOverflowSize
|
|
|
1741 #endif
|
|
|
1742
|
|
|
1743 #ifdef VTHREADS
|
|
|
1744 #include "private/vThreadsP.h"
|
|
|
1745 #endif
|
|
|
1746
|
|
|
1747 #ifndef __RTP__
|
|
|
1748
|
|
|
1749 /* Directly vectored Interrupt routines are not supported when using RTPs. */
|
|
|
1750
|
|
|
1751 extern void * __gnat_inum_to_ivec (int);
|
|
|
1752
|
|
|
1753 /* This is needed by the GNAT run time to handle Vxworks interrupts. */
|
|
|
1754 void *
|
|
|
1755 __gnat_inum_to_ivec (int num)
|
|
|
1756 {
|
|
|
1757 return (void *) INUM_TO_IVEC (num);
|
|
|
1758 }
|
|
|
1759 #endif
|
|
|
1760
|
|
|
1761 #if !defined(__alpha_vxworks) && ((_WRS_VXWORKS_MAJOR != 6) && (_WRS_VXWORKS_MAJOR != 7)) && !defined(__RTP__)
|
|
|
1762
|
|
|
1763 /* getpid is used by s-parint.adb, but is not defined by VxWorks, except
|
|
|
1764 on Alpha VxWorks and VxWorks 6.x (including RTPs). */
|
|
|
1765
|
|
|
1766 extern long getpid (void);
|
|
|
1767
|
|
|
1768 long
|
|
|
1769 getpid (void)
|
|
|
1770 {
|
|
|
1771 return taskIdSelf ();
|
|
|
1772 }
|
|
|
1773 #endif
|
|
|
1774
|
|
|
1775 /* When stack checking is performed by probing a guard page on the stack,
|
|
|
1776 sometimes this guard page is not properly reset on VxWorks. We need to
|
|
|
1777 manually reset it in this case.
|
|
|
1778 This function returns TRUE in case the guard page was hit by the
|
|
|
1779 signal. */
|
|
|
1780 static int
|
|
|
1781 __gnat_reset_guard_page (int sig)
|
|
|
1782 {
|
|
|
1783 /* On ARM VxWorks 6.x and x86_64 VxWorks 7, the guard page is left un-armed
|
|
|
1784 by the kernel after being violated, so subsequent violations aren't
|
|
|
1785 detected.
|
|
|
1786 So we retrieve the address of the guard page from the TCB and compare it
|
|
|
1787 with the page that is violated and re-arm that page if there's a match. */
|
|
|
1788 #if defined (VXWORKS_FORCE_GUARD_PAGE)
|
|
|
1789
|
|
|
1790 /* Ignore signals that are not stack overflow signals */
|
|
|
1791 if (sig != SIGSEGV && sig != SIGBUS && sig != SIGILL) return FALSE;
|
|
|
1792
|
|
|
1793 /* If the target does not support guard pages, INT_OVERFLOW_SIZE will be 0 */
|
|
|
1794 if (INT_OVERFLOW_SIZE == 0) return FALSE;
|
|
|
1795
|
|
|
1796 TASK_ID tid = taskIdSelf ();
|
|
|
1797 WIND_TCB *pTcb = taskTcb (tid);
|
|
|
1798 VIRT_ADDR guardPage = (VIRT_ADDR) pTcb->pStackEnd - INT_OVERFLOW_SIZE;
|
|
|
1799 UINT stateMask = VM_STATE_MASK_VALID;
|
|
|
1800 UINT guardState = VM_STATE_VALID_NOT;
|
|
|
1801
|
|
|
1802 #if (_WRS_VXWORKS_MAJOR >= 7)
|
|
|
1803 stateMask |= MMU_ATTR_SPL_MSK;
|
|
|
1804 guardState |= MMU_ATTR_NO_BLOCK;
|
|
|
1805 #endif
|
|
|
1806
|
|
|
1807 UINT nState;
|
|
|
1808 vmStateGet (NULL, guardPage, &nState);
|
|
|
1809 if ((nState & VM_STATE_MASK_VALID) != VM_STATE_VALID_NOT)
|
|
|
1810 {
|
|
|
1811 /* If the guard page has a valid state, we need to reset to
|
|
|
1812 invalid state here */
|
|
|
1813 vmStateSet (NULL, guardPage, INT_OVERFLOW_SIZE, stateMask, guardState);
|
|
|
1814 return TRUE;
|
|
|
1815 }
|
|
|
1816 #endif /* VXWORKS_FORCE_GUARD_PAGE */
|
|
|
1817 return FALSE;
|
|
|
1818 }
|
|
|
1819
|
|
|
1820 /* VxWorks 653 vThreads expects the field excCnt to be zeroed when a signal is.
|
|
|
1821 handled. The VxWorks version of longjmp does this; GCC's builtin_longjmp
|
|
|
1822 doesn't. */
|
|
|
1823 void
|
|
|
1824 __gnat_clear_exception_count (void)
|
|
|
1825 {
|
|
|
1826 #ifdef VTHREADS
|
|
|
1827 WIND_TCB *currentTask = (WIND_TCB *) taskIdSelf();
|
|
|
1828
|
|
|
1829 currentTask->vThreads.excCnt = 0;
|
|
|
1830 #endif
|
|
|
1831 }
|
|
|
1832
|
|
|
1833 /* Handle different SIGnal to exception mappings in different VxWorks
|
|
|
1834 versions. */
|
|
|
1835 void
|
|
|
1836 __gnat_map_signal (int sig,
|
|
|
1837 siginfo_t *si ATTRIBUTE_UNUSED,
|
|
|
1838 void *sc ATTRIBUTE_UNUSED)
|
|
|
1839 {
|
|
|
1840 struct Exception_Data *exception;
|
|
|
1841 const char *msg;
|
|
|
1842
|
|
|
1843 switch (sig)
|
|
|
1844 {
|
|
|
1845 case SIGFPE:
|
|
|
1846 exception = &constraint_error;
|
|
|
1847 msg = "SIGFPE";
|
|
|
1848 break;
|
|
|
1849 #ifdef VTHREADS
|
|
|
1850 #ifdef __VXWORKSMILS__
|
|
|
1851 case SIGILL:
|
|
|
1852 exception = &storage_error;
|
|
|
1853 msg = "SIGILL: possible stack overflow";
|
|
|
1854 break;
|
|
|
1855 case SIGSEGV:
|
|
|
1856 exception = &storage_error;
|
|
|
1857 msg = "SIGSEGV";
|
|
|
1858 break;
|
|
|
1859 case SIGBUS:
|
|
|
1860 exception = &program_error;
|
|
|
1861 msg = "SIGBUS";
|
|
|
1862 break;
|
|
|
1863 #else
|
|
|
1864 case SIGILL:
|
|
|
1865 exception = &constraint_error;
|
|
|
1866 msg = "Floating point exception or SIGILL";
|
|
|
1867 break;
|
|
|
1868 case SIGSEGV:
|
|
|
1869 exception = &storage_error;
|
|
|
1870 msg = "SIGSEGV";
|
|
|
1871 break;
|
|
|
1872 case SIGBUS:
|
|
|
1873 exception = &storage_error;
|
|
|
1874 msg = "SIGBUS: possible stack overflow";
|
|
|
1875 break;
|
|
|
1876 #endif
|
|
|
1877 #elif (_WRS_VXWORKS_MAJOR >= 6)
|
|
|
1878 case SIGILL:
|
|
|
1879 exception = &constraint_error;
|
|
|
1880 msg = "SIGILL";
|
|
|
1881 break;
|
|
|
1882 #ifdef __RTP__
|
|
|
1883 /* In RTP mode a SIGSEGV is most likely due to a stack overflow,
|
|
|
1884 since stack checking uses the probing mechanism. */
|
|
|
1885 case SIGSEGV:
|
|
|
1886 exception = &storage_error;
|
|
|
1887 msg = "SIGSEGV: possible stack overflow";
|
|
|
1888 break;
|
|
|
1889 case SIGBUS:
|
|
|
1890 exception = &program_error;
|
|
|
1891 msg = "SIGBUS";
|
|
|
1892 break;
|
|
|
1893 #else
|
|
|
1894 /* VxWorks 6 kernel mode with probing. SIGBUS for guard page hit */
|
|
|
1895 case SIGSEGV:
|
|
|
1896 exception = &storage_error;
|
|
|
1897 msg = "SIGSEGV";
|
|
|
1898 break;
|
|
|
1899 case SIGBUS:
|
|
|
1900 exception = &storage_error;
|
|
|
1901 msg = "SIGBUS: possible stack overflow";
|
|
|
1902 break;
|
|
|
1903 #endif
|
|
|
1904 #else
|
|
|
1905 /* VxWorks 5: a SIGILL is most likely due to a stack overflow,
|
|
|
1906 since stack checking uses the stack limit mechanism. */
|
|
|
1907 case SIGILL:
|
|
|
1908 exception = &storage_error;
|
|
|
1909 msg = "SIGILL: possible stack overflow";
|
|
|
1910 break;
|
|
|
1911 case SIGSEGV:
|
|
|
1912 exception = &storage_error;
|
|
|
1913 msg = "SIGSEGV";
|
|
|
1914 break;
|
|
|
1915 case SIGBUS:
|
|
|
1916 exception = &program_error;
|
|
|
1917 msg = "SIGBUS";
|
|
|
1918 break;
|
|
|
1919 #endif
|
|
|
1920 default:
|
|
|
1921 exception = &program_error;
|
|
|
1922 msg = "unhandled signal";
|
|
|
1923 }
|
|
|
1924
|
|
|
1925 if (__gnat_reset_guard_page (sig))
|
|
|
1926 {
|
|
|
1927 /* Set the exception message: we know for sure that we have a
|
|
|
1928 stack overflow here */
|
|
|
1929 exception = &storage_error;
|
|
|
1930
|
|
|
1931 switch (sig)
|
|
|
1932 {
|
|
|
1933 case SIGSEGV:
|
|
|
1934 msg = "SIGSEGV: stack overflow";
|
|
|
1935 break;
|
|
|
1936 case SIGBUS:
|
|
|
1937 msg = "SIGBUS: stack overflow";
|
|
|
1938 break;
|
|
|
1939 case SIGILL:
|
|
|
1940 msg = "SIGILL: stack overflow";
|
|
|
1941 break;
|
|
|
1942 }
|
|
|
1943 }
|
|
|
1944 __gnat_clear_exception_count ();
|
|
|
1945 Raise_From_Signal_Handler (exception, msg);
|
|
|
1946 }
|
|
|
1947
|
|
131
|
1948 #if defined (ARMEL) && (_WRS_VXWORKS_MAJOR >= 7) && !defined (__aarch64__)
|
|
111
|
1949
|
|
|
1950 /* ARM-vx7 case with arm unwinding exceptions */
|
|
|
1951 #define HAVE_GNAT_ADJUST_CONTEXT_FOR_RAISE
|
|
|
1952
|
|
|
1953 #include <arch/../regs.h>
|
|
|
1954 #ifndef __RTP__
|
|
|
1955 #include <sigLib.h>
|
|
|
1956 #else
|
|
|
1957 #include <signal.h>
|
|
|
1958 #include <regs.h>
|
|
|
1959 #include <ucontext.h>
|
|
|
1960 #endif /* __RTP__ */
|
|
|
1961
|
|
|
1962 void
|
|
|
1963 __gnat_adjust_context_for_raise (int signo ATTRIBUTE_UNUSED,
|
|
|
1964 void *sc ATTRIBUTE_UNUSED)
|
|
|
1965 {
|
|
|
1966 /* In case of ARM exceptions, the registers context have the PC pointing
|
|
|
1967 to the instruction that raised the signal. However the unwinder expects
|
|
|
1968 the instruction to be in the range ]PC,PC+1]. */
|
|
|
1969 uintptr_t *pc_addr;
|
|
|
1970 #ifdef __RTP__
|
|
|
1971 mcontext_t *mcontext = &((ucontext_t *) sc)->uc_mcontext;
|
|
|
1972 pc_addr = (uintptr_t*)&mcontext->regs.pc;
|
|
|
1973 #else
|
|
|
1974 struct sigcontext * sctx = (struct sigcontext *) sc;
|
|
|
1975 pc_addr = (uintptr_t*)&sctx->sc_pregs->pc;
|
|
|
1976 #endif
|
|
|
1977 /* ARM Bump has to be an even number because of odd/even architecture. */
|
|
|
1978 *pc_addr += 2;
|
|
|
1979 }
|
|
|
1980 #endif /* ARMEL && _WRS_VXWORKS_MAJOR >= 7 */
|
|
|
1981
|
|
|
1982 /* Tasking and Non-tasking signal handler. Map SIGnal to Ada exception
|
|
|
1983 propagation after the required low level adjustments. */
|
|
|
1984
|
|
|
1985 static void
|
|
|
1986 __gnat_error_handler (int sig, siginfo_t *si, void *sc)
|
|
|
1987 {
|
|
|
1988 sigset_t mask;
|
|
|
1989
|
|
|
1990 /* VxWorks on e500v2 clears the SPE bit of the MSR when entering CPU
|
|
|
1991 exception state. To allow the handler and exception to work properly
|
|
|
1992 when they contain SPE instructions, we need to set it back before doing
|
|
|
1993 anything else.
|
|
|
1994 This mechanism is only need in kernel mode. */
|
|
|
1995 #if !(defined (__RTP__) || defined (VTHREADS)) && ((CPU == PPCE500V2) || (CPU == PPC85XX))
|
|
|
1996 register unsigned msr;
|
|
|
1997 /* Read the MSR value */
|
|
|
1998 asm volatile ("mfmsr %0" : "=r" (msr));
|
|
|
1999 /* Force the SPE bit if not set. */
|
|
|
2000 if ((msr & 0x02000000) == 0)
|
|
|
2001 {
|
|
|
2002 msr |= 0x02000000;
|
|
|
2003 /* Store to MSR */
|
|
|
2004 asm volatile ("mtmsr %0" : : "r" (msr));
|
|
|
2005 }
|
|
|
2006 #endif
|
|
|
2007
|
|
|
2008 /* VxWorks will always mask out the signal during the signal handler and
|
|
|
2009 will reenable it on a longjmp. GNAT does not generate a longjmp to
|
|
|
2010 return from a signal handler so the signal will still be masked unless
|
|
|
2011 we unmask it. */
|
|
|
2012 sigprocmask (SIG_SETMASK, NULL, &mask);
|
|
|
2013 sigdelset (&mask, sig);
|
|
|
2014 sigprocmask (SIG_SETMASK, &mask, NULL);
|
|
|
2015
|
|
131
|
2016 #if defined (__ARMEL__) || defined (__PPC__) || defined (__i386__) || defined (__x86_64__) || defined (__aarch64__)
|
|
111
|
2017 /* On certain targets, kernel mode, we process signals through a Call Frame
|
|
|
2018 Info trampoline, voiding the need for myriads of fallback_frame_state
|
|
|
2019 variants in the ZCX runtime. We have no simple way to distinguish ZCX
|
|
|
2020 from SJLJ here, so we do this for SJLJ as well even though this is not
|
|
|
2021 necessary. This only incurs a few extra instructions and a tiny
|
|
|
2022 amount of extra stack usage. */
|
|
|
2023
|
|
|
2024 #ifdef HAVE_GNAT_ADJUST_CONTEXT_FOR_RAISE
|
|
|
2025 /* We need to sometimes to adjust the PC in case of signals so that it
|
|
|
2026 doesn't reference the exception that actually raised the signal but the
|
|
|
2027 instruction before it. */
|
|
|
2028 __gnat_adjust_context_for_raise (sig, sc);
|
|
|
2029 #endif
|
|
|
2030
|
|
|
2031 __gnat_sigtramp (sig, (void *)si, (void *)sc,
|
|
|
2032 (__sigtramphandler_t *)&__gnat_map_signal);
|
|
|
2033
|
|
|
2034 #else
|
|
|
2035 __gnat_map_signal (sig, si, sc);
|
|
|
2036 #endif
|
|
|
2037 }
|
|
|
2038
|
|
|
2039 #if defined(__leon__) && defined(_WRS_KERNEL)
|
|
|
2040 /* For LEON VxWorks we need to install a trap handler for stack overflow */
|
|
|
2041
|
|
|
2042 extern void excEnt (void);
|
|
|
2043 /* VxWorks exception handler entry */
|
|
|
2044
|
|
|
2045 struct trap_entry {
|
|
|
2046 unsigned long inst_first;
|
|
|
2047 unsigned long inst_second;
|
|
|
2048 unsigned long inst_third;
|
|
|
2049 unsigned long inst_fourth;
|
|
|
2050 };
|
|
|
2051 /* Four instructions representing entries in the trap table */
|
|
|
2052
|
|
|
2053 struct trap_entry *trap_0_entry;
|
|
|
2054 /* We will set the location of the entry for software trap 0 in the trap
|
|
|
2055 table. */
|
|
|
2056 #endif
|
|
|
2057
|
|
|
2058 void
|
|
|
2059 __gnat_install_handler (void)
|
|
|
2060 {
|
|
|
2061 struct sigaction act;
|
|
|
2062
|
|
|
2063 /* Setup signal handler to map synchronous signals to appropriate
|
|
|
2064 exceptions. Make sure that the handler isn't interrupted by another
|
|
|
2065 signal that might cause a scheduling event! */
|
|
|
2066
|
|
|
2067 act.sa_sigaction = __gnat_error_handler;
|
|
|
2068 act.sa_flags = SA_SIGINFO | SA_ONSTACK;
|
|
|
2069 sigemptyset (&act.sa_mask);
|
|
|
2070
|
|
|
2071 /* For VxWorks, install all signal handlers, since pragma Interrupt_State
|
|
|
2072 applies to vectored hardware interrupts, not signals. */
|
|
|
2073 sigaction (SIGFPE, &act, NULL);
|
|
|
2074 sigaction (SIGILL, &act, NULL);
|
|
|
2075 sigaction (SIGSEGV, &act, NULL);
|
|
|
2076 sigaction (SIGBUS, &act, NULL);
|
|
|
2077
|
|
|
2078 #if defined(__leon__) && defined(_WRS_KERNEL)
|
|
|
2079 /* Specific to the LEON VxWorks kernel run-time library */
|
|
|
2080
|
|
|
2081 /* For stack checking the compiler triggers a software trap 0 (ta 0) in
|
|
|
2082 case of overflow (we use the stack limit mechanism). We need to install
|
|
|
2083 the trap handler here for this software trap (the OS does not handle
|
|
|
2084 it) as if it were a data_access_exception (trap 9). We do the same as
|
|
|
2085 if we put in the trap table a VXSPARC_BAD_TRAP(9). Software trap 0 is
|
|
|
2086 located at vector 0x80, and each entry takes 4 words. */
|
|
|
2087
|
|
|
2088 trap_0_entry = (struct trap_entry *)(intVecBaseGet () + 0x80 * 4);
|
|
|
2089
|
|
|
2090 /* mov 0x9, %l7 */
|
|
|
2091
|
|
|
2092 trap_0_entry->inst_first = 0xae102000 + 9;
|
|
|
2093
|
|
|
2094 /* sethi %hi(excEnt), %l6 */
|
|
|
2095
|
|
|
2096 /* The 22 most significant bits of excEnt are obtained shifting 10 times
|
|
|
2097 to the right. */
|
|
|
2098
|
|
|
2099 trap_0_entry->inst_second = 0x2d000000 + ((unsigned long)excEnt >> 10);
|
|
|
2100
|
|
|
2101 /* jmp %l6+%lo(excEnt) */
|
|
|
2102
|
|
|
2103 /* The 10 least significant bits of excEnt are obtained by masking */
|
|
|
2104
|
|
|
2105 trap_0_entry->inst_third = 0x81c5a000 + ((unsigned long)excEnt & 0x3ff);
|
|
|
2106
|
|
|
2107 /* rd %psr, %l0 */
|
|
|
2108
|
|
|
2109 trap_0_entry->inst_fourth = 0xa1480000;
|
|
|
2110 #endif
|
|
|
2111
|
|
|
2112 #ifdef __HANDLE_VXSIM_SC
|
|
|
2113 /* By experiment, found that sysModel () returns the following string
|
|
|
2114 prefix for vxsim when running on Linux and Windows. */
|
|
|
2115 {
|
|
|
2116 char *model = sysModel ();
|
|
|
2117 if ((strncmp (model, "Linux", 5) == 0)
|
|
|
2118 || (strncmp (model, "Windows", 7) == 0)
|
|
|
2119 || (strncmp (model, "SIMLINUX", 8) == 0) /* vx7 */
|
|
|
2120 || (strncmp (model, "SIMNT", 5) == 0)) /* ditto */
|
|
|
2121 __gnat_set_is_vxsim (TRUE);
|
|
|
2122 }
|
|
|
2123 #endif
|
|
|
2124
|
|
|
2125 __gnat_handler_installed = 1;
|
|
|
2126 }
|
|
|
2127
|
|
|
2128 #define HAVE_GNAT_INIT_FLOAT
|
|
|
2129
|
|
|
2130 void
|
|
|
2131 __gnat_init_float (void)
|
|
|
2132 {
|
|
|
2133 /* Disable overflow/underflow exceptions on the PPC processor, needed
|
|
|
2134 to get correct Ada semantics. Note that for AE653 vThreads, the HW
|
|
|
2135 overflow settings are an OS configuration issue. The instructions
|
|
|
2136 below have no effect. */
|
|
|
2137 #if defined (_ARCH_PPC) && !defined (_SOFT_FLOAT) && (!defined (VTHREADS) || defined (__VXWORKSMILS__))
|
|
|
2138 #if defined (__SPE__)
|
|
|
2139 {
|
|
|
2140 /* For e500v2, do nothing and leave the responsibility to install the
|
|
|
2141 handler and enable the exceptions to the BSP. */
|
|
|
2142 }
|
|
|
2143 #else
|
|
|
2144 asm ("mtfsb0 25");
|
|
|
2145 asm ("mtfsb0 26");
|
|
|
2146 #endif
|
|
|
2147 #endif
|
|
|
2148
|
|
|
2149 #if (defined (__i386__) || defined (__x86_64__)) && !defined (VTHREADS)
|
|
|
2150 /* This is used to properly initialize the FPU on an x86 for each
|
|
|
2151 process thread. */
|
|
|
2152 asm ("finit");
|
|
|
2153 #endif
|
|
|
2154
|
|
|
2155 /* Similarly for SPARC64. Achieved by masking bits in the Trap Enable Mask
|
|
|
2156 field of the Floating-point Status Register (see the SPARC Architecture
|
|
|
2157 Manual Version 9, p 48). */
|
|
|
2158 #if defined (sparc64)
|
|
|
2159
|
|
|
2160 #define FSR_TEM_NVM (1 << 27) /* Invalid operand */
|
|
|
2161 #define FSR_TEM_OFM (1 << 26) /* Overflow */
|
|
|
2162 #define FSR_TEM_UFM (1 << 25) /* Underflow */
|
|
|
2163 #define FSR_TEM_DZM (1 << 24) /* Division by Zero */
|
|
|
2164 #define FSR_TEM_NXM (1 << 23) /* Inexact result */
|
|
|
2165 {
|
|
|
2166 unsigned int fsr;
|
|
|
2167
|
|
|
2168 __asm__("st %%fsr, %0" : "=m" (fsr));
|
|
|
2169 fsr &= ~(FSR_TEM_OFM | FSR_TEM_UFM);
|
|
|
2170 __asm__("ld %0, %%fsr" : : "m" (fsr));
|
|
|
2171 }
|
|
|
2172 #endif
|
|
|
2173 }
|
|
|
2174
|
|
|
2175 /* This subprogram is called by System.Task_Primitives.Operations.Enter_Task
|
|
|
2176 (if not null) when a new task is created. It is initialized by
|
|
|
2177 System.Stack_Checking.Operations.Initialize_Stack_Limit.
|
|
|
2178 The use of a hook avoids to drag stack checking subprograms if stack
|
|
|
2179 checking is not used. */
|
|
|
2180 void (*__gnat_set_stack_limit_hook)(void) = (void (*)(void))0;
|
|
|
2181
|
|
|
2182 /******************/
|
|
|
2183 /* NetBSD Section */
|
|
|
2184 /******************/
|
|
|
2185
|
|
|
2186 #elif defined(__NetBSD__)
|
|
|
2187
|
|
|
2188 #include <signal.h>
|
|
|
2189 #include <unistd.h>
|
|
|
2190
|
|
|
2191 static void
|
|
|
2192 __gnat_error_handler (int sig)
|
|
|
2193 {
|
|
|
2194 struct Exception_Data *exception;
|
|
|
2195 const char *msg;
|
|
|
2196
|
|
|
2197 switch(sig)
|
|
|
2198 {
|
|
|
2199 case SIGFPE:
|
|
|
2200 exception = &constraint_error;
|
|
|
2201 msg = "SIGFPE";
|
|
|
2202 break;
|
|
|
2203 case SIGILL:
|
|
|
2204 exception = &constraint_error;
|
|
|
2205 msg = "SIGILL";
|
|
|
2206 break;
|
|
|
2207 case SIGSEGV:
|
|
|
2208 exception = &storage_error;
|
|
|
2209 msg = "stack overflow or erroneous memory access";
|
|
|
2210 break;
|
|
|
2211 case SIGBUS:
|
|
|
2212 exception = &constraint_error;
|
|
|
2213 msg = "SIGBUS";
|
|
|
2214 break;
|
|
|
2215 default:
|
|
|
2216 exception = &program_error;
|
|
|
2217 msg = "unhandled signal";
|
|
|
2218 }
|
|
|
2219
|
|
|
2220 Raise_From_Signal_Handler (exception, msg);
|
|
|
2221 }
|
|
|
2222
|
|
|
2223 void
|
|
|
2224 __gnat_install_handler (void)
|
|
|
2225 {
|
|
|
2226 struct sigaction act;
|
|
|
2227
|
|
|
2228 act.sa_handler = __gnat_error_handler;
|
|
|
2229 act.sa_flags = SA_NODEFER | SA_RESTART;
|
|
|
2230 sigemptyset (&act.sa_mask);
|
|
|
2231
|
|
|
2232 /* Do not install handlers if interrupt state is "System". */
|
|
|
2233 if (__gnat_get_interrupt_state (SIGFPE) != 's')
|
|
|
2234 sigaction (SIGFPE, &act, NULL);
|
|
|
2235 if (__gnat_get_interrupt_state (SIGILL) != 's')
|
|
|
2236 sigaction (SIGILL, &act, NULL);
|
|
|
2237 if (__gnat_get_interrupt_state (SIGSEGV) != 's')
|
|
|
2238 sigaction (SIGSEGV, &act, NULL);
|
|
|
2239 if (__gnat_get_interrupt_state (SIGBUS) != 's')
|
|
|
2240 sigaction (SIGBUS, &act, NULL);
|
|
|
2241
|
|
|
2242 __gnat_handler_installed = 1;
|
|
|
2243 }
|
|
|
2244
|
|
|
2245 /*******************/
|
|
|
2246 /* OpenBSD Section */
|
|
|
2247 /*******************/
|
|
|
2248
|
|
|
2249 #elif defined(__OpenBSD__)
|
|
|
2250
|
|
|
2251 #include <signal.h>
|
|
|
2252 #include <unistd.h>
|
|
|
2253
|
|
|
2254 static void
|
|
|
2255 __gnat_error_handler (int sig)
|
|
|
2256 {
|
|
|
2257 struct Exception_Data *exception;
|
|
|
2258 const char *msg;
|
|
|
2259
|
|
|
2260 switch(sig)
|
|
|
2261 {
|
|
|
2262 case SIGFPE:
|
|
|
2263 exception = &constraint_error;
|
|
|
2264 msg = "SIGFPE";
|
|
|
2265 break;
|
|
|
2266 case SIGILL:
|
|
|
2267 exception = &constraint_error;
|
|
|
2268 msg = "SIGILL";
|
|
|
2269 break;
|
|
|
2270 case SIGSEGV:
|
|
|
2271 exception = &storage_error;
|
|
|
2272 msg = "stack overflow or erroneous memory access";
|
|
|
2273 break;
|
|
|
2274 case SIGBUS:
|
|
|
2275 exception = &constraint_error;
|
|
|
2276 msg = "SIGBUS";
|
|
|
2277 break;
|
|
|
2278 default:
|
|
|
2279 exception = &program_error;
|
|
|
2280 msg = "unhandled signal";
|
|
|
2281 }
|
|
|
2282
|
|
|
2283 Raise_From_Signal_Handler (exception, msg);
|
|
|
2284 }
|
|
|
2285
|
|
|
2286 void
|
|
|
2287 __gnat_install_handler (void)
|
|
|
2288 {
|
|
|
2289 struct sigaction act;
|
|
|
2290
|
|
|
2291 act.sa_handler = __gnat_error_handler;
|
|
|
2292 act.sa_flags = SA_NODEFER | SA_RESTART;
|
|
|
2293 sigemptyset (&act.sa_mask);
|
|
|
2294
|
|
|
2295 /* Do not install handlers if interrupt state is "System" */
|
|
|
2296 if (__gnat_get_interrupt_state (SIGFPE) != 's')
|
|
|
2297 sigaction (SIGFPE, &act, NULL);
|
|
|
2298 if (__gnat_get_interrupt_state (SIGILL) != 's')
|
|
|
2299 sigaction (SIGILL, &act, NULL);
|
|
|
2300 if (__gnat_get_interrupt_state (SIGSEGV) != 's')
|
|
|
2301 sigaction (SIGSEGV, &act, NULL);
|
|
|
2302 if (__gnat_get_interrupt_state (SIGBUS) != 's')
|
|
|
2303 sigaction (SIGBUS, &act, NULL);
|
|
|
2304
|
|
|
2305 __gnat_handler_installed = 1;
|
|
|
2306 }
|
|
|
2307
|
|
|
2308 /******************/
|
|
|
2309 /* Darwin Section */
|
|
|
2310 /******************/
|
|
|
2311
|
|
|
2312 #elif defined(__APPLE__)
|
|
|
2313
|
|
|
2314 #include <TargetConditionals.h>
|
|
|
2315 #include <signal.h>
|
|
|
2316 #include <stdlib.h>
|
|
|
2317 #include <sys/syscall.h>
|
|
|
2318 #include <sys/sysctl.h>
|
|
|
2319
|
|
|
2320 /* This must be in keeping with System.OS_Interface.Alternate_Stack_Size. */
|
|
|
2321 char __gnat_alternate_stack[32 * 1024]; /* 1 * MINSIGSTKSZ */
|
|
|
2322
|
|
|
2323 /* Defined in xnu unix_signal.c.
|
|
|
2324 Tell the kernel to re-use alt stack when delivering a signal. */
|
|
|
2325 #define UC_RESET_ALT_STACK 0x80000000
|
|
|
2326
|
|
|
2327 #if !(defined (__arm__) || defined (__arm64__) || TARGET_IPHONE_SIMULATOR)
|
|
|
2328 #include <mach/mach_vm.h>
|
|
|
2329 #include <mach/mach_init.h>
|
|
|
2330 #include <mach/vm_statistics.h>
|
|
|
2331 #endif
|
|
|
2332
|
|
|
2333 #ifdef __arm64__
|
|
|
2334 #include <sys/ucontext.h>
|
|
|
2335 #include "sigtramp.h"
|
|
|
2336 #endif
|
|
|
2337
|
|
|
2338 /* Return true if ADDR is within a stack guard area. */
|
|
|
2339 static int
|
|
|
2340 __gnat_is_stack_guard (mach_vm_address_t addr)
|
|
|
2341 {
|
|
|
2342 #if !(defined (__arm__) || defined (__arm64__) || TARGET_IPHONE_SIMULATOR)
|
|
|
2343 kern_return_t kret;
|
|
|
2344 vm_region_submap_info_data_64_t info;
|
|
|
2345 mach_vm_address_t start;
|
|
|
2346 mach_vm_size_t size;
|
|
|
2347 natural_t depth;
|
|
|
2348 mach_msg_type_number_t count;
|
|
|
2349
|
|
|
2350 count = VM_REGION_SUBMAP_INFO_COUNT_64;
|
|
|
2351 start = addr;
|
|
|
2352 size = -1;
|
|
|
2353 depth = 9999;
|
|
|
2354 kret = mach_vm_region_recurse (mach_task_self (), &start, &size, &depth,
|
|
|
2355 (vm_region_recurse_info_t) &info, &count);
|
|
|
2356 if (kret == KERN_SUCCESS
|
|
|
2357 && addr >= start && addr < (start + size)
|
|
|
2358 && info.protection == VM_PROT_NONE
|
|
|
2359 && info.user_tag == VM_MEMORY_STACK)
|
|
|
2360 return 1;
|
|
|
2361 return 0;
|
|
|
2362 #else
|
|
|
2363 /* Pagezero for arm. */
|
|
|
2364 return addr >= 4096;
|
|
|
2365 #endif
|
|
|
2366 }
|
|
|
2367
|
|
|
2368 #define HAVE_GNAT_ADJUST_CONTEXT_FOR_RAISE
|
|
|
2369
|
|
|
2370 #if defined (__x86_64__)
|
|
|
2371 static int
|
|
|
2372 __darwin_major_version (void)
|
|
|
2373 {
|
|
|
2374 static int cache = -1;
|
|
|
2375 if (cache < 0)
|
|
|
2376 {
|
|
|
2377 int mib[2] = {CTL_KERN, KERN_OSRELEASE};
|
|
|
2378 size_t len;
|
|
|
2379
|
|
|
2380 /* Find out how big the buffer needs to be (and set cache to 0
|
|
|
2381 on failure). */
|
|
|
2382 if (sysctl (mib, 2, NULL, &len, NULL, 0) == 0)
|
|
|
2383 {
|
|
|
2384 char release[len];
|
|
|
2385 sysctl (mib, 2, release, &len, NULL, 0);
|
|
|
2386 /* Darwin releases are of the form L.M.N where L is the major
|
|
|
2387 version, so strtol will return L. */
|
|
|
2388 cache = (int) strtol (release, NULL, 10);
|
|
|
2389 }
|
|
|
2390 else
|
|
|
2391 {
|
|
|
2392 cache = 0;
|
|
|
2393 }
|
|
|
2394 }
|
|
|
2395 return cache;
|
|
|
2396 }
|
|
|
2397 #endif
|
|
|
2398
|
|
|
2399 void
|
|
|
2400 __gnat_adjust_context_for_raise (int signo ATTRIBUTE_UNUSED,
|
|
|
2401 void *ucontext ATTRIBUTE_UNUSED)
|
|
|
2402 {
|
|
|
2403 #if defined (__x86_64__)
|
|
|
2404 if (__darwin_major_version () < 12)
|
|
|
2405 {
|
|
|
2406 /* Work around radar #10302855, where the unwinders (libunwind or
|
|
|
2407 libgcc_s depending on the system revision) and the DWARF unwind
|
|
|
2408 data for sigtramp have different ideas about register numbering,
|
|
|
2409 causing rbx and rdx to be transposed. */
|
|
|
2410 ucontext_t *uc = (ucontext_t *)ucontext;
|
|
|
2411 unsigned long t = uc->uc_mcontext->__ss.__rbx;
|
|
|
2412
|
|
|
2413 uc->uc_mcontext->__ss.__rbx = uc->uc_mcontext->__ss.__rdx;
|
|
|
2414 uc->uc_mcontext->__ss.__rdx = t;
|
|
|
2415 }
|
|
|
2416 #elif defined(__arm64__)
|
|
|
2417 /* Even though the CFI is marked as a signal frame, we need this. */
|
|
|
2418 ucontext_t *uc = (ucontext_t *)ucontext;
|
|
|
2419 uc->uc_mcontext->__ss.__pc++;
|
|
|
2420 #endif
|
|
|
2421 }
|
|
|
2422
|
|
|
2423 static void
|
|
|
2424 __gnat_map_signal (int sig, siginfo_t *si, void *mcontext ATTRIBUTE_UNUSED)
|
|
|
2425 {
|
|
|
2426 struct Exception_Data *exception;
|
|
|
2427 const char *msg;
|
|
|
2428
|
|
|
2429 switch (sig)
|
|
|
2430 {
|
|
|
2431 case SIGSEGV:
|
|
|
2432 case SIGBUS:
|
|
|
2433 if (__gnat_is_stack_guard ((unsigned long)si->si_addr))
|
|
|
2434 {
|
|
|
2435 #ifdef __arm64__
|
|
|
2436 /* ??? This is a kludge to make stack checking work. The problem is
|
|
|
2437 that the trampoline doesn't restore LR and, consequently, doesn't
|
|
|
2438 make it possible to unwind past an interrupted frame which hasn"t
|
|
|
2439 saved LR on the stack yet. Therefore, for probes in the prologue
|
|
|
2440 (32-bit probes as opposed to standard 64-bit probes), we make the
|
|
|
2441 unwinder skip the not-yet-established frame altogether. */
|
|
|
2442 mcontext_t mc = (mcontext_t)mcontext;
|
|
|
2443 if (!(*(unsigned int *)(mc->__ss.__pc-1) & ((unsigned int)1 << 30)))
|
|
|
2444 mc->__ss.__pc = mc->__ss.__lr;
|
|
|
2445 #endif
|
|
|
2446 exception = &storage_error;
|
|
|
2447 msg = "stack overflow";
|
|
|
2448 }
|
|
|
2449 else
|
|
|
2450 {
|
|
|
2451 exception = &constraint_error;
|
|
|
2452 msg = "erroneous memory access";
|
|
|
2453 }
|
|
|
2454
|
|
|
2455 /* Reset the use of alt stack, so that the alt stack will be used
|
|
|
2456 for the next signal delivery.
|
|
|
2457 The stack can't be used in case of stack checking. */
|
|
|
2458 syscall (SYS_sigreturn, NULL, UC_RESET_ALT_STACK);
|
|
|
2459 break;
|
|
|
2460
|
|
|
2461 case SIGFPE:
|
|
|
2462 exception = &constraint_error;
|
|
|
2463 msg = "SIGFPE";
|
|
|
2464 break;
|
|
|
2465
|
|
|
2466 default:
|
|
|
2467 exception = &program_error;
|
|
|
2468 msg = "unhandled signal";
|
|
|
2469 }
|
|
|
2470
|
|
|
2471 Raise_From_Signal_Handler (exception, msg);
|
|
|
2472 }
|
|
|
2473
|
|
|
2474 static void
|
|
|
2475 __gnat_error_handler (int sig, siginfo_t *si, void *ucontext)
|
|
|
2476 {
|
|
|
2477 __gnat_adjust_context_for_raise (sig, ucontext);
|
|
|
2478
|
|
|
2479 /* The Darwin libc comes with a signal trampoline, except for ARM64. */
|
|
|
2480 #ifdef __arm64__
|
|
|
2481 __gnat_sigtramp (sig, (void *)si, ucontext,
|
|
|
2482 (__sigtramphandler_t *)&__gnat_map_signal);
|
|
|
2483 #else
|
|
|
2484 __gnat_map_signal (sig, si, ucontext);
|
|
|
2485 #endif
|
|
|
2486 }
|
|
|
2487
|
|
|
2488 void
|
|
|
2489 __gnat_install_handler (void)
|
|
|
2490 {
|
|
|
2491 struct sigaction act;
|
|
|
2492
|
|
|
2493 /* Set up signal handler to map synchronous signals to appropriate
|
|
|
2494 exceptions. Make sure that the handler isn't interrupted by another
|
|
|
2495 signal that might cause a scheduling event! Also setup an alternate
|
|
|
2496 stack region for the handler execution so that stack overflows can be
|
|
|
2497 handled properly, avoiding a SEGV generation from stack usage by the
|
|
|
2498 handler itself (and it is required by Darwin). */
|
|
|
2499
|
|
|
2500 stack_t stack;
|
|
|
2501 stack.ss_sp = __gnat_alternate_stack;
|
|
|
2502 stack.ss_size = sizeof (__gnat_alternate_stack);
|
|
|
2503 stack.ss_flags = 0;
|
|
|
2504 sigaltstack (&stack, NULL);
|
|
|
2505
|
|
|
2506 act.sa_flags = SA_NODEFER | SA_RESTART | SA_SIGINFO;
|
|
|
2507 act.sa_sigaction = __gnat_error_handler;
|
|
|
2508 sigemptyset (&act.sa_mask);
|
|
|
2509
|
|
|
2510 /* Do not install handlers if interrupt state is "System". */
|
|
|
2511 if (__gnat_get_interrupt_state (SIGABRT) != 's')
|
|
|
2512 sigaction (SIGABRT, &act, NULL);
|
|
|
2513 if (__gnat_get_interrupt_state (SIGFPE) != 's')
|
|
|
2514 sigaction (SIGFPE, &act, NULL);
|
|
|
2515 if (__gnat_get_interrupt_state (SIGILL) != 's')
|
|
|
2516 sigaction (SIGILL, &act, NULL);
|
|
|
2517
|
|
|
2518 act.sa_flags |= SA_ONSTACK;
|
|
|
2519 if (__gnat_get_interrupt_state (SIGSEGV) != 's')
|
|
|
2520 sigaction (SIGSEGV, &act, NULL);
|
|
|
2521 if (__gnat_get_interrupt_state (SIGBUS) != 's')
|
|
|
2522 sigaction (SIGBUS, &act, NULL);
|
|
|
2523
|
|
|
2524 __gnat_handler_installed = 1;
|
|
|
2525 }
|
|
|
2526
|
|
131
|
2527 #elif defined(__QNX__)
|
|
|
2528
|
|
|
2529 /***************/
|
|
|
2530 /* QNX Section */
|
|
|
2531 /***************/
|
|
|
2532
|
|
|
2533 #include <signal.h>
|
|
|
2534 #include <unistd.h>
|
|
|
2535 #include <string.h>
|
|
|
2536 #include "sigtramp.h"
|
|
|
2537
|
|
|
2538 void
|
|
|
2539 __gnat_map_signal (int sig,
|
|
|
2540 siginfo_t *si ATTRIBUTE_UNUSED,
|
|
|
2541 void *mcontext ATTRIBUTE_UNUSED)
|
|
|
2542 {
|
|
|
2543 struct Exception_Data *exception;
|
|
|
2544 const char *msg;
|
|
|
2545
|
|
|
2546 switch(sig)
|
|
|
2547 {
|
|
|
2548 case SIGFPE:
|
|
|
2549 exception = &constraint_error;
|
|
|
2550 msg = "SIGFPE";
|
|
|
2551 break;
|
|
|
2552 case SIGILL:
|
|
|
2553 exception = &constraint_error;
|
|
|
2554 msg = "SIGILL";
|
|
|
2555 break;
|
|
|
2556 case SIGSEGV:
|
|
|
2557 exception = &storage_error;
|
|
|
2558 msg = "stack overflow or erroneous memory access";
|
|
|
2559 break;
|
|
|
2560 case SIGBUS:
|
|
|
2561 exception = &constraint_error;
|
|
|
2562 msg = "SIGBUS";
|
|
|
2563 break;
|
|
|
2564 default:
|
|
|
2565 exception = &program_error;
|
|
|
2566 msg = "unhandled signal";
|
|
|
2567 }
|
|
|
2568
|
|
|
2569 Raise_From_Signal_Handler (exception, msg);
|
|
|
2570 }
|
|
|
2571
|
|
|
2572 static void
|
|
|
2573 __gnat_error_handler (int sig, siginfo_t *si, void *ucontext)
|
|
|
2574 {
|
|
|
2575 __gnat_sigtramp (sig, (void *) si, (void *) ucontext,
|
|
|
2576 (__sigtramphandler_t *)&__gnat_map_signal);
|
|
|
2577 }
|
|
|
2578
|
|
|
2579 /* This must be in keeping with System.OS_Interface.Alternate_Stack_Size. */
|
|
|
2580 /* sigaltstack is currently not supported by QNX7 */
|
|
|
2581 char __gnat_alternate_stack[0];
|
|
|
2582
|
|
|
2583 void
|
|
|
2584 __gnat_install_handler (void)
|
|
|
2585 {
|
|
|
2586 struct sigaction act;
|
|
|
2587 int err;
|
|
|
2588
|
|
|
2589 act.sa_handler = __gnat_error_handler;
|
|
|
2590 act.sa_flags = SA_NODEFER | SA_SIGINFO;
|
|
|
2591 sigemptyset (&act.sa_mask);
|
|
|
2592
|
|
|
2593 /* Do not install handlers if interrupt state is "System" */
|
|
|
2594 if (__gnat_get_interrupt_state (SIGFPE) != 's') {
|
|
|
2595 err = sigaction (SIGFPE, &act, NULL);
|
|
|
2596 if (err == -1) {
|
|
|
2597 err = errno;
|
|
|
2598 perror ("error while attaching SIGFPE");
|
|
|
2599 perror (strerror (err));
|
|
|
2600 }
|
|
|
2601 }
|
|
|
2602 if (__gnat_get_interrupt_state (SIGILL) != 's') {
|
|
|
2603 sigaction (SIGILL, &act, NULL);
|
|
|
2604 if (err == -1) {
|
|
|
2605 err = errno;
|
|
|
2606 perror ("error while attaching SIGFPE");
|
|
|
2607 perror (strerror (err));
|
|
|
2608 }
|
|
|
2609 }
|
|
|
2610 if (__gnat_get_interrupt_state (SIGSEGV) != 's') {
|
|
|
2611 sigaction (SIGSEGV, &act, NULL);
|
|
|
2612 if (err == -1) {
|
|
|
2613 err = errno;
|
|
|
2614 perror ("error while attaching SIGFPE");
|
|
|
2615 perror (strerror (err));
|
|
|
2616 }
|
|
|
2617 }
|
|
|
2618 if (__gnat_get_interrupt_state (SIGBUS) != 's') {
|
|
|
2619 sigaction (SIGBUS, &act, NULL);
|
|
|
2620 if (err == -1) {
|
|
|
2621 err = errno;
|
|
|
2622 perror ("error while attaching SIGFPE");
|
|
|
2623 perror (strerror (err));
|
|
|
2624 }
|
|
|
2625 }
|
|
|
2626 __gnat_handler_installed = 1;
|
|
|
2627 }
|
|
|
2628
|
|
111
|
2629 #elif defined (__DJGPP__)
|
|
|
2630
|
|
|
2631 void
|
|
|
2632 __gnat_install_handler ()
|
|
|
2633 {
|
|
|
2634 __gnat_handler_installed = 1;
|
|
|
2635 }
|
|
|
2636
|
|
|
2637 #elif defined(__ANDROID__)
|
|
|
2638
|
|
|
2639 /*******************/
|
|
|
2640 /* Android Section */
|
|
|
2641 /*******************/
|
|
|
2642
|
|
|
2643 #include <signal.h>
|
|
|
2644 #include <sys/ucontext.h>
|
|
|
2645 #include "sigtramp.h"
|
|
|
2646
|
|
|
2647 #define HAVE_GNAT_ADJUST_CONTEXT_FOR_RAISE
|
|
|
2648
|
|
|
2649 void
|
|
|
2650 __gnat_adjust_context_for_raise (int signo ATTRIBUTE_UNUSED, void *ucontext)
|
|
|
2651 {
|
|
|
2652 mcontext_t *mcontext = &((ucontext_t *) ucontext)->uc_mcontext;
|
|
|
2653
|
|
|
2654 /* ARM Bump has to be an even number because of odd/even architecture. */
|
|
|
2655 ((mcontext_t *) mcontext)->arm_pc += 2;
|
|
|
2656 }
|
|
|
2657
|
|
|
2658 static void
|
|
|
2659 __gnat_map_signal (int sig,
|
|
|
2660 siginfo_t *si ATTRIBUTE_UNUSED,
|
|
|
2661 void *mcontext ATTRIBUTE_UNUSED)
|
|
|
2662 {
|
|
|
2663 struct Exception_Data *exception;
|
|
|
2664 const char *msg;
|
|
|
2665
|
|
|
2666 switch (sig)
|
|
|
2667 {
|
|
|
2668 case SIGSEGV:
|
|
|
2669 exception = &storage_error;
|
|
|
2670 msg = "stack overflow or erroneous memory access";
|
|
|
2671 break;
|
|
|
2672
|
|
|
2673 case SIGBUS:
|
|
|
2674 exception = &constraint_error;
|
|
|
2675 msg = "SIGBUS";
|
|
|
2676 break;
|
|
|
2677
|
|
|
2678 case SIGFPE:
|
|
|
2679 exception = &constraint_error;
|
|
|
2680 msg = "SIGFPE";
|
|
|
2681 break;
|
|
|
2682
|
|
|
2683 default:
|
|
|
2684 exception = &program_error;
|
|
|
2685 msg = "unhandled signal";
|
|
|
2686 }
|
|
|
2687
|
|
|
2688 Raise_From_Signal_Handler (exception, msg);
|
|
|
2689 }
|
|
|
2690
|
|
|
2691 static void
|
|
|
2692 __gnat_error_handler (int sig, siginfo_t *si, void *ucontext)
|
|
|
2693 {
|
|
|
2694 __gnat_adjust_context_for_raise (sig, ucontext);
|
|
|
2695
|
|
|
2696 __gnat_sigtramp (sig, (void *) si, (void *) ucontext,
|
|
|
2697 (__sigtramphandler_t *)&__gnat_map_signal);
|
|
|
2698 }
|
|
|
2699
|
|
|
2700 /* This must be in keeping with System.OS_Interface.Alternate_Stack_Size. */
|
|
|
2701 char __gnat_alternate_stack[16 * 1024];
|
|
|
2702
|
|
|
2703 void
|
|
|
2704 __gnat_install_handler (void)
|
|
|
2705 {
|
|
|
2706 struct sigaction act;
|
|
|
2707
|
|
|
2708 /* Set up signal handler to map synchronous signals to appropriate
|
|
|
2709 exceptions. Make sure that the handler isn't interrupted by another
|
|
|
2710 signal that might cause a scheduling event! Also setup an alternate
|
|
|
2711 stack region for the handler execution so that stack overflows can be
|
|
|
2712 handled properly, avoiding a SEGV generation from stack usage by the
|
|
|
2713 handler itself. */
|
|
|
2714
|
|
|
2715 stack_t stack;
|
|
|
2716 stack.ss_sp = __gnat_alternate_stack;
|
|
|
2717 stack.ss_size = sizeof (__gnat_alternate_stack);
|
|
|
2718 stack.ss_flags = 0;
|
|
|
2719 sigaltstack (&stack, NULL);
|
|
|
2720
|
|
|
2721 act.sa_sigaction = __gnat_error_handler;
|
|
|
2722 act.sa_flags = SA_NODEFER | SA_RESTART | SA_SIGINFO;
|
|
|
2723 sigemptyset (&act.sa_mask);
|
|
|
2724
|
|
|
2725 sigaction (SIGABRT, &act, NULL);
|
|
|
2726 sigaction (SIGFPE, &act, NULL);
|
|
|
2727 sigaction (SIGILL, &act, NULL);
|
|
|
2728 sigaction (SIGBUS, &act, NULL);
|
|
|
2729 act.sa_flags |= SA_ONSTACK;
|
|
|
2730 sigaction (SIGSEGV, &act, NULL);
|
|
|
2731
|
|
|
2732 __gnat_handler_installed = 1;
|
|
|
2733 }
|
|
|
2734
|
|
|
2735 #else
|
|
|
2736
|
|
|
2737 /* For all other versions of GNAT, the handler does nothing. */
|
|
|
2738
|
|
|
2739 /*******************/
|
|
|
2740 /* Default Section */
|
|
|
2741 /*******************/
|
|
|
2742
|
|
|
2743 void
|
|
|
2744 __gnat_install_handler (void)
|
|
|
2745 {
|
|
|
2746 __gnat_handler_installed = 1;
|
|
|
2747 }
|
|
|
2748
|
|
|
2749 #endif
|
|
|
2750
|
|
|
2751 /*********************/
|
|
|
2752 /* __gnat_init_float */
|
|
|
2753 /*********************/
|
|
|
2754
|
|
|
2755 /* This routine is called as each process thread is created, for possible
|
|
|
2756 initialization of the FP processor. This version is used under INTERIX
|
|
|
2757 and WIN32. */
|
|
|
2758
|
|
|
2759 #if defined (_WIN32) || defined (__INTERIX) \
|
|
|
2760 || defined (__Lynx__) || defined(__NetBSD__) || defined(__FreeBSD__) \
|
|
131
|
2761 || defined (__OpenBSD__) || defined (__DragonFly__) || defined(__QNX__)
|
|
111
|
2762
|
|
|
2763 #define HAVE_GNAT_INIT_FLOAT
|
|
|
2764
|
|
|
2765 void
|
|
|
2766 __gnat_init_float (void)
|
|
|
2767 {
|
|
|
2768 #if defined (__i386__) || defined (__x86_64__)
|
|
|
2769
|
|
|
2770 /* This is used to properly initialize the FPU on an x86 for each
|
|
|
2771 process thread. */
|
|
|
2772
|
|
|
2773 asm ("finit");
|
|
|
2774
|
|
|
2775 #endif /* Defined __i386__ */
|
|
|
2776 }
|
|
|
2777 #endif
|
|
|
2778
|
|
|
2779 #ifndef HAVE_GNAT_INIT_FLOAT
|
|
|
2780
|
|
|
2781 /* All targets without a specific __gnat_init_float will use an empty one. */
|
|
|
2782 void
|
|
|
2783 __gnat_init_float (void)
|
|
|
2784 {
|
|
|
2785 }
|
|
|
2786 #endif
|
|
|
2787
|
|
|
2788 /***********************************/
|
|
|
2789 /* __gnat_adjust_context_for_raise */
|
|
|
2790 /***********************************/
|
|
|
2791
|
|
|
2792 #ifndef HAVE_GNAT_ADJUST_CONTEXT_FOR_RAISE
|
|
|
2793
|
|
|
2794 /* All targets without a specific version will use an empty one. */
|
|
|
2795
|
|
|
2796 /* Given UCONTEXT a pointer to a context structure received by a signal
|
|
|
2797 handler for SIGNO, perform the necessary adjustments to let the handler
|
|
|
2798 raise an exception. Calls to this routine are not conditioned by the
|
|
|
2799 propagation scheme in use. */
|
|
|
2800
|
|
|
2801 void
|
|
|
2802 __gnat_adjust_context_for_raise (int signo ATTRIBUTE_UNUSED,
|
|
|
2803 void *ucontext ATTRIBUTE_UNUSED)
|
|
|
2804 {
|
|
|
2805 /* We used to compensate here for the raised from call vs raised from signal
|
|
|
2806 exception discrepancy with the GCC ZCX scheme, but this now can be dealt
|
|
|
2807 with generically in the unwinder (see GCC PR other/26208). This however
|
|
|
2808 requires the use of the _Unwind_GetIPInfo routine in raise-gcc.c, which
|
|
|
2809 is predicated on the definition of HAVE_GETIPINFO at compile time. Only
|
|
|
2810 the VMS ports still do the compensation described in the few lines below.
|
|
|
2811
|
|
|
2812 *** Call vs signal exception discrepancy with GCC ZCX scheme ***
|
|
|
2813
|
|
|
2814 The GCC unwinder expects to be dealing with call return addresses, since
|
|
|
2815 this is the "nominal" case of what we retrieve while unwinding a regular
|
|
|
2816 call chain.
|
|
|
2817
|
|
|
2818 To evaluate if a handler applies at some point identified by a return
|
|
|
2819 address, the propagation engine needs to determine what region the
|
|
|
2820 corresponding call instruction pertains to. Because the return address
|
|
|
2821 may not be attached to the same region as the call, the unwinder always
|
|
|
2822 subtracts "some" amount from a return address to search the region
|
|
|
2823 tables, amount chosen to ensure that the resulting address is inside the
|
|
|
2824 call instruction.
|
|
|
2825
|
|
|
2826 When we raise an exception from a signal handler, e.g. to transform a
|
|
|
2827 SIGSEGV into Storage_Error, things need to appear as if the signal
|
|
|
2828 handler had been "called" by the instruction which triggered the signal,
|
|
|
2829 so that exception handlers that apply there are considered. What the
|
|
|
2830 unwinder will retrieve as the return address from the signal handler is
|
|
|
2831 what it will find as the faulting instruction address in the signal
|
|
|
2832 context pushed by the kernel. Leaving this address untouched looses, if
|
|
|
2833 the triggering instruction happens to be the very first of a region, as
|
|
|
2834 the later adjustments performed by the unwinder would yield an address
|
|
|
2835 outside that region. We need to compensate for the unwinder adjustments
|
|
|
2836 at some point, and this is what this routine is expected to do.
|
|
|
2837
|
|
|
2838 signo is passed because on some targets for some signals the PC in
|
|
|
2839 context points to the instruction after the faulting one, in which case
|
|
|
2840 the unwinder adjustment is still desired. */
|
|
|
2841 }
|
|
|
2842
|
|
|
2843 #endif
|
|
|
2844
|
|
|
2845 #ifdef __cplusplus
|
|
|
2846 }
|
|
|
2847 #endif
|
