Changeset c529a24 for doc/working/exception/impl

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/impl

Files:

• exception.c (modified) (1 diff)
• exception.h (modified) (3 diffs)
• test-main.c (modified) (10 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);
                 {