1/**************************************************************************** 2 * * 3 * GNAT COMPILER COMPONENTS * 4 * * 5 * S E H - I N I T * 6 * * 7 * C Implementation File * 8 * * 9 * Copyright (C) 2005-2014, Free Software Foundation, Inc. * 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 support for SEH (Structured Exception Handling). 33 Right now the only implementation is for Win32. */ 34 35#if defined (_WIN32) || (defined (__CYGWIN__) && defined (__SEH__)) 36/* Include system headers, before system.h poisons malloc. */ 37#include <windows.h> 38#include <excpt.h> 39#endif 40 41#ifdef IN_RTS 42#include "tconfig.h" 43#include "tsystem.h" 44 45/* We don't have libiberty, so use malloc. */ 46#define xmalloc(S) malloc (S) 47 48#else 49#include "config.h" 50#include "system.h" 51#endif 52 53#include "raise.h" 54 55#ifdef __cplusplus 56extern "C" { 57#endif 58 59/* Addresses of exception data blocks for predefined exceptions. */ 60extern struct Exception_Data constraint_error; 61extern struct Exception_Data numeric_error; 62extern struct Exception_Data program_error; 63extern struct Exception_Data storage_error; 64extern struct Exception_Data tasking_error; 65extern struct Exception_Data _abort_signal; 66 67#define Raise_From_Signal_Handler \ 68 ada__exceptions__raise_from_signal_handler 69extern void Raise_From_Signal_Handler (struct Exception_Data *, const char *) 70 ATTRIBUTE_NORETURN; 71 72 73#if defined (_WIN32) || (defined (__CYGWIN__) && defined (__SEH__)) 74 75/* Prototypes. */ 76extern void _global_unwind2 (void *); 77 78EXCEPTION_DISPOSITION __gnat_SEH_error_handler 79(struct _EXCEPTION_RECORD*, void*, struct _CONTEXT*, void*) ATTRIBUTE_NORETURN; 80 81struct Exception_Data * 82__gnat_map_SEH (EXCEPTION_RECORD* ExceptionRecord, const char **msg); 83 84/* Convert an SEH exception to an Ada one. Return the exception ID 85 and set MSG with the corresponding message. */ 86 87struct Exception_Data * 88__gnat_map_SEH (EXCEPTION_RECORD* ExceptionRecord, const char **msg) 89{ 90 switch (ExceptionRecord->ExceptionCode) 91 { 92 case EXCEPTION_ACCESS_VIOLATION: 93 /* If the failing address isn't maximally-aligned or if the page 94 before the faulting page is not accessible, this is a program error. 95 */ 96 if ((ExceptionRecord->ExceptionInformation[1] & 3) != 0 97 || IsBadCodePtr 98 ((FARPROC)(ExceptionRecord->ExceptionInformation[1] + 4096))) 99 { 100 *msg = "EXCEPTION_ACCESS_VIOLATION"; 101 return &program_error; 102 } 103 else 104 { 105 /* otherwise it is a stack overflow */ 106 *msg = "stack overflow or erroneous memory access"; 107 return &storage_error; 108 } 109 110 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: 111 *msg = "EXCEPTION_ARRAY_BOUNDS_EXCEEDED"; 112 return &constraint_error; 113 114 case EXCEPTION_DATATYPE_MISALIGNMENT: 115 *msg = "EXCEPTION_DATATYPE_MISALIGNMENT"; 116 return &constraint_error; 117 118 case EXCEPTION_FLT_DENORMAL_OPERAND: 119 *msg = "EXCEPTION_FLT_DENORMAL_OPERAND"; 120 return &constraint_error; 121 122 case EXCEPTION_FLT_DIVIDE_BY_ZERO: 123 *msg = "EXCEPTION_FLT_DENORMAL_OPERAND"; 124 return &constraint_error; 125 126 case EXCEPTION_FLT_INVALID_OPERATION: 127 *msg = "EXCEPTION_FLT_INVALID_OPERATION"; 128 return &constraint_error; 129 130 case EXCEPTION_FLT_OVERFLOW: 131 *msg = "EXCEPTION_FLT_OVERFLOW"; 132 return &constraint_error; 133 134 case EXCEPTION_FLT_STACK_CHECK: 135 *msg = "EXCEPTION_FLT_STACK_CHECK"; 136 return &program_error; 137 138 case EXCEPTION_FLT_UNDERFLOW: 139 *msg = "EXCEPTION_FLT_UNDERFLOW"; 140 return &constraint_error; 141 142 case EXCEPTION_INT_DIVIDE_BY_ZERO: 143 *msg = "EXCEPTION_INT_DIVIDE_BY_ZERO"; 144 return &constraint_error; 145 146 case EXCEPTION_INT_OVERFLOW: 147 *msg = "EXCEPTION_INT_OVERFLOW"; 148 return &constraint_error; 149 150 case EXCEPTION_INVALID_DISPOSITION: 151 *msg = "EXCEPTION_INVALID_DISPOSITION"; 152 return &program_error; 153 154 case EXCEPTION_NONCONTINUABLE_EXCEPTION: 155 *msg = "EXCEPTION_NONCONTINUABLE_EXCEPTION"; 156 return &program_error; 157 158 case EXCEPTION_PRIV_INSTRUCTION: 159 *msg = "EXCEPTION_PRIV_INSTRUCTION"; 160 return &program_error; 161 162 case EXCEPTION_SINGLE_STEP: 163 *msg = "EXCEPTION_SINGLE_STEP"; 164 return &program_error; 165 166 case EXCEPTION_STACK_OVERFLOW: 167 *msg = "EXCEPTION_STACK_OVERFLOW"; 168 return &storage_error; 169 170 default: 171 *msg = NULL; 172 return NULL; 173 } 174} 175 176#if !(defined (_WIN64) && defined (__SEH__)) 177 178EXCEPTION_DISPOSITION 179__gnat_SEH_error_handler (struct _EXCEPTION_RECORD* ExceptionRecord, 180 void *EstablisherFrame ATTRIBUTE_UNUSED, 181 struct _CONTEXT* ContextRecord ATTRIBUTE_UNUSED, 182 void *DispatcherContext ATTRIBUTE_UNUSED) 183{ 184 struct Exception_Data *exception; 185 const char *msg; 186 187 exception = __gnat_map_SEH (ExceptionRecord, &msg); 188 189 if (exception == NULL) 190 { 191 exception = &program_error; 192 msg = "unhandled signal"; 193 } 194 195#if ! defined (_WIN64) 196 /* This call is important as it avoids locking the second time we catch a 197 signal. Note that this routine is documented as internal to Windows and 198 should not be used. */ 199 200 _global_unwind2 (EstablisherFrame); 201 /* Call equivalent to RtlUnwind (EstablisherFrame, NULL, NULL, 0); */ 202#endif 203 204 Raise_From_Signal_Handler (exception, msg); 205} 206#endif /* !(defined (_WIN64) && defined (__SEH__)) */ 207 208#if defined (_WIN64) 209/* On x86_64 windows exception mechanism is no more based on a chained list 210 of handlers addresses on the stack. Instead unwinding information is used 211 to retrieve the exception handler (similar to ZCX GCC mechanism). So in 212 order to register an exception handler we need to put in the final 213 executable some unwinding information. This information might be present 214 statically in the image file inside the .pdata section or registered 215 through RtlAddFunctionTable API. Currently the GCC toolchain does not 216 generate the .pdata information for each function. As we don't need to 217 handle SEH exceptions except for signal handling we are registering a 218 "fake" unwinding data that associate a SEH exception handler to the 219 complete .text section. As we never return from the handler, the system 220 does not try to do the final unwinding using the pdata information. The 221 unwinding is handled by the runtime using either the GNAT SJLJ mechanism 222 or the ZCX GCC mechanism. 223 224 Solutions based on SetUnhandledExceptionFilter have been discarded as this 225 function is mostly disabled on last Windows versions. 226 Using AddVectoredExceptionHandler should also be discarded as it overrides 227 all SEH exception handlers that might be present in the program itself and 228 the loaded DLL (for example it results in unexpected behaviors in the 229 Win32 subsystem. */ 230 231#ifndef __SEH__ 232 /* Don't use this trick when SEH are emitted by gcc, as it will conflict with 233 them. */ 234asm 235( 236 " .section .rdata, \"dr\"\n" 237 " .align 4\n" 238 "unwind_info:\n" 239 " .byte 9\n" /* UNW_FLAG_EHANDLER | UNW_VERSION */ 240 " .byte 0\n" /* Prologue size. */ 241 " .byte 0\n" /* Count of unwind code. */ 242 " .byte 0\n" /* Frame register and offset. */ 243 " .rva __gnat_SEH_error_handler\n" 244 "\n" 245 " .section .pdata, \"dr\"\n" 246 " .align 4\n" 247 " .long 0\n" /* ImageBase */ 248 " .rva etext\n" 249 " .rva unwind_info\n" 250 "\n" 251 " .text\n" 252); 253#endif /* __SEH__ */ 254 255void __gnat_install_SEH_handler (void *eh ATTRIBUTE_UNUSED) 256{ 257 /* Nothing to do, the handler is statically installed by the asm statement 258 just above. */ 259} 260 261#else /* defined (_WIN64) */ 262/* Install the Win32 SEH exception handler. Note that the caller must have 263 allocated 8 bytes on the stack and pass the pointer to this stack 264 space. This is needed as the SEH exception handler must be on the stack of 265 the thread. 266 267 int buf[2]; 268 269 __gnat_install_SEH_handler ((void*)buf); 270 271 main(); 272 273 This call must be done before calling the main procedure or the thread 274 entry. The stack space must exists during all the main run. */ 275 276void 277__gnat_install_SEH_handler (void *ER) 278{ 279 int *ptr; 280 281 /* put current handler in ptr */ 282 283 asm ("mov %%fs:(0),%0" : "=r" (ptr)); 284 285 ((int *)ER)[0] = (int)ptr; /* previous handler */ 286 ((int *)ER)[1] = (int)__gnat_SEH_error_handler; /* new handler */ 287 288 /* ER is the new handler, set fs:(0) with this value */ 289 290 asm volatile ("mov %0,%%fs:(0)": : "r" (ER)); 291} 292#endif 293 294#else /* defined (_WIN32) */ 295/* For all non Windows targets we provide a dummy SEH install handler. */ 296void __gnat_install_SEH_handler (void *eh ATTRIBUTE_UNUSED) 297{ 298} 299#endif 300 301#ifdef __cplusplus 302} 303#endif 304