Changeset c529a24

Timestamp:

Jun 16, 2017, 4:36:00 PM (7 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

365d553c

Parents:

0892b1b

Message:

Updates to exception handling and translation.

Location:

doc/working/exception

Files:

• impl/exception.c (modified) (1 diff)
• impl/exception.h (modified) (3 diffs)
• impl/test-main.c (modified) (10 diffs)
• translate.c (modified) (7 diffs)

doc/working/exception/impl/exception.c

@@ -44 +44 @@
         __throw_terminate(except);
         // TODO: Default handler for resumption.
+}
+
+/* QUESTION: Could interupts interact with exception handling?
+Ex. could an context switch stop execution, and we get an exception when we
+come back? Is so resumption has to go:
++ create node (init next and handler)
++ prepare cleanup (add a cleanup hook with the ..._cleaup function)
+  also the cleanup has to be the next node, not just a pop from the list.
++ push node on the list (change the existing node)
+Which if an exception can come from anywhere, might just be required to ensure
+the list is valid.
+
+void __try_resume_setup(struct __try_resume_node * node,
+                        bool (*handler)(exception except) {
+        node->next = shared_stack.top_resume;
+        node->try_to_handle = handler;
+        shared_stack.top_resume = node;
+}*/
+
+// We have a single cleanup function
+void __try_resume_cleanup(struct __try_resume_node * node) {
+        shared_stack.top_resume = node->next;
 }
 

doc/working/exception/impl/exception.h

@@ -6 +6 @@
 
 
-// These might be given simpler names and made public.
 void __throw_terminate(exception except) __attribute__((noreturn));
 void __rethrow_terminate(void) __attribute__((noreturn));
@@ -20 +19 @@
 };
 
+void __try_resume_cleanup(struct __try_resume_node * node);
+
 struct __cleanup_hook {};
 
@@ -27 +28 @@
  * and threads means that... well I'm going to get it working ignoring those
  * first, then get it working with concurrency.
+ * Eventually there should be some global name that just gets you the right
+ * data block.
  */
 struct shared_stack_t {
-        //struct lock lock;
         struct __try_resume_node * top_resume;
         struct __try_resume_node * current_resume;

doc/working/exception/impl/test-main.c

@@ -6 +6 @@
 #include <stdbool.h>
 
-// Translation Helpers:
-#define CLEANUP(function) \
-        struct __cleanup_hook __hidden_hook __attribute__((cleanup(function)))
-
-#define SET_UP_RESUME_NODE(handler_function) \
-        struct __try_resume_node node \
-                __attribute__((cleanup(__try_resume_node_delete))); \
-        __try_resume_node_new(&node, handler_function)
-
+// Helps with manual translation. It may or may not get folded into the
+// header, that depends on how it interacts with concurancy.
 void __try_resume_node_new(struct __try_resume_node * node,
         _Bool (*handler)(exception except)) {
@@ -20 +13 @@
     shared_stack.top_resume = node;
     node->try_to_handle = handler;
-}
-
-void __try_resume_node_delete(struct __try_resume_node * node) {
-    shared_stack.top_resume = node->next;
 }
 
@@ -122 +111 @@
                 }
                 struct __try_resume_node node
-                        __attribute__((cleanup(__try_resume_node_delete)));
+                        __attribute__((cleanup(__try_resume_cleanup)));
                 __try_resume_node_new(&node, beta_handle1);
                 {
@@ -144 +133 @@
                 }
                 struct __try_resume_node node
-                        __attribute__((cleanup(__try_resume_node_delete)));
+                        __attribute__((cleanup(__try_resume_cleanup)));
                 __try_resume_node_new(&node, alpha_handle1);
                 {
@@ -260 +249 @@
                 }
                 struct __try_resume_node node
-                        __attribute__((cleanup(__try_resume_node_delete)));
+                        __attribute__((cleanup(__try_resume_cleanup)));
                 __try_resume_node_new(&node, fn_handle1);
                 {
@@ -279 +268 @@
                 }
                 struct __try_resume_node node
-                        __attribute__((cleanup(__try_resume_node_delete)));
+                        __attribute__((cleanup(__try_resume_cleanup)));
                 __try_resume_node_new(&node, fn_handle1);
                 {
@@ -349 +338 @@
                 }
                 struct __try_resume_node node
-                        __attribute__((cleanup(__try_resume_node_delete)));
+                        __attribute__((cleanup(__try_resume_cleanup)));
                 __try_resume_node_new(&node, reresume_handle1);
                 {
@@ -361 +350 @@
                         }
                         struct __try_resume_node node
-                                __attribute__((cleanup(__try_resume_node_delete)));
+                                __attribute__((cleanup(__try_resume_cleanup)));
                         __try_resume_node_new(&node, reresume_handle2);
                         {
@@ -409 +398 @@
                 }
                 struct __try_resume_node node
-                        __attribute__((cleanup(__try_resume_node_delete)));
+                        __attribute__((cleanup(__try_resume_cleanup)));
                 __try_resume_node_new(&node, foe_handle1);
                 {
@@ -456 +445 @@
                 }
                 struct __try_resume_node node
-                        __attribute__((cleanup(__try_resume_node_delete)));
+                        __attribute__((cleanup(__try_resume_cleanup)));
                 __try_resume_node_new(&node, fee_handle1);
                 {

doc/working/exception/translate.c

@@ -17 +17 @@
 
 void __throw_terminate(exception except) __attribute__((noreturn));
+void __rethrow_terminate() __attribute__((noreturn));
 void __throw_resume(exception except);
 
@@ -27 +28 @@
         bool (*try_to_handle)(exception except);
 };
+
+void __try_resume_cleanup(struct __try_resume_node * node);
 
 struct __cleanup_hook {};
@@ -147 +150 @@
 void try_resume() {
         {
-                bool catch1(exception except) {
+                bool handle1(exception except) {
                         OtherException inner_except;
                         if (dynamic_cast__SomeException(except)) {
@@ -161 +164 @@
                 }
                 struct __try_resume_node data =
-                        {.next = stack.except.top_resume, .try_to_handle = catch1};
+                        {.next = stack.except.top_resume, .try_to_handle = handle1};
                 stack.except.top_resume = &data;
 
@@ -204 +207 @@
 
 
-// Combining the Above:
+// Resume + Finally:
+"Cforall"
+
+void try_resume_finally() {
+        try {
+                insideTry();
+        }
+        catch resume (SomeException) {
+                fiddleThing();
+        }
+        finally {
+                twiddleWidget();
+        }
+}
+
+"C"
+
+void try_resume_finally() {
+        {
+                void finally1() {
+                        twiddleWidget();
+                }
+                bool handle1(exception except) {
+                        if (dynamic_cast__SomeException(except)) {
+                                fiddleThing();
+                                return true;
+                        } else {
+                                return false;
+                        }
+                }
+                struct __cleanup_hook generated_name
+                        __attribute__((cleanup(finally1)));
+
+                struct __try_resume_node data =
+                        {.next = stack.except.top_resume, .try_to_handle = handle1};
+                stack.except.top_resume = &data;
+
+                struct __cleanup_hook generated_name
+                        __attribute__((cleanup(__try_resume_cleanup)));
+        }
+}
+
+
+// Terminate + Resume + Finally:
 "Cforall"
 
@@ -226 +272 @@
 void try_all() {
         {
+                bool handle1() {
+                        if (dynamic_cast__OtherException(except)) {
+                                twiddleWidget();
+                                return true;
+                        }
+                        return false;
+                }
                 void try1 () {
+                        struct __try_resume_node generated_name =
+                                {.next = stack.except.top_resume, .try_to_handle = handle1}
+                                __attribute__((cleanup(__try_resume_cleanup)));
+                        stack.except.top_resume = &data;
+
                         insideTry();
                 }
@@ -244 +302 @@
                         return 0;
                 }
-                bool catch2() {
-                        if (dynamic_cast__OtherException(except)) {
-                                twiddleWidget();
-                                return true;
-                        }
-                        return false;
-                }
                 void finally1() {
-                        // Finally, because of timing, also works for resume.
-                        // However this might not actually be better in any way.
-                        __try_resume_cleanup();
 
                         twiddleWidget();
                 }
-
-                struct __try_resume_node generated_name =
-                        {.next = stack.except.top_resume, .try_to_handle = catch2};
-                stack.except.top_resume = &data;
                 struct __cleanup_hook generated_name
                         __attribute__((cleanup(finally1)));