[CN-Exec/CN-Test-Gen] Generalize failure handling (#699)

ZippeyKeys12 · web-flow · commit 84d21f388def · 2024-11-06T12:55:06.000-05:00
diff --git a/runtime/libcn/include/cn-executable/utils.h b/runtime/libcn/include/cn-executable/utils.h
@@ -138,9 +138,18 @@ void cn_free_sized(void*, size_t len);
 void cn_print_nr_u64(int i, unsigned long u) ;
 void cn_print_u64(const char *str, unsigned long u) ;
 
-/* cn_exit callbacks */
-void set_cn_exit_cb(void (*callback)(void));
-void reset_cn_exit_cb(void);
+/* cn_failure callbacks */
+enum cn_failure_mode {
+    CN_FAILURE_ASSERT = 1,
+    CN_FAILURE_CHECK_OWNERSHIP,
+    CN_FAILURE_OWNERSHIP_LEAK,
+    CN_FAILURE_ALLOC
+};
+
+typedef void (*cn_failure_callback)(enum cn_failure_mode);
+void set_cn_failure_cb(cn_failure_callback callback);
+void reset_cn_failure_cb(void);
+void cn_failure(enum cn_failure_mode mode);
 
 /* Conversion functions */
 
diff --git a/runtime/libcn/include/cn-testing/test.h b/runtime/libcn/include/cn-testing/test.h
@@ -22,7 +22,7 @@ void print_test_info(char* suite, char* name, int tests, int discards);
         if (setjmp(buf_##Name)) {                                                       \
             return CN_TEST_FAIL;                                                        \
         }                                                                               \
-        set_cn_exit_cb(&cn_test_##Name##_fail);                                         \
+        set_cn_failure_cb(&cn_test_##Name##_fail);                                      \
                                                                                         \
         CN_TEST_INIT();                                                                 \
         Name();                                                                         \
@@ -33,39 +33,42 @@ void print_test_info(char* suite, char* name, int tests, int discards);
 #define CN_RANDOM_TEST_CASE_WITH_CUSTOM_INIT(Suite, Name, Samples, Init, ...)           \
     static jmp_buf buf_##Name;                                                          \
                                                                                         \
-    void cn_test_##Name##_fail () {                                                     \
-        longjmp(buf_##Name, 1);                                                         \
+    void cn_test_##Name##_fail (enum cn_failure_mode mode) {                            \
+        longjmp(buf_##Name, mode);                                                      \
     }                                                                                   \
                                                                                         \
     enum cn_test_result cn_test_##Name (int printing) {                                 \
-        if (setjmp(buf_##Name)) {                                                       \
-            return CN_TEST_FAIL;                                                        \
-        }                                                                               \
-        set_cn_exit_cb(&cn_test_##Name##_fail);                                         \
-                                                                                        \
         cn_gen_rand_checkpoint checkpoint = cn_gen_rand_save();                         \
         int i = 0, d = 0;                                                               \
+        switch (setjmp(buf_##Name)) {                                                   \
+            case CN_FAILURE_ASSERT:                                                     \
+            case CN_FAILURE_CHECK_OWNERSHIP:                                            \
+            case CN_FAILURE_OWNERSHIP_LEAK:                                             \
+                return CN_TEST_FAIL;                                                    \
+            case CN_FAILURE_ALLOC:                                                      \
+                d++;                                                                    \
+                break;                                                                  \
+        }                                                                               \
+        set_cn_failure_cb(&cn_test_##Name##_fail);                                      \
         for (; i < Samples; i++) {                                                      \
             if (printing) {                                                             \
                 printf("\r");                                                           \
                 print_test_info(#Suite, #Name, i, d);                                   \
             }                                                                           \
+            if (d == 10 * Samples) {                                                    \
+                return CN_TEST_GEN_FAIL;                                                \
+            }                                                                           \
+            cn_gen_rand_replace(checkpoint);                                            \
             CN_TEST_INIT();                                                             \
             struct cn_gen_##Name##_record *res = cn_gen_##Name();                       \
             if (cn_gen_backtrack_type() != CN_GEN_BACKTRACK_NONE) {                     \
                 i--;                                                                    \
                 d++;                                                                    \
-                if (d == 10 * Samples) {                                                \
-                    printf("\r");                                                       \
-                    print_test_info(#Suite, #Name, i + 1, d);                           \
-                    return CN_TEST_GEN_FAIL;                                            \
-                }                                                                       \
                 continue;                                                               \
             }                                                                           \
             assume_##Name(__VA_ARGS__);                                                 \
             Init(res);                                                                  \
             Name(__VA_ARGS__);                                                          \
-            cn_gen_rand_replace(checkpoint);                                            \
         }                                                                               \
                                                                                         \
         if (printing) {                                                                 \
diff --git a/runtime/libcn/src/cn-executable/alloc.c b/runtime/libcn/src/cn-executable/alloc.c
@@ -3,6 +3,7 @@
 #include <string.h>
 
 #include <cn-executable/alloc.h>
+#include <cn-executable/utils.h>
 
 // #define foo(x)\
 //     [ x ] = #x
@@ -44,8 +45,8 @@ void *alloc_(long nbytes, const char *str, int line) {
     // printf("Alloc called: %s:%d\n", str, line);
     void *res = curr;
     if ((char *) curr + nbytes - buf > MEM_SIZE) {
-        printf("Out of memory! %lu\n", count);
-        exit(1);
+        cn_failure(CN_FAILURE_ALLOC);
+        return NULL;
     }
     count++;
     curr += nbytes;
diff --git a/runtime/libcn/src/cn-executable/utils.c b/runtime/libcn/src/cn-executable/utils.c
@@ -27,18 +27,29 @@ enum cn_logging_level set_cn_logging_level(enum cn_logging_level new_level) {
     return old_level;
 }
 
-void cn_exit_aux(void) {
-    exit(SIGABRT);
+void cn_failure_default(enum cn_failure_mode mode) {
+  switch (mode) {
+    case CN_FAILURE_ALLOC:
+      printf("Out of memory!");
+    case CN_FAILURE_ASSERT:
+    case CN_FAILURE_CHECK_OWNERSHIP:
+    case CN_FAILURE_OWNERSHIP_LEAK:
+      exit(SIGABRT);
+  }
 }
 
-void static (*cn_exit)(void) = &cn_exit_aux;
+static cn_failure_callback cn_failure_aux = &cn_failure_default;
 
-void set_cn_exit_cb(void (*callback)(void)) {
-    cn_exit = callback;
+void cn_failure(enum cn_failure_mode mode) {
+  cn_failure_aux(mode);
 }
 
-void reset_cn_exit_cb(void) {
-    cn_exit = &cn_exit_aux;
+void set_cn_failure_cb(cn_failure_callback callback) {
+  cn_failure_aux = callback;
+}
+
+void reset_cn_failure_cb(void) {
+  cn_failure_aux = &cn_failure_default;
 }
 
 void print_error_msg_info(struct cn_error_message_info *info) {
@@ -54,7 +65,7 @@ void print_error_msg_info(struct cn_error_message_info *info) {
   }
   else {
     cn_printf(CN_LOGGING_ERROR, "Internal error: no error_msg_info available.");
-    cn_exit_aux();
+    exit(SIGABRT);
   }
 }
 
@@ -74,7 +85,7 @@ void cn_assert(cn_bool *cn_b) {
     if (!(cn_b->val)) {
         print_error_msg_info(error_msg_info);
         cn_printf(CN_LOGGING_ERROR, "CN assertion failed.");
-        cn_exit();
+        cn_failure(CN_FAILURE_ASSERT);
     }
 }
 
@@ -161,7 +172,7 @@ void ghost_stack_depth_decr(void) {
         if (*depth > cn_stack_depth) {
           print_error_msg_info(error_msg_info);
           cn_printf(CN_LOGGING_ERROR, "Leak check failed, ownership leaked for pointer "FMT_PTR"\n", *key);
-          cn_exit();
+          cn_failure(CN_FAILURE_OWNERSHIP_LEAK);
             // cn_printf(CN_LOGGING_INFO, FMT_PTR_2 " (%d),", *key, *depth);
         }
     }
@@ -277,7 +288,7 @@ void c_ownership_check(char *access_kind, uintptr_t generic_c_ptr, int offset, s
           cn_printf(CN_LOGGING_ERROR, "  ==> "FMT_PTR"[%d] ("FMT_PTR") not owned at expected function call stack depth %ld\n", generic_c_ptr, i, (uintptr_t)((char*)generic_c_ptr + i), expected_stack_depth);
           cn_printf(CN_LOGGING_ERROR, "  ==> (owned at stack depth: %d)\n", curr_depth);
         }
-        cn_exit();
+        cn_failure(CN_FAILURE_CHECK_OWNERSHIP);
       }
     }
     // cn_printf(CN_LOGGING_INFO, "\n");
diff --git a/runtime/libcn/src/cn-testing/test.c b/runtime/libcn/src/cn-testing/test.c
@@ -228,7 +228,7 @@ int cn_test_main(int argc, char* argv[]) {
 
         cn_gen_rand_restore(checkpoints[mapToCase[testcase - 1]]);
         set_cn_logging_level(CN_LOGGING_INFO);
-        reset_cn_exit_cb();
+        reset_cn_failure_cb();
         // raise(SIGTRAP); // Trigger breakpoint
         test_cases[mapToCase[testcase - 1]].func(0);
     }

Original file line number	Diff line number	Diff line change
`@@ -27,18 +27,29 @@ enum cn_logging_level set_cn_logging_level(enum cn_logging_level new_level) {`
`27`	`27`	`return old_level;`
`28`	`28`	`}`
`29`	`29`
`30`		`-void cn_exit_aux(void) {`
`31`		`- exit(SIGABRT);`
	`30`	`+void cn_failure_default(enum cn_failure_mode mode) {`
	`31`	`+ switch (mode) {`
	`32`	`+ case CN_FAILURE_ALLOC:`
	`33`	`+ printf("Out of memory!");`
	`34`	`+ case CN_FAILURE_ASSERT:`
	`35`	`+ case CN_FAILURE_CHECK_OWNERSHIP:`
	`36`	`+ case CN_FAILURE_OWNERSHIP_LEAK:`
	`37`	`+ exit(SIGABRT);`
	`38`	`+ }`
`32`	`39`	`}`
`33`	`40`
`34`		`-void static (*cn_exit)(void) = &cn_exit_aux;`
	`41`	`+static cn_failure_callback cn_failure_aux = &cn_failure_default;`
`35`	`42`
`36`		`-void set_cn_exit_cb(void (*callback)(void)) {`
`37`		`- cn_exit = callback;`
	`43`	`+void cn_failure(enum cn_failure_mode mode) {`
	`44`	`+ cn_failure_aux(mode);`
`38`	`45`	`}`
`39`	`46`
`40`		`-void reset_cn_exit_cb(void) {`
`41`		`- cn_exit = &cn_exit_aux;`
	`47`	`+void set_cn_failure_cb(cn_failure_callback callback) {`
	`48`	`+ cn_failure_aux = callback;`
	`49`	`+}`
	`50`	`+`
	`51`	`+void reset_cn_failure_cb(void) {`
	`52`	`+ cn_failure_aux = &cn_failure_default;`
`42`	`53`	`}`
`43`	`54`
`44`	`55`	`void print_error_msg_info(struct cn_error_message_info *info) {`
`@@ -54,7 +65,7 @@ void print_error_msg_info(struct cn_error_message_info *info) {`
`54`	`65`	`}`
`55`	`66`	`else {`
`56`	`67`	`cn_printf(CN_LOGGING_ERROR, "Internal error: no error_msg_info available.");`
`57`		`- cn_exit_aux();`
	`68`	`+ exit(SIGABRT);`
`58`	`69`	`}`
`59`	`70`	`}`
`60`	`71`
`@@ -74,7 +85,7 @@ void cn_assert(cn_bool *cn_b) {`
`74`	`85`	`if (!(cn_b->val)) {`
`75`	`86`	`print_error_msg_info(error_msg_info);`
`76`	`87`	`cn_printf(CN_LOGGING_ERROR, "CN assertion failed.");`
`77`		`- cn_exit();`
	`88`	`+ cn_failure(CN_FAILURE_ASSERT);`
`78`	`89`	`}`
`79`	`90`	`}`
`80`	`91`
`@@ -161,7 +172,7 @@ void ghost_stack_depth_decr(void) {`
`161`	`172`	`if (*depth > cn_stack_depth) {`
`162`	`173`	`print_error_msg_info(error_msg_info);`
`163`	`174`	`cn_printf(CN_LOGGING_ERROR, "Leak check failed, ownership leaked for pointer "FMT_PTR"\n", *key);`
`164`		`- cn_exit();`
	`175`	`+ cn_failure(CN_FAILURE_OWNERSHIP_LEAK);`
`165`	`176`	`// cn_printf(CN_LOGGING_INFO, FMT_PTR_2 " (%d),", key, depth);`
`166`	`177`	`}`
`167`	`178`	`}`
`@@ -277,7 +288,7 @@ void c_ownership_check(char *access_kind, uintptr_t generic_c_ptr, int offset, s`
`277`	`288`	`cn_printf(CN_LOGGING_ERROR, " ==> "FMT_PTR"[%d] ("FMT_PTR") not owned at expected function call stack depth %ld\n", generic_c_ptr, i, (uintptr_t)((char*)generic_c_ptr + i), expected_stack_depth);`
`278`	`289`	`cn_printf(CN_LOGGING_ERROR, " ==> (owned at stack depth: %d)\n", curr_depth);`
`279`	`290`	`}`
`280`		`- cn_exit();`
	`291`	`+ cn_failure(CN_FAILURE_CHECK_OWNERSHIP);`
`281`	`292`	`}`
`282`	`293`	`}`
`283`	`294`	`// cn_printf(CN_LOGGING_INFO, "\n");`
Original file line number	Diff line number	Diff line change
`@@ -228,7 +228,7 @@ int cn_test_main(int argc, char* argv[]) {`
`228`	`228`
`229`	`229`	`cn_gen_rand_restore(checkpoints[mapToCase[testcase - 1]]);`
`230`	`230`	`set_cn_logging_level(CN_LOGGING_INFO);`
`231`		`- reset_cn_exit_cb();`
	`231`	`+ reset_cn_failure_cb();`
`232`	`232`	`// raise(SIGTRAP); // Trigger breakpoint`
`233`	`233`	`test_cases[mapToCase[testcase - 1]].func(0);`
`234`	`234`	`}`