1 /****************************************************************************
3 * GNAT COMPILER COMPONENTS *
7 * C Implementation File *
9 * Copyright (C) 2005-2013, Free Software Foundation, Inc. *
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. *
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. *
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/>. *
27 * GNAT was originally developed by the GNAT team at New York University. *
28 * Extensive contributions were provided by Ada Core Technologies Inc. *
30 ****************************************************************************/
32 /* This unit contains support for SEH (Structured Exception Handling).
33 Right now the only implementation is for Win32. */
43 /* We don't have libiberty, so use malloc. */
44 #define xmalloc(S) malloc (S)
53 /* Addresses of exception data blocks for predefined exceptions. */
54 extern struct Exception_Data constraint_error;
55 extern struct Exception_Data numeric_error;
56 extern struct Exception_Data program_error;
57 extern struct Exception_Data storage_error;
58 extern struct Exception_Data tasking_error;
59 extern struct Exception_Data _abort_signal;
61 #define Raise_From_Signal_Handler \
62 ada__exceptions__raise_from_signal_handler
63 extern void Raise_From_Signal_Handler (struct Exception_Data *, const char *)
72 extern void _global_unwind2 (void *);
74 EXCEPTION_DISPOSITION __gnat_SEH_error_handler
75 (struct _EXCEPTION_RECORD*, void*, struct _CONTEXT*, void*) ATTRIBUTE_NORETURN;
78 __gnat_SEH_error_handler (struct _EXCEPTION_RECORD* ExceptionRecord,
79 void *EstablisherFrame,
80 struct _CONTEXT* ContextRecord ATTRIBUTE_UNUSED,
81 void *DispatcherContext ATTRIBUTE_UNUSED)
83 struct Exception_Data *exception;
86 switch (ExceptionRecord->ExceptionCode)
88 case EXCEPTION_ACCESS_VIOLATION:
89 /* If the failing address isn't maximally-aligned or if the page
90 before the faulting page is not accessible, this is a program error.
92 if ((ExceptionRecord->ExceptionInformation[1] & 3) != 0
94 ((FARPROC)(ExceptionRecord->ExceptionInformation[1] + 4096)))
96 exception = &program_error;
97 msg = "EXCEPTION_ACCESS_VIOLATION";
101 /* otherwise it is a stack overflow */
102 exception = &storage_error;
103 msg = "stack overflow or erroneous memory access";
107 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
108 exception = &constraint_error;
109 msg = "EXCEPTION_ARRAY_BOUNDS_EXCEEDED";
112 case EXCEPTION_DATATYPE_MISALIGNMENT:
113 exception = &constraint_error;
114 msg = "EXCEPTION_DATATYPE_MISALIGNMENT";
117 case EXCEPTION_FLT_DENORMAL_OPERAND:
118 exception = &constraint_error;
119 msg = "EXCEPTION_FLT_DENORMAL_OPERAND";
122 case EXCEPTION_FLT_DIVIDE_BY_ZERO:
123 exception = &constraint_error;
124 msg = "EXCEPTION_FLT_DENORMAL_OPERAND";
127 case EXCEPTION_FLT_INVALID_OPERATION:
128 exception = &constraint_error;
129 msg = "EXCEPTION_FLT_INVALID_OPERATION";
132 case EXCEPTION_FLT_OVERFLOW:
133 exception = &constraint_error;
134 msg = "EXCEPTION_FLT_OVERFLOW";
137 case EXCEPTION_FLT_STACK_CHECK:
138 exception = &program_error;
139 msg = "EXCEPTION_FLT_STACK_CHECK";
142 case EXCEPTION_FLT_UNDERFLOW:
143 exception = &constraint_error;
144 msg = "EXCEPTION_FLT_UNDERFLOW";
147 case EXCEPTION_INT_DIVIDE_BY_ZERO:
148 exception = &constraint_error;
149 msg = "EXCEPTION_INT_DIVIDE_BY_ZERO";
152 case EXCEPTION_INT_OVERFLOW:
153 exception = &constraint_error;
154 msg = "EXCEPTION_INT_OVERFLOW";
157 case EXCEPTION_INVALID_DISPOSITION:
158 exception = &program_error;
159 msg = "EXCEPTION_INVALID_DISPOSITION";
162 case EXCEPTION_NONCONTINUABLE_EXCEPTION:
163 exception = &program_error;
164 msg = "EXCEPTION_NONCONTINUABLE_EXCEPTION";
167 case EXCEPTION_PRIV_INSTRUCTION:
168 exception = &program_error;
169 msg = "EXCEPTION_PRIV_INSTRUCTION";
172 case EXCEPTION_SINGLE_STEP:
173 exception = &program_error;
174 msg = "EXCEPTION_SINGLE_STEP";
177 case EXCEPTION_STACK_OVERFLOW:
178 exception = &storage_error;
179 msg = "EXCEPTION_STACK_OVERFLOW";
183 exception = &program_error;
184 msg = "unhandled signal";
187 #if ! defined (_WIN64)
188 /* This call is important as it avoids locking the second time we catch a
189 signal. Note that this routine is documented as internal to Windows and
190 should not be used. */
192 _global_unwind2 (EstablisherFrame);
193 /* Call equivalent to RtlUnwind (EstablisherFrame, NULL, NULL, 0); */
196 Raise_From_Signal_Handler (exception, msg);
200 /* On x86_64 windows exception mechanism is no more based on a chained list
201 of handlers addresses on the stack. Instead unwinding information is used
202 to retrieve the exception handler (similar to ZCX GCC mechanism). So in
203 order to register an exception handler we need to put in the final
204 executable some unwinding information. This information might be present
205 statically in the image file inside the .pdata section or registered
206 through RtlAddFunctionTable API. Currently the GCC toolchain does not
207 generate the .pdata information for each function. As we don't need to
208 handle SEH exceptions except for signal handling we are registering a
209 "fake" unwinding data that associate a SEH exception handler to the
210 complete .text section. As we never return from the handler, the system
211 does not try to do the final unwinding using the pdata information. The
212 unwinding is handled by the runtime using either the GNAT SJLJ mechanism
213 or the ZCX GCC mechanism.
215 Solutions based on SetUnhandledExceptionFilter have been discarded as this
216 function is mostly disabled on last Windows versions.
217 Using AddVectoredExceptionHandler should also be discarded as it overrides
218 all SEH exception handlers that might be present in the program itself and
219 the loaded DLL (for example it results in unexpected behaviors in the
224 " .section .rdata, \"dr\"\n"
227 " .byte 9\n" /* UNW_FLAG_EHANDLER | UNW_VERSION */
228 " .byte 0\n" /* Prologue size. */
229 " .byte 0\n" /* Count of unwind code. */
230 " .byte 0\n" /* Frame register and offset. */
231 " .rva __gnat_SEH_error_handler\n"
233 " .section .pdata, \"dr\"\n"
235 " .long 0\n" /* ImageBase */
237 " .rva unwind_info\n"
242 void __gnat_install_SEH_handler (void *eh ATTRIBUTE_UNUSED)
244 /* Nothing to do, the handler is statically installed by the asm statement
248 #else /* defined (_WIN64) */
249 /* Install the Win32 SEH exception handler. Note that the caller must have
250 allocated 8 bytes on the stack and pass the pointer to this stack
251 space. This is needed as the SEH exception handler must be on the stack of
256 __gnat_install_SEH_handler ((void*)buf);
260 This call must be done before calling the main procedure or the thread
261 entry. The stack space must exists during all the main run. */
264 __gnat_install_SEH_handler (void *ER)
268 /* put current handler in ptr */
270 asm ("mov %%fs:(0),%0" : "=r" (ptr));
272 ((int *)ER)[0] = (int)ptr; /* previous handler */
273 ((int *)ER)[1] = (int)__gnat_SEH_error_handler; /* new handler */
275 /* ER is the new handler, set fs:(0) with this value */
277 asm volatile ("mov %0,%%fs:(0)": : "r" (ER));
281 #else /* defined (_WIN32) */
282 /* For all non Windows targets we provide a dummy SEH install handler. */
283 void __gnat_install_SEH_handler (void *eh ATTRIBUTE_UNUSED)