30482d4da1381ab8f80d8b33390b4fd14fc5d456
[occt.git] / src / OSD / OSD_signal.cxx
1 // Copyright (c) 1999-2014 OPEN CASCADE SAS
2 //
3 // This file is part of Open CASCADE Technology software library.
4 //
5 // This library is free software; you can redistribute it and/or modify it under
6 // the terms of the GNU Lesser General Public License version 2.1 as published
7 // by the Free Software Foundation, with special exception defined in the file
8 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
9 // distribution for complete text of the license and disclaimer of any warranty.
10 //
11 // Alternatively, this file may be used under the terms of Open CASCADE
12 // commercial license or contractual agreement.
13
14
15 #include <OSD.hxx>
16 #include <OSD_Exception_CTRL_BREAK.hxx>
17 #include <Standard_DivideByZero.hxx>
18 #include <Standard_Overflow.hxx>
19
20 #ifdef _WIN32
21 //---------------------------- Windows NT System --------------------------------
22
23 #ifdef NOUSER
24 #undef NOUSER
25 #endif
26 #ifdef NONLS
27 #undef NONLS
28 #endif
29 #include <windows.h>
30
31 #include <Strsafe.h>
32
33 #ifndef STATUS_FLOAT_MULTIPLE_FAULTS
34   // <ntstatus.h>
35   #define STATUS_FLOAT_MULTIPLE_FAULTS     (0xC00002B4L)
36   #define STATUS_FLOAT_MULTIPLE_TRAPS      (0xC00002B5L)
37 #endif
38
39 #include <OSD_Exception_ACCESS_VIOLATION.hxx>
40 #include <OSD_Exception_ARRAY_BOUNDS_EXCEEDED.hxx>
41 #include <OSD_Exception_ILLEGAL_INSTRUCTION.hxx>
42 #include <OSD_Exception_IN_PAGE_ERROR.hxx>
43 #include <OSD_Exception_INT_DIVIDE_BY_ZERO.hxx>
44 #include <OSD_Exception_INT_OVERFLOW.hxx>
45 #include <OSD_Exception_INVALID_DISPOSITION.hxx>
46 #include <OSD_Exception_NONCONTINUABLE_EXCEPTION.hxx>
47 #include <OSD_Exception_PRIV_INSTRUCTION.hxx>
48 #include <OSD_Exception_STACK_OVERFLOW.hxx>
49 #include <OSD_Exception_STATUS_NO_MEMORY.hxx>
50
51 #include <OSD_Environment.hxx>
52 #include <Standard_Underflow.hxx>
53 #include <Standard_ProgramError.hxx>
54 #include <Standard_Mutex.hxx>
55
56 #include <OSD_WNT_1.hxx>
57
58 #ifdef _MSC_VER
59 #include <eh.h>
60 #include <malloc.h>
61 #endif
62
63 #include <process.h>
64 #include <signal.h>
65 #include <float.h>
66
67 static Standard_Boolean fCtrlBrk;
68
69 static Standard_Boolean fMsgBox;
70 static Standard_Boolean fFltExceptions;
71
72 // used to forbid simultaneous execution of setting / executing handlers
73 static Standard_Mutex THE_SIGNAL_MUTEX;
74
75 static LONG __fastcall _osd_raise ( DWORD, LPSTR );
76 static BOOL WINAPI     _osd_ctrl_break_handler ( DWORD );
77
78 #if ! defined(OCCT_UWP) && !defined(__MINGW32__) && !defined(__CYGWIN32__)
79 static Standard_Boolean fDbgLoaded;
80 static LONG _osd_debug   ( void );
81 #endif
82
83 //# define _OSD_FPX ( _EM_INVALID | _EM_DENORMAL | _EM_ZERODIVIDE | _EM_OVERFLOW | _EM_UNDERFLOW )
84 # define _OSD_FPX ( _EM_INVALID | _EM_DENORMAL | _EM_ZERODIVIDE | _EM_OVERFLOW )
85
86 #ifdef OCC_CONVERT_SIGNALS
87 #define THROW_OR_JUMP(Type,Message) Type::NewInstance(Message)->Jump()
88 #else
89 #define THROW_OR_JUMP(Type,Message) throw Type(Message)
90 #endif
91
92 //=======================================================================
93 //function : CallHandler
94 //purpose  :
95 //=======================================================================
96 static LONG CallHandler (DWORD dwExceptionCode,
97                          ptrdiff_t ExceptionInformation1,
98                          ptrdiff_t ExceptionInformation0)
99 {
100   Standard_Mutex::Sentry aSentry (THE_SIGNAL_MUTEX); // lock the mutex to prevent simultaneous handling
101
102   static wchar_t         buffer[2048];
103
104   int                  flterr = 0;
105
106   buffer[0] = '\0' ;
107
108 // cout << "CallHandler " << dwExceptionCode << endl ;
109   switch ( dwExceptionCode ) {
110     case EXCEPTION_FLT_DENORMAL_OPERAND:
111 //      cout << "CallHandler : EXCEPTION_FLT_DENORMAL_OPERAND:" << endl ;
112       StringCchCopyW (buffer, _countof(buffer), L"FLT DENORMAL OPERAND");
113       flterr = 1 ;
114       break ;
115     case EXCEPTION_FLT_DIVIDE_BY_ZERO:
116 //      cout << "CallHandler : EXCEPTION_FLT_DIVIDE_BY_ZERO:" << endl ;
117       StringCchCopyW (buffer, _countof(buffer), L"FLT DIVIDE BY ZERO");
118       flterr = 1 ;
119       break ;
120     case EXCEPTION_FLT_INEXACT_RESULT:
121 //      cout << "CallHandler : EXCEPTION_FLT_INEXACT_RESULT:" << endl ;
122       StringCchCopyW (buffer, _countof(buffer), L"FLT INEXACT RESULT");
123       flterr = 1 ;
124       break ;
125     case EXCEPTION_FLT_INVALID_OPERATION:
126 //      cout << "CallHandler : EXCEPTION_FLT_INVALID_OPERATION:" << endl ;
127       StringCchCopyW (buffer, _countof(buffer), L"FLT INVALID OPERATION");
128       flterr = 1 ;
129       break ;
130     case EXCEPTION_FLT_OVERFLOW:
131 //      cout << "CallHandler : EXCEPTION_FLT_OVERFLOW:" << endl ;
132       StringCchCopyW (buffer, _countof(buffer), L"FLT OVERFLOW");
133       flterr = 1 ;
134       break ;
135     case EXCEPTION_FLT_STACK_CHECK:
136 //      cout << "CallHandler : EXCEPTION_FLT_STACK_CHECK:" << endl ;
137       StringCchCopyW (buffer, _countof(buffer), L"FLT STACK CHECK");
138       flterr = 1 ;
139       break ;
140     case EXCEPTION_FLT_UNDERFLOW:
141 //      cout << "CallHandler : EXCEPTION_FLT_UNDERFLOW:" << endl ;
142       StringCchCopyW (buffer, _countof(buffer), L"FLT UNDERFLOW");
143       flterr = 1 ;
144       break ;
145     case STATUS_FLOAT_MULTIPLE_TRAPS:
146 //      cout << "CallHandler : EXCEPTION_FLT_UNDERFLOW:" << endl ;
147       StringCchCopyW (buffer, _countof(buffer), L"FLT MULTIPLE TRAPS (possible overflow in conversion of double to integer)");
148       flterr = 1 ;
149       break ;
150     case STATUS_FLOAT_MULTIPLE_FAULTS:
151 //      cout << "CallHandler : EXCEPTION_FLT_UNDERFLOW:" << endl ;
152       StringCchCopyW (buffer, _countof(buffer), L"FLT MULTIPLE FAULTS");
153       flterr = 1 ;
154       break ;
155     case STATUS_NO_MEMORY:
156 //      cout << "CallHandler : STATUS_NO_MEMORY:" << endl ;
157       THROW_OR_JUMP (OSD_Exception_STATUS_NO_MEMORY, "MEMORY ALLOCATION ERROR ( no room in the process heap )");
158       break;
159     case EXCEPTION_ACCESS_VIOLATION:
160 //      cout << "CallHandler : EXCEPTION_ACCESS_VIOLATION:" << endl ;
161       StringCchPrintfW (buffer, _countof(buffer), L"%s%s%s0x%.8p%s%s%s", L"ACCESS VIOLATION",
162                  fMsgBox ? L"\n" : L" ", L"at address ",
163                  ExceptionInformation1 ,
164                  L" during '",
165                  ExceptionInformation0 ? L"WRITE" : L"READ",
166                  L"' operation");
167       break;
168     case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
169 //      cout << "CallHandler : EXCEPTION_ARRAY_BOUNDS_EXCEEDED:" << endl ;
170       StringCchCopyW (buffer, _countof(buffer), L"ARRAY BOUNDS EXCEEDED");
171       break;
172     case EXCEPTION_DATATYPE_MISALIGNMENT:
173 //      cout << "CallHandler : EXCEPTION_DATATYPE_MISALIGNMENT:" << endl ;
174       StringCchCopyW (buffer, _countof(buffer), L"DATATYPE MISALIGNMENT");
175       break;
176
177     case EXCEPTION_ILLEGAL_INSTRUCTION:
178 //      cout << "CallHandler : EXCEPTION_ILLEGAL_INSTRUCTION:" << endl ;
179       StringCchCopyW (buffer, _countof(buffer), L"ILLEGAL INSTRUCTION");
180       break;
181
182     case EXCEPTION_IN_PAGE_ERROR:
183 //      cout << "CallHandler : EXCEPTION_IN_PAGE_ERROR:" << endl ;
184       StringCchCopyW (buffer, _countof(buffer), L"IN_PAGE ERROR");
185       break;
186
187     case EXCEPTION_INT_DIVIDE_BY_ZERO:
188 //      cout << "CallHandler : EXCEPTION_INT_DIVIDE_BY_ZERO:" << endl ;
189       StringCchCopyW (buffer, _countof(buffer), L"INTEGER DIVISION BY ZERO");
190       break;
191
192     case EXCEPTION_INT_OVERFLOW:
193 //      cout << "CallHandler : EXCEPTION_INT_OVERFLOW:" << endl ;
194       StringCchCopyW (buffer, _countof(buffer), L"INTEGER OVERFLOW");
195       break;
196
197     case EXCEPTION_INVALID_DISPOSITION:
198 //      cout << "CallHandler : EXCEPTION_INVALID_DISPOSITION:" << endl ;
199       StringCchCopyW (buffer, _countof(buffer), L"INVALID DISPOSITION");
200       break;
201
202     case EXCEPTION_NONCONTINUABLE_EXCEPTION:
203 //      cout << "CallHandler : EXCEPTION_NONCONTINUABLE_EXCEPTION:" << endl ;
204       StringCchCopyW (buffer, _countof(buffer), L"NONCONTINUABLE EXCEPTION");
205       break;
206
207     case EXCEPTION_PRIV_INSTRUCTION:
208 //      cout << "CallHandler : EXCEPTION_PRIV_INSTRUCTION:" << endl ;
209       StringCchCopyW (buffer, _countof(buffer), L"PRIVELEGED INSTRUCTION ENCOUNTERED");
210       break;
211
212     case EXCEPTION_STACK_OVERFLOW:
213 //      cout << "CallHandler : EXCEPTION_STACK_OVERFLOW:" << endl ;
214 #if defined( _MSC_VER ) && ( _MSC_VER >= 1300 ) && !defined(OCCT_UWP)
215     // try recovering from stack overflow: available in MS VC++ 7.0
216       if (!_resetstkoflw())
217         StringCchCopyW (buffer, _countof(buffer), L"Unrecoverable STACK OVERFLOW");
218       else
219 #endif
220       StringCchCopyW (buffer, _countof(buffer), L"STACK OVERFLOW");
221       break;
222
223     default:
224       StringCchPrintfW (buffer, _countof(buffer), L"unknown exception code 0x%x, params 0x%p 0x%p",
225                 dwExceptionCode, ExceptionInformation1, ExceptionInformation0 );
226
227   }  // end switch
228
229  // provide message to the user with possibility to stop
230   size_t idx;
231   StringCchLengthW (buffer, _countof(buffer),&idx);
232   if ( idx && fMsgBox && dwExceptionCode != EXCEPTION_NONCONTINUABLE_EXCEPTION ) {
233      // reset FP operations before message box, otherwise it may fail to show up
234     _fpreset();
235     _clearfp();
236
237 #if ! defined(OCCT_UWP) && !defined(__MINGW32__) && !defined(__CYGWIN32__)
238     MessageBeep ( MB_ICONHAND );
239     int aChoice = ::MessageBoxW (0, buffer, L"OCCT Exception Handler", MB_ABORTRETRYIGNORE | MB_ICONSTOP);
240     if (aChoice == IDRETRY)
241     {
242       _osd_debug();
243       DebugBreak();
244     } else if (aChoice == IDABORT)
245       exit(0xFFFF);
246 #endif
247   }
248
249   // reset FPE state
250   if ( flterr ) {
251     if ( !fFltExceptions ) return EXCEPTION_EXECUTE_HANDLER;
252    _fpreset () ;
253    _clearfp() ;
254    _controlfp ( 0, _OSD_FPX ) ;          // JR add :
255 //     cout << "OSD::WntHandler _controlfp( 0, _OSD_FPX ) " << hex << _controlfp(0,0) << dec << endl ;
256   }
257
258   char aBufferA[2048];
259   WideCharToMultiByte(CP_UTF8, 0, buffer, -1, aBufferA, sizeof(aBufferA), NULL, NULL);
260   return _osd_raise(dwExceptionCode, aBufferA);
261 }
262
263 //=======================================================================
264 //function : SIGWntHandler
265 //purpose  : Will only be used if user calls ::raise() function with
266 //           signal type set in OSD::SetSignal() - SIGSEGV, SIGFPE, SIGILL
267 //           (the latter will likely be removed in the future)
268 //=======================================================================
269 static void SIGWntHandler (int signum, int sub_code)
270 {
271   Standard_Mutex::Sentry aSentry (THE_SIGNAL_MUTEX); // lock the mutex to prevent simultaneous handling
272   switch( signum ) {
273     case SIGFPE :
274       if ( signal( signum , (void(*)(int))SIGWntHandler ) == SIG_ERR )
275         cout << "signal error" << endl ;
276       switch( sub_code ) {
277         case _FPE_INVALID :
278           CallHandler( EXCEPTION_FLT_INVALID_OPERATION ,0,0) ;
279           break ;
280         case _FPE_DENORMAL :
281           CallHandler( EXCEPTION_FLT_DENORMAL_OPERAND ,0,0) ;
282           break ;
283         case _FPE_ZERODIVIDE :
284           CallHandler( EXCEPTION_FLT_DIVIDE_BY_ZERO ,0,0) ;
285           break ;
286         case _FPE_OVERFLOW :
287           CallHandler( EXCEPTION_FLT_OVERFLOW ,0,0) ;
288           break ;
289         case _FPE_UNDERFLOW :
290           CallHandler( EXCEPTION_FLT_UNDERFLOW ,0,0) ;
291           break ;
292         case _FPE_INEXACT :
293           CallHandler( EXCEPTION_FLT_INEXACT_RESULT ,0,0) ;
294           break ;
295         default:
296           cout << "SIGWntHandler(default) -> throw Standard_NumericError(\"Floating Point Error\");" << endl;
297           THROW_OR_JUMP (Standard_NumericError, "Floating Point Error");
298           break ;
299       }
300       break ;
301     case SIGSEGV :
302       if ( signal( signum, (void(*)(int))SIGWntHandler ) == SIG_ERR )
303         cout << "signal error" << endl ;
304       CallHandler( EXCEPTION_ACCESS_VIOLATION ,0,0) ;
305       break ;
306     case SIGILL :
307       if ( signal( signum, (void(*)(int))SIGWntHandler ) == SIG_ERR )
308         cout << "signal error" << endl ;
309       CallHandler( EXCEPTION_ILLEGAL_INSTRUCTION ,0,0) ;
310       break ;
311     default:
312       cout << "SIGWntHandler unexpected signal : " << signum << endl ;
313       break ;
314   }
315 #ifndef OCCT_UWP
316   DebugBreak ();
317 #endif
318 }
319
320 //=======================================================================
321 //function : TranslateSE
322 //purpose  : Translate Structural Exceptions into C++ exceptions
323 //           Will be used when user's code is compiled with /EHa option
324 //=======================================================================
325 #ifdef _MSC_VER
326 // If this file compiled with the default MSVC options for exception
327 // handling (/GX or /EHsc) then the following warning is issued:
328 //   warning C4535: calling _set_se_translator() requires /EHa
329 // However it is correctly inserted and used when user's code compiled with /EHa.
330 // So, here we disable the warning.
331 #pragma warning (disable:4535)
332
333 static void TranslateSE( unsigned int theCode, EXCEPTION_POINTERS* theExcPtr )
334 {
335   Standard_Mutex::Sentry aSentry (THE_SIGNAL_MUTEX); // lock the mutex to prevent simultaneous handling
336   ptrdiff_t info1 = 0, info0 = 0;
337   if ( theExcPtr ) {
338     info1 = theExcPtr->ExceptionRecord->ExceptionInformation[1];
339     info0 = theExcPtr->ExceptionRecord->ExceptionInformation[0];
340   }
341   CallHandler(theCode, info1, info0);
342 }
343 #endif
344
345 //=======================================================================
346 //function : WntHandler
347 //purpose  : Will be used when user's code is compiled with /EHs
348 //           option and unless user sets his own exception handler with
349 //           ::SetUnhandledExceptionFilter().
350 //=======================================================================
351 static LONG WINAPI WntHandler (EXCEPTION_POINTERS *lpXP)
352 {
353   DWORD               dwExceptionCode = lpXP->ExceptionRecord->ExceptionCode;
354
355   return CallHandler (dwExceptionCode,
356                       lpXP->ExceptionRecord->ExceptionInformation[1],
357                       lpXP->ExceptionRecord->ExceptionInformation[0]);
358 }
359
360 //=======================================================================
361 //function : SetSignal
362 //purpose  :
363 //=======================================================================
364 void OSD::SetSignal (const Standard_Boolean theFloatingSignal)
365 {
366   Standard_Mutex::Sentry aSentry (THE_SIGNAL_MUTEX); // lock the mutex to prevent simultaneous handling
367 #if !defined(OCCT_UWP) || defined(NTDDI_WIN10_TH2)
368   OSD_Environment env ("CSF_DEBUG_MODE");
369   TCollection_AsciiString val = env.Value();
370   if (!env.Failed())
371   {
372     cout << "Environment variable CSF_DEBUG_MODE setted.\n";
373     fMsgBox = Standard_True;
374   }
375   else
376   {
377     fMsgBox = Standard_False;
378   }
379
380   // Set exception handler (ignored when running under debugger). It will be used in most cases
381   // when user's code is compiled with /EHs
382   // Replaces the existing top-level exception filter for all existing and all future threads
383   // in the calling process
384   ::SetUnhandledExceptionFilter (/*(LPTOP_LEVEL_EXCEPTION_FILTER)*/ WntHandler);
385 #endif // NTDDI_WIN10_TH2
386
387   // Signal handlers will only be used when the method ::raise() will be used
388   // Handlers must be set for every thread
389   if (signal (SIGSEGV, (void(*)(int))SIGWntHandler) == SIG_ERR)
390     cout << "signal(OSD::SetSignal) error\n";
391   if (signal (SIGFPE,  (void(*)(int))SIGWntHandler) == SIG_ERR)
392     cout << "signal(OSD::SetSignal) error\n";
393   if (signal (SIGILL,  (void(*)(int))SIGWntHandler) == SIG_ERR)
394     cout << "signal(OSD::SetSignal) error\n";
395
396   // Set Ctrl-C and Ctrl-Break handler
397   fCtrlBrk = Standard_False;
398 #ifndef OCCT_UWP
399   SetConsoleCtrlHandler (&_osd_ctrl_break_handler, TRUE);
400 #endif
401 #ifdef _MSC_VER
402 //  _se_translator_function pOldSeFunc =
403   _set_se_translator (TranslateSE);
404 #endif
405
406   fFltExceptions = theFloatingSignal;
407   if (theFloatingSignal)
408   {
409     _controlfp (0, _OSD_FPX);        // JR add :
410   }
411   else {
412     _controlfp (_OSD_FPX, _OSD_FPX); // JR add :
413   }
414 }  // end OSD :: SetSignal
415
416 //============================================================================
417 //==== ControlBreak
418 //============================================================================
419 void OSD::ControlBreak () {
420   if ( fCtrlBrk ) {
421     fCtrlBrk = Standard_False;
422     throw OSD_Exception_CTRL_BREAK ( "*** INTERRUPT ***" );
423   }
424 }  // end OSD :: ControlBreak
425
426 #ifndef OCCT_UWP
427 //============================================================================
428 //==== _osd_ctrl_break_handler
429 //============================================================================
430 static BOOL WINAPI _osd_ctrl_break_handler ( DWORD dwCode ) {
431   if ( dwCode == CTRL_C_EVENT || dwCode == CTRL_BREAK_EVENT ) {
432     MessageBeep ( MB_ICONEXCLAMATION );
433     fCtrlBrk = Standard_True;
434   } else
435     exit ( 254 );
436
437   return TRUE;
438 }  // end _osd_ctrl_break_handler
439 #endif
440
441 //============================================================================
442 //==== _osd_raise
443 //============================================================================
444 static LONG __fastcall _osd_raise ( DWORD dwCode, LPSTR msg )
445 {
446   if (msg[0] == '\x03') ++msg;
447
448   switch (dwCode)
449   {
450     case EXCEPTION_ACCESS_VIOLATION:
451       THROW_OR_JUMP (OSD_Exception_ACCESS_VIOLATION, msg);
452       break;
453     case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
454       THROW_OR_JUMP (OSD_Exception_ARRAY_BOUNDS_EXCEEDED, msg);
455       break;
456     case EXCEPTION_DATATYPE_MISALIGNMENT:
457       THROW_OR_JUMP (Standard_ProgramError, msg);
458       break;
459     case EXCEPTION_ILLEGAL_INSTRUCTION:
460       THROW_OR_JUMP (OSD_Exception_ILLEGAL_INSTRUCTION, msg);
461       break;
462     case EXCEPTION_IN_PAGE_ERROR:
463       THROW_OR_JUMP (OSD_Exception_IN_PAGE_ERROR, msg);
464       break;
465     case EXCEPTION_INT_DIVIDE_BY_ZERO:
466       THROW_OR_JUMP (Standard_DivideByZero, msg);
467       break;
468     case EXCEPTION_INT_OVERFLOW:
469       THROW_OR_JUMP (OSD_Exception_INT_OVERFLOW, msg);
470       break;
471     case EXCEPTION_INVALID_DISPOSITION:
472       THROW_OR_JUMP (OSD_Exception_INVALID_DISPOSITION, msg);
473       break;
474     case EXCEPTION_NONCONTINUABLE_EXCEPTION:
475       THROW_OR_JUMP (OSD_Exception_NONCONTINUABLE_EXCEPTION, msg);
476       break;
477     case EXCEPTION_PRIV_INSTRUCTION:
478       THROW_OR_JUMP (OSD_Exception_PRIV_INSTRUCTION, msg);
479       break;
480     case EXCEPTION_STACK_OVERFLOW:
481       THROW_OR_JUMP (OSD_Exception_STACK_OVERFLOW, msg);
482       break;
483     case EXCEPTION_FLT_DIVIDE_BY_ZERO:
484       THROW_OR_JUMP (Standard_DivideByZero, msg);
485       break;
486     case EXCEPTION_FLT_STACK_CHECK:
487     case EXCEPTION_FLT_OVERFLOW:
488       THROW_OR_JUMP (Standard_Overflow, msg);
489       break;
490     case EXCEPTION_FLT_UNDERFLOW:
491       THROW_OR_JUMP (Standard_Underflow, msg);
492       break;
493     case EXCEPTION_FLT_INVALID_OPERATION:
494     case EXCEPTION_FLT_DENORMAL_OPERAND:
495     case EXCEPTION_FLT_INEXACT_RESULT:
496     case STATUS_FLOAT_MULTIPLE_TRAPS:
497     case STATUS_FLOAT_MULTIPLE_FAULTS:
498       THROW_OR_JUMP (Standard_NumericError, msg);
499       break;
500     default:
501       break;
502   }  // end switch
503   return EXCEPTION_EXECUTE_HANDLER;
504 }  // end _osd_raise
505
506 #if ! defined(OCCT_UWP) && !defined(__MINGW32__) && !defined(__CYGWIN32__)
507 //============================================================================
508 //==== _osd_debug
509 //============================================================================
510 LONG _osd_debug ( void ) {
511
512   LONG action ;
513
514   if ( !fDbgLoaded ) {
515
516     HKEY                hKey = NULL;
517     HANDLE              hEvent = INVALID_HANDLE_VALUE;
518     DWORD               dwKeyType;
519     DWORD               dwValueLen;
520     TCHAR               keyValue[ MAX_PATH ];
521     TCHAR               cmdLine[ MAX_PATH ];
522     SECURITY_ATTRIBUTES sa;
523     PROCESS_INFORMATION pi;
524     STARTUPINFO         si;
525
526     __try {
527
528       if (  RegOpenKey (
529               HKEY_LOCAL_MACHINE,
530               TEXT( "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\AeDebug" ),
531               &hKey
532             ) != ERROR_SUCCESS
533       ) __leave;
534
535       dwValueLen = sizeof ( keyValue );
536
537       if (  RegQueryValueEx (
538              hKey, TEXT( "Debugger" ), NULL, &dwKeyType, ( unsigned char* )keyValue, &dwValueLen
539             ) != ERROR_SUCCESS
540       ) __leave;
541
542       sa.nLength              = sizeof ( SECURITY_ATTRIBUTES );
543       sa.lpSecurityDescriptor = NULL;
544       sa.bInheritHandle       = TRUE;
545
546       if (   (  hEvent = CreateEvent ( &sa, TRUE, FALSE, NULL )  ) == NULL   ) __leave;
547
548       StringCchPrintf(cmdLine, _countof(cmdLine), keyValue, GetCurrentProcessId(), hEvent);
549
550       ZeroMemory (  &si, sizeof ( STARTUPINFO )  );
551
552       si.cb      = sizeof ( STARTUPINFO );
553       si.dwFlags = STARTF_FORCEONFEEDBACK;
554
555   //   cout << "_osd_debug -> CreateProcess" << endl ;
556       if (  !CreateProcess (
557               NULL, cmdLine, NULL, NULL, TRUE, CREATE_DEFAULT_ERROR_MODE,
558               NULL, NULL, &si, &pi
559              )
560       ) __leave;
561
562   //   cout << "_osd_debug -> WaitForSingleObject " << endl ;
563       WaitForSingleObject ( hEvent, INFINITE );
564   //   cout << "_osd_debug <- WaitForSingleObject -> CloseHandle " << endl ;
565
566       CloseHandle ( pi.hProcess );
567       CloseHandle ( pi.hThread  );
568
569   //   cout << "_osd_debug fDbgLoaded  " << endl ;
570       fDbgLoaded = TRUE;
571
572     }  // end __try
573
574     __finally {
575
576 //   cout << "_osd_debug -> CloseHandle(hKey) " << endl ;
577       if ( hKey   != INVALID_HANDLE_VALUE ) CloseHandle ( hKey   );
578 //   cout << "_osd_debug -> CloseHandle(hEvent) " << endl ;
579       if ( hEvent != INVALID_HANDLE_VALUE ) CloseHandle ( hEvent );
580 //   cout << "_osd_debug end __finally " << endl ;
581
582     }  // end __finally
583
584   }  /* end if */
585
586   action = fDbgLoaded ? EXCEPTION_CONTINUE_EXECUTION : EXCEPTION_EXECUTE_HANDLER;
587 // cout << "_osd_debug return " << action << " EXCEPTION_CONTINUE_EXECUTION("
588 //      << EXCEPTION_CONTINUE_EXECUTION << ")" << endl ;
589   return action ;
590
591 }  // end _osd_debug
592 #endif /* ! OCCT_UWP && ! __CYGWIN__ && ! __MINGW32__ */
593
594 #else /* ! _WIN32 */
595
596 //---------- All Systems except Windows NT : ----------------------------------
597
598 # include <stdio.h>
599
600 #include <OSD_WhoAmI.hxx>
601 #include <OSD_SIGHUP.hxx>
602 #include <OSD_SIGINT.hxx>
603 #include <OSD_SIGQUIT.hxx>
604 #include <OSD_SIGILL.hxx>
605 #include <OSD_SIGKILL.hxx>
606 #include <OSD_SIGBUS.hxx>
607 #include <OSD_SIGSEGV.hxx>
608 #include <OSD_SIGSYS.hxx>
609 #include <Standard_NumericError.hxx>
610
611 #include <Standard_ErrorHandler.hxx>
612
613 // POSIX threads
614 #include <pthread.h>
615
616 #ifdef __linux__
617 #include  <cfenv>
618 //#include  <fenv.h>
619 static Standard_Boolean fFltExceptions = Standard_False;
620 #endif
621
622 // variable signalling that Control-C has been pressed (SIGINT signal)
623 static Standard_Boolean fCtrlBrk;
624
625 //const OSD_WhoAmI Iam = OSD_WPackage;
626
627 typedef void (ACT_SIGIO_HANDLER)(void) ;
628 ACT_SIGIO_HANDLER *ADR_ACT_SIGIO_HANDLER = NULL ;
629
630 #ifdef DECOSF1
631 typedef void (* SIG_PFV) (int);
632 #endif
633
634 #ifdef __GNUC__
635 # include <stdlib.h>
636 # include <stdio.h>
637 #else
638 #  ifdef SA_SIGINFO
639 #    ifndef _AIX
640 #  include <sys/siginfo.h>
641 #     endif
642 #  endif
643 #endif
644 typedef void (* SIG_PFV) (int);
645
646 #include <signal.h>
647
648 #if !defined(__ANDROID__) && !defined(__QNX__)
649   #include <sys/signal.h>
650 #endif
651
652 //============================================================================
653 //==== Handler
654 //====     Catche the differents signals:
655 //====          1- The Fatal signals, which cause the end of process:
656 //====          2- The exceptions which are "signaled" by Raise.
657 //====     The Fatal Signals:
658 //====        SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGKILL, SIGBUS, SIGSYS
659 //====     The Exceptions:
660 //====        SIGFPE
661 //====         (SUN versions)
662 //====           FPE_INTOVF_TRAP    // ..... integer overflow
663 //====           FPE_INTDIV_TRAP    // ..... integer divide by zero
664 //====           FPE_FLTINEX_TRAP   // ..... [floating inexact result]
665 //====           FPE_FLTDIV_TRAP    // ..... [floating divide by zero]
666 //====           FPE_FLTUND_TRAP    // ..... [floating underflow]
667 //====           FPE_FLTOPER_TRAP   // ..... [floating inexact result]
668 //====           FPE_FLTOVF_TRAP    // ..... [floating overflow]
669 //==== SIGSEGV is handled by "SegvHandler()"
670 //============================================================================
671 #ifdef SA_SIGINFO
672 static void Handler (const int theSignal, siginfo_t */*theSigInfo*/, const Standard_Address /*theContext*/)
673 #else
674 static void Handler (const int theSignal)
675 #endif
676 {
677   struct sigaction oldact, act;
678   // re-install the signal
679   if ( ! sigaction (theSignal, NULL, &oldact) ) {
680     // cout << " signal is " << theSignal << " handler is " <<  oldact.sa_handler << endl;
681     if (sigaction (theSignal, &oldact, &act)) perror ("sigaction");
682   }
683   else {
684     perror ("sigaction");
685   }
686
687   // cout << "OSD::Handler: signal " << (int) theSignal << " occured inside a try block " <<  endl ;
688   if ( ADR_ACT_SIGIO_HANDLER != NULL )
689     (*ADR_ACT_SIGIO_HANDLER)() ;
690 #ifdef __linux__
691   if (fFltExceptions)
692     feenableexcept (FE_INVALID | FE_DIVBYZERO | FE_OVERFLOW);
693     //feenableexcept (FE_INVALID | FE_DIVBYZERO);
694 #endif
695   sigset_t set;
696   sigemptyset(&set);
697   switch (theSignal) {
698   case SIGHUP:
699     OSD_SIGHUP::NewInstance("SIGHUP 'hangup' detected.")->Jump();
700     exit(SIGHUP);
701     break;
702   case SIGINT:
703     // For safe handling of Control-C as stop event, arm a variable but do not
704     // generate longjump (we are out of context anyway)
705     fCtrlBrk = Standard_True;
706     // OSD_SIGINT::NewInstance("SIGINT 'interrupt' detected.")->Jump();
707     // exit(SIGINT);
708     break;
709   case SIGQUIT:
710     OSD_SIGQUIT::NewInstance("SIGQUIT 'quit' detected.")->Jump();
711     exit(SIGQUIT);
712     break;
713   case SIGILL:
714     OSD_SIGILL::NewInstance("SIGILL 'illegal instruction' detected.")->Jump();
715     exit(SIGILL);
716     break;
717   case SIGKILL:
718     OSD_SIGKILL::NewInstance("SIGKILL 'kill' detected.")->Jump();
719     exit(SIGKILL);
720     break;
721   case SIGBUS:
722     sigaddset(&set, SIGBUS);
723     sigprocmask(SIG_UNBLOCK, &set, NULL) ;
724     OSD_SIGBUS::NewInstance("SIGBUS 'bus error' detected.")->Jump();
725     exit(SIGBUS);
726     break;
727   case SIGSEGV:
728     OSD_SIGSEGV::NewInstance("SIGSEGV 'segmentation violation' detected.")->Jump();
729     exit(SIGSEGV);
730     break;
731 #ifdef SIGSYS
732   case SIGSYS:
733     OSD_SIGSYS::NewInstance("SIGSYS 'bad argument to system call' detected.")->Jump();
734     exit(SIGSYS);
735     break;
736 #endif
737   case SIGFPE:
738     sigaddset(&set, SIGFPE);
739     sigprocmask(SIG_UNBLOCK, &set, NULL) ;
740 #ifdef DECOSF1
741     // Pour DEC/OSF1 SIGFPE = Division par zero.
742     Standard_DivideByZero::NewInstance('')->Jump;
743     break;
744 #endif
745 #if (!defined (__sun)) && (!defined(SOLARIS))
746     Standard_NumericError::NewInstance("SIGFPE Arithmetic exception detected")->Jump();
747     break;
748 #else
749     // Reste SOLARIS
750     if (aSigInfo) {
751       switch(aSigInfo->si_code) {
752       case FPE_FLTDIV_TRAP :
753         Standard_DivideByZero::NewInstance("Floating Divide By Zero")->Jump();
754         break;
755       case FPE_INTDIV_TRAP :
756         Standard_DivideByZero::NewInstance("Integer Divide By Zero")->Jump();
757         break;
758       case FPE_FLTOVF_TRAP :
759         Standard_Overflow::NewInstance("Floating Overflow")->Jump();
760         break;
761       case FPE_INTOVF_TRAP :
762         Standard_Overflow::NewInstance("Integer Overflow")->Jump();
763         break;
764       case FPE_FLTUND_TRAP :
765         Standard_NumericError::NewInstance("Floating Underflow")->Jump();
766         break;
767       case FPE_FLTRES_TRAP:
768         Standard_NumericError::NewInstance("Floating Point Inexact Result")->Jump();
769         break;
770       case FPE_FLTINV_TRAP :
771         Standard_NumericError::NewInstance("Invalid Floating Point Operation")->Jump();
772         break;
773       default:
774         Standard_NumericError::NewInstance("Numeric Error")->Jump();
775         break;
776       }
777     } else {
778       Standard_NumericError::NewInstance("SIGFPE Arithmetic exception detected")->Jump();
779     }
780 #endif
781     break;
782 #if defined (__sgi) || defined(IRIX)
783   case SIGTRAP:
784     sigaddset(&set, SIGTRAP);
785     sigprocmask(SIG_UNBLOCK, &set, NULL) ;
786     Standard_DivideByZero::NewInstance("SIGTRAP IntegerDivideByZero")->Jump(); break;
787 #endif
788   default:
789 #ifdef OCCT_DEBUG
790     cout << "Unexpected signal " << theSignal << endl ;
791 #endif
792     break;
793   }
794 }
795
796 //============================================================================
797 //==== SegvHandler
798 //============================================================================
799 #ifdef SA_SIGINFO
800
801 static void SegvHandler(const int theSignal,
802                         siginfo_t *ip,
803                         const Standard_Address theContext)
804 {
805   (void)theSignal; // silence GCC warnings
806   (void)theContext;
807
808 #ifdef __linux__
809   if (fFltExceptions)
810     feenableexcept (FE_INVALID | FE_DIVBYZERO | FE_OVERFLOW);
811     //feenableexcept (FE_INVALID | FE_DIVBYZERO);
812 #endif
813 //  cout << "OSD::SegvHandler activated(SA_SIGINFO)" << endl ;
814   if ( ip != NULL ) {
815      sigset_t set;
816      sigemptyset(&set);
817      sigaddset(&set, SIGSEGV);
818      sigprocmask (SIG_UNBLOCK, &set, NULL) ;
819      void *address = ip->si_addr ;
820      {
821        char Msg[100];
822        sprintf(Msg,"SIGSEGV 'segmentation violation' detected. Address %lx",
823          (long ) address ) ;
824        OSD_SIGSEGV::NewInstance(Msg)->Jump();
825      }
826   }
827 #ifdef OCCT_DEBUG
828   else {
829     cout << "Wrong undefined address." << endl ;
830   }
831 #endif
832   exit(SIGSEGV);
833 }
834
835 #elif defined (_hpux) || defined(HPUX)
836 // Not ACTIVE ? SA_SIGINFO is defined on SUN, OSF, SGI and HP (and Linux) !
837 // pour version 09.07
838
839 static void SegvHandler(const int theSignal,
840                         siginfo_t *ip,
841                         const Standard_Address theContext)
842 {
843   unsigned long Space  ;
844   unsigned long Offset ;
845   char Msg[100] ;
846
847   if ( theContext != NULL ) {
848     Space = ((struct sigcontext *)theContext)->sc_sl.sl_ss.ss_cr20 ;
849     Offset = ((struct sigcontext *)theContext)->sc_sl.sl_ss.ss_cr21 ;
850 //    cout << "Wrong address = " << hex(Offset) << endl ;
851     {
852       sprintf(Msg,"SIGSEGV 'segmentation violation' detected. Address %lx",Offset) ;
853       OSD_SIGSEGV::Jump(Msg);
854 //    scp->sc_pcoq_head = scp->sc_pcoq_tail ;       Permettrait de continuer a
855 //    scp->sc_pcoq_tail = scp->sc_pcoq_tail + 0x4 ; l'intruction suivant le segv.
856     }
857   }
858 #ifdef OCCT_DEBUG
859   else {
860     cout << "Wrong undefined address." << endl ;
861   }
862 #endif
863   exit(SIGSEGV);
864 }
865
866 #endif
867
868 //============================================================================
869 //==== SetSignal
870 //====     Set the differents signals:
871 //============================================================================
872
873 void OSD::SetSignal(const Standard_Boolean aFloatingSignal)
874 {
875   struct sigaction act, oact;
876   int              stat = 0;
877
878   if( aFloatingSignal ) {
879     //==== Enable the floating point exceptions ===============
880 #if defined (__sun) || defined (SOLARIS)
881     sigfpe_handler_type PHandler = (sigfpe_handler_type) Handler ;
882     stat = ieee_handler("set", "invalid",  PHandler);
883     stat = ieee_handler("set", "division", PHandler) || stat;
884     stat = ieee_handler("set", "overflow", PHandler) || stat;
885
886     //stat = ieee_handler("set", "underflow", PHandler) || stat;
887     //stat = ieee_handler("set", "inexact", PHandler) || stat;
888
889     if (stat) {
890 #ifdef OCCT_DEBUG
891       cerr << "ieee_handler does not work !!! KO " << endl;
892 #endif
893     }
894 #elif defined (__linux__)
895     feenableexcept (FE_INVALID | FE_DIVBYZERO | FE_OVERFLOW);
896     fFltExceptions = Standard_True;
897 #endif
898   }
899   else
900   {
901 #if defined (__linux__)
902     fedisableexcept (FE_INVALID | FE_DIVBYZERO | FE_OVERFLOW);
903     fFltExceptions = Standard_False;
904 #endif
905   }
906
907 #if defined (sgi) || defined (IRIX )
908  char *TRAP_FPE = getenv("TRAP_FPE") ;
909  if ( TRAP_FPE == NULL ) {
910 #ifdef OCCT_DEBUG
911    cout << "On SGI you must set TRAP_FPE environment variable : " << endl ;
912    cout << "set env(TRAP_FPE) \"UNDERFL=FLUSH_ZERO;OVERFL=DEFAULT;DIVZERO=DEFAULT;INT_OVERFL=DEFAULT\" or" << endl ;
913    cout << "setenv TRAP_FPE \"UNDERFL=FLUSH_ZERO;OVERFL=DEFAULT;DIVZERO=DEFAULT;INT_OVERFL=DEFAULT\"" << endl ;
914 #endif
915  }
916 #endif
917
918   //==== Save the old Signal Handler, and set the new one ===================
919
920   sigemptyset(&act.sa_mask) ;
921
922 #ifdef SA_RESTART
923   act.sa_flags   = SA_RESTART ;
924 #else
925   act.sa_flags   = 0 ;
926 #endif
927 #ifdef SA_SIGINFO
928   act.sa_flags = act.sa_flags | SA_SIGINFO ;
929   act.sa_sigaction = /*(void(*)(int, siginfo_t *, void*))*/ Handler;
930 #else
931   act.sa_handler = /*(SIG_PFV)*/ Handler;
932 #endif
933
934   //==== Always detected the signal "SIGFPE" =================================
935   stat = sigaction(SIGFPE,&act,&oact);   // ...... floating point exception
936   if (stat) {
937 #ifdef OCCT_DEBUG
938      cerr << "sigaction does not work !!! KO " << endl;
939 #endif
940      perror("sigaction ");
941   }
942
943   //==== Detected the only the "free" signals ================================
944   sigaction(SIGHUP,&act,&oact);    // ...... hangup
945
946 #ifdef OBJS
947   if(oact.sa_handler)
948         sigaction(SIGHUP,&oact,&oact);
949 #endif
950
951   sigaction(SIGINT,&act,&oact);   // ...... interrupt
952
953 #ifdef OBJS
954   if(oact.sa_handler)
955         sigaction(SIGINT,&oact,&oact);
956 #endif
957
958   sigaction(SIGQUIT,&act,&oact);  // ...... quit
959
960 #ifdef OBJS
961   if(oact.sa_handler)
962         sigaction(SIGQUIT,&oact,&oact);
963 #endif
964
965   sigaction(SIGILL,&act,&oact);   // ...... illegal instruction
966
967 #ifdef OBJS
968   if(oact.sa_handler)
969         sigaction(SIGILL,&oact,&oact);
970 #endif
971
972   sigaction(SIGBUS,&act,&oact);   // ...... bus error
973
974 #ifdef OBJS
975   if(oact.sa_handler)
976         sigaction(SIGBUS,&oact,&oact);
977 #endif
978
979 #if !defined(__linux__)
980   sigaction(SIGSYS,&act,&oact);   // ...... bad argument to system call
981
982 # ifdef OBJS
983   if(oact.sa_handler)
984         sigaction(SIGSYS,&oact,&oact);
985 # endif
986 #endif
987
988 #if defined (__sgi) || defined(IRIX)
989   sigaction(SIGTRAP,&act,&oact);   // Integer Divide By Zero (IRIX)
990
991 # ifdef OBJS
992   if(oact.sa_handler)
993         sigaction(SIGTRAP,&oact,&oact);
994 # endif
995 #endif
996
997 #ifdef SA_SIGINFO
998   act.sa_sigaction = /*(void(*)(int, siginfo_t *, void*))*/ SegvHandler;
999 #else
1000   act.sa_handler = /*(SIG_PFV)*/ SegvHandler;
1001 #endif
1002
1003   if ( sigaction( SIGSEGV , &act , &oact ) )  // ...... segmentation violation
1004     perror("OSD::SetSignal sigaction( SIGSEGV , &act , &oact ) ") ;
1005
1006 #ifdef OBJS
1007   if(oact.sa_handler)
1008         sigaction(SIGSEGV,&oact,&oact);
1009 #endif
1010 #if defined(__osf__) || defined(DECOSF1)
1011    struct sigaction action, prev_action;
1012    action.sa_handler = SIG_IGN;
1013    action.sa_mask = 0;
1014    action.sa_flags = 0;
1015
1016    if (sigaction (SIGFPE, &action, &prev_action) == -1) {
1017      perror ("sigaction");
1018      exit (1);
1019    }
1020 #endif
1021
1022 }
1023
1024 //============================================================================
1025 //==== ControlBreak
1026 //============================================================================
1027
1028 void OSD :: ControlBreak ()
1029 {
1030   if ( fCtrlBrk ) {
1031     fCtrlBrk = Standard_False;
1032     throw OSD_Exception_CTRL_BREAK ("*** INTERRUPT ***");
1033   }
1034 }
1035
1036 #endif