Changeset 475

Timestamp:

01/05/11 22:09:15 (14 years ago)

Author:

Don Clugston

Message:

Added a brief explanation of Windows SEH, which is incredibly poorly documented by Microsoft, together with an explanation of the DMD/DMC implementation. The code is practically incomprehensible without this.
Also cleaned up variable naming scheme. No change to generated code.

Files:

• trunk/src/rt/deh.d (modified) (9 diffs)

trunk/src/rt/deh.d

@@ -15 +15 @@
-import core.sys.windows.windows;
-//import core.stdc.stdio;
-
-enum EXCEPTION_DISPOSITION {
-    ExceptionContinueExecution,
-    ExceptionContinueSearch,
-    ExceptionNestedException,
-    ExceptionCollidedUnwind
-}
-
+/+
-enum {
-    EXCEPTION_EXECUTE_HANDLER    = 1,
-    EXCEPTION_CONTINUE_SEARCH    = 0,
-    EXCEPTION_CONTINUE_EXECUTION = -1
-}
++/
-
-extern(Windows)
-{
-void RaiseException(DWORD, DWORD, DWORD, void *);
-}
-
-// used in EXCEPTION_RECORD
-enum : DWORD {
-    STATUS_WAIT_0                      = 0,
-    STATUS_ABANDONED_WAIT_0            = 0x00000080,
@@ -161 +163 @@
-
-enum EXCEPTION_UNWIND = 6;  // Flag to indicate if the system is unwinding
-
-/* Windows Kernel function to initiate a system unwind.
-
-  Documentation for this function is severely lacking.
-  http://www.nynaeve.net/?p=99 states that the MSDN documentation is incorrect,
-    and gives a corrected form, but it's for x86_64 only.
-  http://www.microsoft.com/msj/0197/exception/exception.aspx says that it was
-    undocumented in 1997.
-  Presumably DMC reverse-engineered it, because it got the signature of this 
-    function wrong!!
-  The pExceptRec is what will be passed to the language specific handler.
-  According to MSJ, the targetIp value is unused on Win32.
-  The 'valueForEAX' parameter should always be 0.
- */
-extern(Windows)
-void RtlUnwind(void *targetFrame, void *targetIp, EXCEPTION_RECORD *pExceptRec, void *valueForEAX);
-
-alias int function() fp_t; // function pointer in ambient memory model
-
-extern(C)
-{ 
-
+ // This is just FS:[0]
-}
-
-extern(C)
-{
-void _d_setUnhandled(Object);
-void _d_createTrace(Object);
-int _d_isbaseof(ClassInfo b, ClassInfo c);
-}
+
+/+
+
+Implementation of Structured Exception Handling in DMD-Windows
+
+Every function which uses exception handling (a 'frame') has a thunk created
+for it. This thunk is the 'language-specific handler'.
+The thunks are created in the DMD backend, in nteh_framehandler() in nteh.c.
+These thunks are of the form:
+      MOV     EAX,&scope_table
+      JMP     __d_framehandler
+FS:[0] contains a singly linked list of all active handlers (they'll all be
+thunks). The list is created on the stack. 
+At the end of this list is _except_handler3, a function in the DMC library.
+Its signature is:
+
+extern(C)
+EXCEPTION_DISPOSITION _except_handler3(EXCEPTION_RECORD *eRecord,
+    DEstablisherFrame * frame,CONTEXT *context,void *dispatchercontext);
+
+It may be unnecessary. I think it is included for compatibility with MSVC
+exceptions?
+
+Documentation of Windows SEH is hard to find. Here is a brief explanation:
+
+When an exception is raised, the OS calls each handler in the FS:[0] list in
+turn, looking for a catch block. It continues moving down the list, as long as
+each handler indicates that it has not caught the exception. When a handler is
+ready to catch the exception, it calls the OS function RtlUnwind.
+This calls each function in the FS:[0] list again, this time indicating that it
+is a 'unwind' call. All of the intervening finally blocks are run at this time.
+The complicated case is a CollidedException, which happens when a finally block
+throws an exception. The new exception needs to either replace the old one, or
+be chained to the old one.
+
+The other complexity comes from the fact that a single function may have
+multiple try/catch/finally blocks. Hence, there's a 'handler table' created for
+each function which uses exceptions.
++/
-
-// The layout of DEstablisherFrame is the same for C++
-
-struct DEstablisherFrame
-{
-    void *prev;                 // pointer to previous exception list
-    void *handler;              // pointer to routine for exception handler
-    DWORD table_index;          // current index into handler_info[]
-    DWORD ebp;                  // this is EBP of routine
-};
@@ -227 +266 @@
-};
-
-// Create one of these for each try-catch
-struct DCatchInfo
-{
-    uint ncatches;                  // number of catch blocks
-    DCatchBlock catch_block[1];  // data for each catch block
-};
-
-// Macro to make our own exception code
-
+
+
-        enum int MAKE_EXCEPTION_CODE = (((severity) << 30) | (1 << 29) | (0 << 28) | ((facility) << 16) | (exception));
-}
-enum int STATUS_DIGITAL_MARS_D_EXCEPTION = MAKE_EXCEPTION_CODE!(3,'D',1);
-
-
-/***********************************
- * The frame handler, this is called for each frame that has been registered
- * in the OS except_list.
- * Input:
- *      EAX     the handler table for the frame
- */
-extern(C)
-EXCEPTION_DISPOSITION _d_framehandler(
-_r
+R
-            DEstablisherFrame *frame,
-            CONTEXT *context,
-_c
-
-_t
-
-_t
-
-_r
+C
+
+T
+
+T
+
+R
-    {
-         // Call all the finally blocks in this frame
-_t
+T
-    }
-    else
-    {
-        // Jump to catch block if matching one is found
-        int ndx,prev_ndx,i;
-        DHandlerInfo *phi;
-        DCatchInfo *pci;
-        DCatchBlock *pcb;
-        uint ncatches;              // number of catches in the current handler
-        Object pti;
-        ClassInfo ci;
-
-        ci = null;                      // only compute it if we need it
-
-        // walk through handler table, checking each handler
-        // with an index smaller than the current table_index
-        for (ndx = frame.table_index; ndx != -1; ndx = prev_ndx)
-        {
-_t
+T
-            prev_ndx = phi.prev_index;
-            if (phi.cioffset)
-            {
-                // this is a catch handler (no finally)
-_t
+T
-                ncatches = pci.ncatches;
-                for (i = 0; i < ncatches; i++)
-                {
-                    pcb = &pci.catch_block[i];
-
-                    if (!ci)
-                    {
-                        // This code must match the translation code
-_r
+R
-                        {
-_r
-_r
+R
+R
-                        }
-                        else
-                            ci = Throwable.typeinfo;
-                    }
-                    if (_d_isbaseof(ci, pcb.type))
-                    {
-                        // Matched the catch type, so we've found the handler.
-                        int regebp;
-
-_r
+R
-
-                        // Initialize catch variable
-                        regebp = cast(int)&frame.ebp;              // EBP for this frame
-                        *cast(Object *)(regebp + (pcb.bpoffset)) = pti;
-
-                        _d_setUnhandled(pti);
-
-                        // Have system call all finally blocks in intervening frames
-_r
+R
-
-                        // Call all the finally blocks skipped in this frame
-_t
+T
-
-                        _d_setUnhandled(null);
-
-                        frame.table_index = prev_ndx;  // we are out of this handler
-
-                        // Jump to catch block. Does not return.
-                        {
-                            uint catch_esp;
-                            fp_t catch_addr;
-
-                            catch_addr = cast(fp_t)(pcb.code);
-_t
+T
-                            asm
-                            {
-                                mov     EAX,catch_esp;
-                                mov     ECX,catch_addr;
-                                mov     [EAX],ECX;
-                                mov     EBP,regebp;
-                                mov     ESP,EAX;         // reset stack
-                                ret;                     // jump to catch block
-                            }
-                        }
@@ -349 +390 @@
-    return EXCEPTION_DISPOSITION.ExceptionContinueSearch;
-}
-
-/***********************************
- * Exception filter for use in __try..__except block
- * surrounding call to Dmain()
- */
-
-int _d_exception_filter(EXCEPTION_POINTERS *eptrs,
-                        int retval,
-_o
-
-_o
+O
+
+O
-    return retval;
-}
-
-/***********************************
- * Throw a D object.
- */
-extern(C)
-void _d_throwc(Object h)
-{
-    //printf("_d_throw(h = %p, &h = %p)\n", h, &h);
@@ -374 +415 @@
-    //_d_setUnhandled(h);
-    RaiseException(STATUS_DIGITAL_MARS_D_EXCEPTION,
-                   EXCEPTION_NONCONTINUABLE,
-                   1, cast(void *)&h);
-}
-
-/***********************************
- * Converts a Windows Structured Exception code to a D Exception Object.
- */
-
-_r
+R
-{
-    Object pti;
-   // BUG: what if _d_newclass() throws an out of memory exception?
-
-_r
+R
-        case STATUS_DIGITAL_MARS_D_EXCEPTION:
-            // Generated D exception
-_r
+R
-            break;
-
-        case STATUS_INTEGER_DIVIDE_BY_ZERO:
-            pti = new Error("Integer Divide by Zero");
-            break;
-
-        case STATUS_FLOAT_DIVIDE_BY_ZERO:
-            pti = new Error("Float Divide by Zero");
-            break;
-
@@ -434 +475 @@
-
-        case STATUS_FLOAT_UNDERFLOW:
-            pti = new Error("Floating Point Underflow");
-            break;
-
-        case STATUS_FLOAT_STACK_CHECK:
-            pti = new Error("Floating Point Stack Check");
-            break;
-
-        case STATUS_PRIVILEGED_INSTRUCTION:
-_r
+R
-                pti = new Error("assert(0) or HLT instruction");
-            } else {
-                pti = new Error("Privileged Instruction");
-            }
-            break;
-
-        case STATUS_ILLEGAL_INSTRUCTION:
-            pti = new Error("Illegal Instruction");
-            break;
-
@@ -475 +516 @@
-            break;
-    }
-    _d_createTrace(pti);
-    return pti;
-}
-
-/+
-  These next two functions are necessary for dealing with collided exceptions:
-  when an exception has been thrown during unwinding. This happens for example
-  when a throw statement was encountered inside a finally clause.
-
-  A description of the equivalent situation for x86_64 is given at 
-  http://www.nynaeve.net/?p=107, which states:
-      This, in effect, requires that the compiler stop the current unwind operation
-      and transfer control to the target location (which is usually within the
-      function that contained the __finally that the programmer jumped out of).
-      Nevertheless, the compiler still has to deal with the fact that it has been
-      called in the context of an unwind operation, and as such it needs a way
-      to 'break out' of the unwind call stack. This is done by executing a 
-      'local unwind', or an unwind to a location within the current function.
-       In order to do this, the compiler calls a small, runtime-supplied helper
-      function known as local_unwind. This function is described below, and is essentially
-      an extremely thin wrapper around RtlUnwindEx that, in practice, adds no value other
-      than providing some default argument values (and scratch space on the stack
-      for RtlUnwindEx to use to store a CONTEXT structure).
-   [snip brief asm code]
-      When the compiler calls local_unwind as a result of the programmer
-      breaking out of a __finally block in some fashion, then execution will
-      eventually end up in RtlUnwindEx. From there, RtlUnwindEx eventually
-      detects the operation as a collided unwind, once it unwinds past the
-      original call to the original unwind handler that started the new unwind
-      operation via local_unwind.
-
-+/
-
-extern(C)
-EXCEPTION_DISPOSITION unwindCollisionExceptionHandler(
-            EXCEPTION_RECORD *ExceptionRecord,
-            DEstablisherFrame *frame,
-            CONTEXT *context,
-            void *dispatcherContext)
-{
-    if (!(ExceptionRecord.ExceptionFlags & EXCEPTION_UNWIND)) 
@@ -577 +595 @@
-}
-
-/+ According to http://www.microsoft.com/msj/0197/exception/exception.aspx, 
-global unwind is just a thin wrapper around RtlUnwind.
-__global_unwind(void * pRegistFrame)
- {
-     _RtlUnwind( pRegistFrame,
-                 &__ret_label,
-                 0, 0 );
-     __ret_label:
+  }
+Apparently Win32 doesn't use the return address anyway.
-
-This code seems to be calling RtlUnwind( pFrame, &__retlabel, eRecord, 0);
-Apparently Win32 doesn't use the return address anyway.
-}
-
-+/
-extern(C)
-int _d_global_unwind(DEstablisherFrame *pFrame, EXCEPTION_RECORD *eRecord)
-{
-    asm {
-        naked;
-        push EBP;
-        mov EBP,ESP;
-        push ECX;
-        push EBX;
@@ -636 +653 @@
-
-/***********************************
- * The frame handler, this is called for each frame that has been registered
- * in the OS except_list.
- * Input:
- *      EAX     the handler table for the frame
- */
-
-extern(C)
-EXCEPTION_DISPOSITION _d_monitor_handler(
-_r
+R
-            DEstablisherFrame *frame,
-            CONTEXT *context,
-_c
-
-_r
+C
+
+R
-    {
-        _d_monitorexit(cast(Object)cast(void *)frame.table_index);
-    }
-    else
-    {
-    }
-    return EXCEPTION_DISPOSITION.ExceptionContinueSearch;
-}
-
-/***********************************