git.oblomov.eu Git - wine/blob - dlls/msvcrt/except.c

   1 /*
   2  * msvcrt.dll exception handling
   3  *
   4  * Copyright 2000 Jon Griffiths
   5  *
   6  * See http://www.microsoft.com/msj/0197/exception/exception.htm,
   7  * but don't believe all of it.
   8  *
   9  * FIXME: Incomplete support for nested exceptions/try block cleanup.
  10  */
  11 #include "config.h"
  12
  13 #include "ntddk.h"
  14 #include "wine/exception.h"
  15 #include "thread.h"
  16 #include "msvcrt.h"
  17
  18 DEFAULT_DEBUG_CHANNEL(msvcrt);
  19
  20 typedef void (*MSVCRT_sig_handler_func)(void);
  21
  22 /* VC++ extensions to Win32 SEH */
  23 typedef struct _SCOPETABLE
  24 {
  25   DWORD previousTryLevel;
  26   int (*lpfnFilter)(PEXCEPTION_POINTERS);
  27   int (*lpfnHandler)(void);
  28 } SCOPETABLE, *PSCOPETABLE;
  29
  30 typedef struct _MSVCRT_EXCEPTION_FRAME
  31 {
  32   EXCEPTION_FRAME *prev;
  33   void (*handler)(PEXCEPTION_RECORD, PEXCEPTION_FRAME,
  34                   PCONTEXT, PEXCEPTION_RECORD);
  35   PSCOPETABLE scopetable;
  36   DWORD trylevel;
  37   int _ebp;
  38   PEXCEPTION_POINTERS xpointers;
  39 } MSVCRT_EXCEPTION_FRAME;
  40
  41 #define TRYLEVEL_END 0xff /* End of trylevel list */
  42
  43 #if defined(__GNUC__) && defined(__i386__)
  44
  45 #define CALL_FINALLY_BLOCK(code_block, base_ptr) \
  46   __asm__ __volatile__ ("movl %0,%%eax; movl %1,%%ebp; call *%%eax" \
  47                         : : "g" (code_block), "g" (base_ptr))
  48
  49 static DWORD MSVCRT_nested_handler(PEXCEPTION_RECORD rec,
  50                                    struct __EXCEPTION_FRAME* frame,
  51                                    PCONTEXT context WINE_UNUSED,
  52                                    struct __EXCEPTION_FRAME** dispatch)
  53 {
  54   if (rec->ExceptionFlags & 0x6)
  55     return ExceptionContinueSearch;
  56   *dispatch = frame;
  57   return ExceptionCollidedUnwind;
  58 }
  59 #endif
  60
  61
  62 /*********************************************************************
  63  *              _XcptFilter (MSVCRT.@)
  64  */
  65 int _XcptFilter(int ex, PEXCEPTION_POINTERS ptr)
  66 {
  67   FIXME("(%d,%p)semi-stub\n", ex, ptr);
  68   return UnhandledExceptionFilter(ptr);
  69 }
  70
  71 /*********************************************************************
  72  *              _EH_prolog (MSVCRT.@)
  73  */
  74 #ifdef __i386__
  75 /* Provided for VC++ binary compatability only */
  76 __ASM_GLOBAL_FUNC(_EH_prolog,
  77                   "pushl $0xff\n\t"
  78                   "pushl %eax\n\t"
  79                   "pushl %fs:0\n\t"
  80                   "movl  %esp, %fs:0\n\t"
  81                   "movl  12(%esp), %eax\n\t"
  82                   "movl  %ebp, 12(%esp)\n\t"
  83                   "leal  12(%esp), %ebp\n\t"
  84                   "pushl %eax\n\t"
  85                   "ret");
  86 #endif
  87
  88 /*******************************************************************
  89  *              _global_unwind2 (MSVCRT.@)
  90  */
  91 void _global_unwind2(PEXCEPTION_FRAME frame)
  92 {
  93     TRACE("(%p)\n",frame);
  94     RtlUnwind( frame, 0, 0, 0 );
  95 }
  96
  97 /*******************************************************************
  98  *              _local_unwind2 (MSVCRT.@)
  99  */
 100 void _local_unwind2(MSVCRT_EXCEPTION_FRAME* frame,
 101                     DWORD trylevel)
 102 {
 103   MSVCRT_EXCEPTION_FRAME *curframe = frame;
 104   DWORD curtrylevel = 0xfe;
 105   EXCEPTION_FRAME reg;
 106
 107   TRACE("(%p,%ld,%ld)\n",frame, frame->trylevel, trylevel);
 108
 109   /* Register a handler in case of a nested exception */
 110   reg.Handler = (PEXCEPTION_HANDLER)MSVCRT_nested_handler;
 111   reg.Prev = NtCurrentTeb()->except;
 112   __wine_push_frame(&reg);
 113
 114   while (frame->trylevel != TRYLEVEL_END && frame->trylevel != trylevel)
 115   {
 116     curtrylevel = frame->scopetable[frame->trylevel].previousTryLevel;
 117     curframe = frame;
 118     curframe->trylevel = curtrylevel;
 119     if (!frame->scopetable[curtrylevel].lpfnFilter)
 120     {
 121       ERR("__try block cleanup not implemented - expect crash!\n");
 122       /* FIXME: Remove current frame, set ebp, call
 123        * frame->scopetable[curtrylevel].lpfnHandler()
 124        */
 125     }
 126   }
 127   __wine_pop_frame(&reg);
 128   TRACE("unwound OK\n");
 129 }
 130
 131 /*********************************************************************
 132  *              _except_handler2 (MSVCRT.@)
 133  */
 134 int _except_handler2(PEXCEPTION_RECORD rec,
 135                      PEXCEPTION_FRAME frame,
 136                      PCONTEXT context,
 137                      PEXCEPTION_FRAME* dispatcher)
 138 {
 139   FIXME("exception %lx flags=%lx at %p handler=%p %p %p stub\n",
 140         rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress,
 141         frame->Handler, context, dispatcher);
 142   return ExceptionContinueSearch;
 143 }
 144
 145 /*********************************************************************
 146  *              _except_handler3 (MSVCRT.@)
 147  */
 148 int _except_handler3(PEXCEPTION_RECORD rec,
 149                      MSVCRT_EXCEPTION_FRAME* frame,
 150                      PCONTEXT context, void* dispatcher)
 151 {
 152 #if defined(__GNUC__) && defined(__i386__)
 153   long retval, trylevel;
 154   EXCEPTION_POINTERS exceptPtrs;
 155   PSCOPETABLE pScopeTable;
 156
 157   TRACE("exception %lx flags=%lx at %p handler=%p %p %p semi-stub\n",
 158         rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress,
 159         frame->handler, context, dispatcher);
 160
 161   __asm__ __volatile__ ("cld");
 162
 163   if (rec->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND))
 164   {
 165     /* Unwinding the current frame */
 166      _local_unwind2(frame, TRYLEVEL_END);
 167     return ExceptionContinueSearch;
 168   }
 169   else
 170   {
 171     /* Hunting for handler */
 172     exceptPtrs.ExceptionRecord = rec;
 173     exceptPtrs.ContextRecord = context;
 174     *((DWORD *)frame-1) = (DWORD)&exceptPtrs;
 175     trylevel = frame->trylevel;
 176     pScopeTable = frame->scopetable;
 177
 178     while (trylevel != TRYLEVEL_END)
 179     {
 180       if (pScopeTable[trylevel].lpfnFilter)
 181       {
 182         TRACE("filter = %p\n", pScopeTable[trylevel].lpfnFilter);
 183
 184         retval = pScopeTable[trylevel].lpfnFilter(&exceptPtrs);
 185
 186         TRACE("filter returned %s\n", retval == EXCEPTION_CONTINUE_EXECUTION ?
 187               "CONTINUE_EXECUTION" : retval == EXCEPTION_EXECUTE_HANDLER ?
 188               "EXECUTE_HANDLER" : "CONTINUE_SEARCH");
 189
 190         if (retval == EXCEPTION_CONTINUE_EXECUTION)
 191           return ExceptionContinueExecution;
 192
 193         if (retval == EXCEPTION_EXECUTE_HANDLER)
 194         {
 195           /* Unwind all higher frames, this one will handle the exception */
 196           _global_unwind2((PEXCEPTION_FRAME)frame);
 197           _local_unwind2(frame, trylevel);
 198
 199           /* Set our trylevel to the enclosing block, and call the __finally
 200            * code, which won't return
 201            */
 202           frame->trylevel = pScopeTable->previousTryLevel;
 203           TRACE("__finally block %p\n",pScopeTable[trylevel].lpfnHandler);
 204           CALL_FINALLY_BLOCK(pScopeTable[trylevel].lpfnHandler, frame->_ebp);
 205           ERR("Returned from __finally block - expect crash!\n");
 206        }
 207       }
 208       trylevel = pScopeTable->previousTryLevel;
 209     }
 210   }
 211 #else
 212   TRACE("exception %lx flags=%lx at %p handler=%p %p %p stub\n",
 213         rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress,
 214         frame->handler, context, dispatcher);
 215 #endif
 216   return ExceptionContinueSearch;
 217 }
 218
 219 /*********************************************************************
 220  *              _abnormal_termination (MSVCRT.@)
 221  */
 222 int _abnormal_termination(void)
 223 {
 224   FIXME("(void)stub\n");
 225   return 0;
 226 }
 227
 228 /*******************************************************************
 229  *              _setjmp (MSVCRT.@)
 230  */
 231 int MSVCRT__setjmp(LPDWORD* jmpbuf)
 232 {
 233   FIXME(":(%p): stub\n",jmpbuf);
 234   return 0;
 235 }
 236
 237 /*******************************************************************
 238  *              _setjmp3 (MSVCRT.@)
 239  */
 240 int __cdecl MSVCRT__setjmp3(LPDWORD *jmpbuf, int x)
 241 {
 242   FIXME(":(%p %x): stub\n",jmpbuf,x);
 243   return 0;
 244 }
 245
 246 /*********************************************************************
 247  *              longjmp (MSVCRT.@)
 248  */
 249 void MSVCRT_longjmp(jmp_buf env, int val)
 250 {
 251   FIXME("MSVCRT_longjmp semistub, expect crash\n");
 252   longjmp(env, val);
 253 }
 254
 255 /*********************************************************************
 256  *              signal (MSVCRT.@)
 257  */
 258 void* MSVCRT_signal(int sig, MSVCRT_sig_handler_func func)
 259 {
 260   FIXME("(%d %p):stub\n", sig, func);
 261   return (void*)-1;
 262 }