Changeset 503

Timestamp:

01/11/11 20:50:01 (14 years ago)

Author:

Don Clugston

Message:

Implements TDPL exception chaining for Windows, using the rule that a chain can be caught if and only if every member of the chain could be caught individually.

Files:

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

trunk/src/rt/deh.d

@@ -155 +155 @@
-}
-alias EXCEPTION_RECORD* PEXCEPTION_RECORD, LPEXCEPTION_RECORD;
-
-struct EXCEPTION_POINTERS {
-    PEXCEPTION_RECORD ExceptionRecord;
-    PCONTEXT          ContextRecord;
-}
-alias EXCEPTION_POINTERS* PEXCEPTION_POINTERS, LPEXCEPTION_POINTERS;
-
-enum EXCEPTION_UNWIND = 6;  // Flag to indicate if the system is unwinding
+/+ Values used by Microsoft for Itanium and Win64 are:
+#define EXCEPTION_NONCONTINUABLE   0x0001
+#define EXCEPTION_UNWINDING        0x0002
+#define EXCEPTION_EXIT_UNWIND      0x0004
+#define EXCEPTION_STACK_INVALID    0x0008
+#define EXCEPTION_NESTED_CALL      0x0010
+#define EXCEPTION_TARGET_UNWIND    0x0020
+#define EXCEPTION_COLLIDED_UNWIND  0x0040
+#define EXCEPTION_UNWIND           0x0066
+
+@@@ BUG @@@
+We don't have any guarantee that this bit will remain available. Unfortunately,
+it seems impossible to implement exception handling at all, without relying on
+undocumented behaviour in several places.
++/
+enum EXCEPTION_COLLATERAL = 0x100; // Flag used to implement TDPL exception chaining
-
-/* 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.
-  The pExceptRec is what will be passed to the language specific handler.
-  According to MSJ, the targetIp value is unused on Win32.
@@ -297 +313 @@
-    DHandlerInfo handler_info[1];
-};
-
-struct DCatchBlock
-{
-    ClassInfo type;            // catch type
-    uint bpoffset;          // EBP offset of catch var
-    void *code;                 // catch handler code
-};
-
-Create one of these
+One of these is created
-struct DCatchInfo
-{
-    uint ncatches;                  // number of catch blocks
-    DCatchBlock catch_block[1];  // data for each catch block
-};
-
-// Macro to make our own exception code
-template MAKE_EXCEPTION_CODE(int severity, int facility, int exception)
-{
-        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);
+
+/* Head of a linked list of all exceptions which are in flight.
+ * This is used to implement exception chaining as described in TDPL.
+ * Central to making chaining work correctly is that chaining must only occur
+ * when a collision occurs (not merely when two exceptions are in flight,
+ * because one may be caught before it has any effect on the other).
+ *
+ * The 'ExceptionRecord' member of the EXCEPTION_RECORD struct is used to
+ * store a link to the earlier member on the list.
+ * All exceptions which have found their catch handler are linked into this
+ * list. The exceptions which collided are marked by setting a bit in the
+ * ExceptionFlags. I've called this bit EXCEPTION_COLLATERAL. It has never
+ * been used by Microsoft.
+ *
+ * Every member of the list will either eventually collide with the next earlier
+ * exception, having its EXCEPTION_COLLATERAL bit set, or else will be caught.
+ * If it is caught, a D exception object is created, containing all of the
+ * collateral exceptions,
+ *
+ * There are many subtleties in this design:
+ * (1) The exception records are all on the stack, so it's not possible to
+ * modify them very much. In particular, we have very little choice about how
+ * unwinding works, so we have to leave all the exception records essentially
+ * intact.
+ * (2) The length of an exception record is not constant. System exceptions
+ * are shorter than D exceptions, for example.
+ * (3) System exceptions don't have any space for a pointer to a D object.
+ * So we cannot store the collision information in the exception record.
+ * (4) it's important that this list is thread-local.
+ *
+ * Every member of this list will suffer one of two fates:
+ * (1) it will be caught successfully.
+ *    In this case it is popped from the list.
+ *    The previous head of the list, and the previous Throwable chain, are restored.
+ * (2) it will collide with the previous exception.
+ *    In this case, it gets added to the active Throwable chain, and then discarded.
+ * (in which case its Throwable chain will be added to the Throwable chain of
+ * the previous exception, and then this exception will be popped from the list).
+ *
+ * Note:
+ */
+
+EXCEPTION_RECORD * inflightExceptionList = null;
+
+/***********************************
+ * Find the first non-collateral exception in the list. If the last
+ * entry in the list has the EXCEPTION_COLLATERAL bit set, it means
+ * that this fragment will collide with the top exception in the
+ * inflightException list.
+ */
+EXCEPTION_RECORD *skipCollateralExceptions(EXCEPTION_RECORD *n)
+{
+    while ( n.ExceptionRecord && n.ExceptionFlags & EXCEPTION_COLLATERAL )
+    {
+        n = n.ExceptionRecord;
+    }
+    return n;
+}
+
-
-/***********************************
- * 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(
-            EXCEPTION_RECORD *exceptionRecord,
@@ -360 +435 @@
-            phi = &handlerTable.handler_info[ndx];
-            prev_ndx = phi.prev_index;
-            if (phi.cioffset)
-            {
-                // this is a catch handler (no finally)
-                pci = cast(DCatchInfo *)(cast(ubyte *)handlerTable + phi.cioffset);
-                ncatches = pci.ncatches;
-                for (i = 0; i < ncatches; i++)
-                {
-                    pcb = &pci.catch_block[i];
-
-
+
+
+
+
-                    {
-
-
+
-                        {
-
-
+
+
+
+
+
+
+
+
-                        }
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                    {
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                        int regebp;
-
-                        pti = _d_translate_se_to_d_exception(exceptionRecord);
-
-                        // 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
-                        _d_global_unwind(frame, exceptionRecord);
-                        
-                        // Call all the finally blocks skipped in this frame
-                        _d_local_unwind(handlerTable, frame, ndx, &searchCollisionExceptionHandler);
-
-                        _d_setUnhandled(null);
-
-                        frame.table_index = prev_ndx;  // we are out of this handler
-
-                        // Jump to catch block. Does not return.
-                        {
-                            uint catch_esp;
-                            alias void function() fp_t; // generic function pointer
-                            fp_t catch_addr = cast(fp_t)(pcb.code);
-                            catch_esp = regebp - handlerTable.espoffset - fp_t.sizeof;
-                            asm
-                            {
-                                mov     EAX,catch_esp;
@@ -576 +698 @@
-So, we need to restart from 'frame.prev'.
-*/
-
-extern (C)
-EXCEPTION_DISPOSITION searchCollisionExceptionHandler(
-            EXCEPTION_RECORD *exceptionRecord,
-            DEstablisherFrame *frame,
-            CONTEXT *context,
-            void *dispatcherContext)
-{
-
+
+
+
+
+
+
-        return EXCEPTION_DISPOSITION.ExceptionContinueSearch;
-
+
+
-    // An exception has been thrown during unwinding.
-    // It happened during the SEARCH phase.
-    // We need to cancel the original search pass, so we'll restart from 'frame'.
-    *(cast(void **)dispatcherContext) = frame;
-    return EXCEPTION_DISPOSITION.ExceptionCollidedUnwind;
-}
-
-extern(C)
-EXCEPTION_DISPOSITION unwindCollisionExceptionHandler(
-            EXCEPTION_RECORD *exceptionRecord,
-            DEstablisherFrame *frame,
-            CONTEXT *context,
-            void *dispatcherContext)
-{
-
+
+
+
+
+
-        return EXCEPTION_DISPOSITION.ExceptionContinueSearch;
-
+}
-    // An exception has been thrown during unwinding.
-    // It happened during the UNWIND phase.
-    // We need to cancel the unwind pass, AND we need to cancel the search
-    // pass that initiated the unwind. So, we need to restart from 'frame.prev'.
-    *(cast(void **)dispatcherContext) = frame.prev;
-    return EXCEPTION_DISPOSITION.ExceptionCollidedUnwind;
-}
-
-/**************************************
- * Call finally blocks in the current stack frame until stop_index.