change backtrace gathering method for compilation time

KubaTaba1uga · KubaTaba1uga · commit 77bb4530885f · 2025-05-02T21:46:03.000+02:00
diff --git a/example/meson.build b/example/meson.build
@@ -4,13 +4,9 @@ executable(
   'example.c',
   dependencies : c_minilib_error_dep,
   c_args : [
-    '-g',                         # Enable debug symbols (DWARF info)
-    '-fno-pie',                   # Disable position-independent code generation
-    '-fno-omit-frame-pointer',    # Preserve frame pointer for accurate backtraces
     '-O0'                         # Disable compiler optimizations (more accurate traces)
   ],
   link_args : [
-    '-no-pie',                    # Tell linker to produce a non-PIE executable
-    '-O0'                         # Disable linker-level optimizations
+    '-O0'                         # Disable linker-level optimizations (more accurate traces)
   ],
 )
diff --git a/include/c_minilib_error.h b/include/c_minilib_error.h
@@ -9,9 +9,6 @@
 #include <inttypes.h>
 #include <stdint.h>
 
-// We are staticly restricting fields to create only one memory allocation for
-//  whole error. Mallocs are pretty expensive and errors can be created and
-//  destroyed very frequently.
 #ifdef CME_ENABLE_BACKTRACE
 #define CME_STACK_MAX 16
 #else
@@ -20,6 +17,9 @@
 
 #define CME_STR_MAX 255
 
+// Resolving symbols is quite cumbersome and require a lot of compilation flags
+// like -fno-omit-pointer, -fno-pie etc. Resolving symbols on compilation
+//  step simplify process much.
 struct cme_StackSymbol {
   const char *source_file;
   const char *source_func;
@@ -30,6 +30,9 @@ struct __attribute__((aligned(8))) cme_Error {
   uint32_t code;
   char msg[CME_STR_MAX];
   uint32_t stack_length;
+  // We are staticly restricting fields to create only one memory allocation for
+  //  whole error. Mallocs are pretty expensive and errors can be created and
+  //  destroyed very frequently.
   struct cme_StackSymbol stack_symbols[CME_STACK_MAX];
 };
 
diff --git a/src/c_minilib_error.c b/src/c_minilib_error.c
@@ -80,8 +80,9 @@ int cme_error_dump_to_str(cme_error_t err, uint32_t n, char *buffer) {
 
   written =
       cme_sprintf(buffer + offset, n - offset, "------------------------\n");
-  if (written < 0)
+  if (written < 0) {
     return ENOBUFS;
+  }
   offset += (size_t)written;
 
   for (uint32_t i = 0; i < err->stack_length; ++i) {
@@ -90,8 +91,9 @@ int cme_error_dump_to_str(cme_error_t err, uint32_t n, char *buffer) {
                           sym->source_func ? sym->source_func : "??",
                           sym->source_file ? sym->source_file : "??",
                           sym->source_line);
-    if (written < 0)
+    if (written < 0) {
       return ENOBUFS;
+    }
     offset += (size_t)written;
   }
 
@@ -120,10 +122,12 @@ cme_error_t cme_error_push_symbol(cme_error_t err, const char *file,
   (void)line;
   return err;
 #else
-  if (!err)
+  if (!err) {
     return err;
-  if (err->stack_length >= CME_STACK_MAX)
+  }
+  if (err->stack_length >= CME_STACK_MAX) {
     return err;
+  }
 
   struct cme_StackSymbol *f = &err->stack_symbols[err->stack_length++];
   f->source_file = file;
diff --git a/test/test_c_minilib_error.d/common.h b/test/test_c_minilib_error.d/common.h
@@ -6,7 +6,6 @@
 #include <string.h>
 #include <unistd.h>
 
-inline static char *create_temp_file_path(void) __attribute__((unused));
 inline static char *create_temp_file_path(void) {
   char *template = strdup("/tmp/cme_error_dump_XXXXXX");
   if (!template) {
diff --git a/test/test_c_minilib_error.d/test_c_minilib_error.c b/test/test_c_minilib_error.d/test_c_minilib_error.c
@@ -1,23 +1,23 @@
+// test/test_c_minilib_error.d/test_c_minilib_error.c
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
-#include <unity.h>
-
 #include "c_minilib_error.h"
 #include "common.h"
+#include <unity.h>
 
 void test_create_error_success(void) {
   struct cme_Error *err = cme_error_create(42, "test.c", "test_func", 123,
                                            "Failed with code %d", 42);
 
   TEST_ASSERT_NOT_NULL(err);
   TEST_ASSERT_EQUAL(42, err->code);
-  TEST_ASSERT_EQUAL_STRING("test.c", err->source_file);
-  TEST_ASSERT_EQUAL_STRING("test_func", err->source_func);
-  TEST_ASSERT_EQUAL(123, err->source_line);
+  TEST_ASSERT_EQUAL_STRING("test.c", err->stack_symbols[0].source_file);
+  TEST_ASSERT_EQUAL_STRING("test_func", err->stack_symbols[0].source_func);
+  TEST_ASSERT_EQUAL(123, err->stack_symbols[0].source_line);
   TEST_ASSERT_EQUAL_STRING("Failed with code 42", err->msg);
 
   cme_error_destroy(err);
@@ -43,9 +43,7 @@ void test_create_error_invalid_format(void) {
   cme_error_destroy(err);
 }
 
-void test_destroy_null(void) {
-  cme_error_destroy(NULL); // Should not crash
-}
+void test_destroy_null(void) { cme_error_destroy(NULL); }
 
 void test_create_error_multiple_format_args(void) {
   struct cme_Error *err =
@@ -54,9 +52,9 @@ void test_create_error_multiple_format_args(void) {
 
   TEST_ASSERT_NOT_NULL(err);
   TEST_ASSERT_EQUAL(7, err->code);
-  TEST_ASSERT_EQUAL_STRING("multi.c", err->source_file);
-  TEST_ASSERT_EQUAL_STRING("multi_func", err->source_func);
-  TEST_ASSERT_EQUAL(77, err->source_line);
+  TEST_ASSERT_EQUAL_STRING("multi.c", err->stack_symbols[0].source_file);
+  TEST_ASSERT_EQUAL_STRING("multi_func", err->stack_symbols[0].source_func);
+  TEST_ASSERT_EQUAL(77, err->stack_symbols[0].source_line);
   TEST_ASSERT_EQUAL_STRING("Error code 7 at multi.c:77", err->msg);
 
   cme_error_destroy(err);
@@ -68,28 +66,22 @@ void test_create_error_no_format_string(void) {
 
   TEST_ASSERT_NOT_NULL(err);
   TEST_ASSERT_EQUAL(88, err->code);
-  TEST_ASSERT_EQUAL_STRING("plain.c", err->source_file);
-  TEST_ASSERT_EQUAL_STRING("plain_func", err->source_func);
-  TEST_ASSERT_EQUAL(88, err->source_line);
+  TEST_ASSERT_EQUAL_STRING("plain.c", err->stack_symbols[0].source_file);
+  TEST_ASSERT_EQUAL_STRING("plain_func", err->stack_symbols[0].source_func);
+  TEST_ASSERT_EQUAL(88, err->stack_symbols[0].source_line);
   TEST_ASSERT_EQUAL_STRING("Static message", err->msg);
 
   cme_error_destroy(err);
 }
 
 void test_cme_error_dump_tmp(void) {
-  struct cme_Error err = {
-      .code = 42,
-      .source_line = 100,
-      .stack_length = 0,
-#ifdef CME_ENABLE_BACKTRACE
-      .stack_symbols = {0},
-#else
-      .stack_symbols = NULL,
-#endif
-  };
+  struct cme_Error err;
+  err.code = 42;
+  err.stack_length = 1;
   strncpy(err.msg, "Temporary error message", CME_STR_MAX);
-  strncpy(err.source_file, "test_tmp.c", CME_STR_MAX);
-  strncpy(err.source_func, "test_tmp_func", CME_STR_MAX);
+  err.stack_symbols[0].source_file = "test_tmp.c";
+  err.stack_symbols[0].source_func = "test_tmp_func";
+  err.stack_symbols[0].source_line = 100;
 
   char *temp_file = create_temp_file_path();
   TEST_ASSERT_NOT_NULL(temp_file);
@@ -108,9 +100,7 @@ void test_cme_error_dump_tmp(void) {
   TEST_ASSERT_NOT_NULL(strstr(buf, "====== ERROR DUMP ======"));
   TEST_ASSERT_NOT_NULL(strstr(buf, "Error code: 42"));
   TEST_ASSERT_NOT_NULL(strstr(buf, err.msg));
-  TEST_ASSERT_NOT_NULL(strstr(buf, err.source_file));
-  TEST_ASSERT_NOT_NULL(strstr(buf, "Src line: 100"));
-  TEST_ASSERT_NOT_NULL(strstr(buf, err.source_func));
+  TEST_ASSERT_NOT_NULL(strstr(buf, "0:test_tmp_func:test_tmp.c:100"));
 
   remove(temp_file);
   free(temp_file);
diff --git a/test/test_c_minilib_error.d/test_c_minilib_error_with_backtrace.c b/test/test_c_minilib_error.d/test_c_minilib_error_with_backtrace.c
@@ -1,37 +1,45 @@
+// test/test_c_minilib_error.d/test_c_minilib_error_with_backtrace.c
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
-#include <unity.h>
-
 #include "c_minilib_error.h"
 #include "common.h"
+#include <unity.h>
 
-void test_create_error_with_backtrace(void) {
-  struct cme_Error *err = cme_errorf(101, "Backtrace test");
-
+// Verifies code, message, and the first backtrace symbol fields
+void test_create_error_with_backtrace_fields(void) {
+  struct cme_Error *err = cme_errorf(300, "Field test");
   TEST_ASSERT_NOT_NULL(err);
-  TEST_ASSERT_EQUAL(101, err->code);
-  TEST_ASSERT_NOT_NULL(err->msg);
-  TEST_ASSERT_TRUE(err->stack_length == 0);
+
+  TEST_ASSERT_EQUAL(300, err->code);
+  TEST_ASSERT_EQUAL_STRING("Field test", err->msg);
+  TEST_ASSERT_EQUAL(1, err->stack_length);
+
+  const struct cme_StackSymbol *sym = &err->stack_symbols[0];
+  TEST_ASSERT_NOT_NULL(sym->source_file);
+
+  TEST_ASSERT_TRUE(
+      strstr(sym->source_file, "test_c_minilib_error_with_backtrace.c"));
+
+  TEST_ASSERT_EQUAL_STRING("test_create_error_with_backtrace_fields",
+                           sym->source_func);
+
+  TEST_ASSERT_TRUE(sym->source_line > 0);
 
   cme_error_destroy(err);
 }
 
 void test_cme_error_dump_with_backtrace(void) {
-  struct cme_Error err = {
-      .code = 42,
-      .source_line = 100,
-      .stack_length = 1,
-  };
+  struct cme_Error err;
+  err.code = 42;
+  err.stack_length = 1;
   strncpy(err.msg, "Temporary error message", CME_STR_MAX);
-  strncpy(err.source_file, "test_tmp.c", CME_STR_MAX);
-  strncpy(err.source_func, "test_tmp_func", CME_STR_MAX);
-
-  void *dummy_symbols[] = {(void *)0x1234abcd};
-  memcpy(err.stack_symbols, dummy_symbols, sizeof(dummy_symbols));
+  err.stack_symbols[0].source_file = "test_tmp.c";
+  err.stack_symbols[0].source_func = "test_tmp_func";
+  err.stack_symbols[0].source_line = 100;
 
   char *temp_file = create_temp_file_path();
   TEST_ASSERT_NOT_NULL(temp_file);
@@ -50,11 +58,41 @@ void test_cme_error_dump_with_backtrace(void) {
   TEST_ASSERT_NOT_NULL(strstr(buf, "====== ERROR DUMP ======"));
   TEST_ASSERT_NOT_NULL(strstr(buf, "Error code: 42"));
   TEST_ASSERT_NOT_NULL(strstr(buf, err.msg));
-  TEST_ASSERT_NOT_NULL(strstr(buf, err.source_file));
-  TEST_ASSERT_NOT_NULL(strstr(buf, "Src line: 100"));
-  TEST_ASSERT_NOT_NULL(strstr(buf, err.source_func));
-  TEST_ASSERT_NOT_NULL(strstr(buf, "0x"));
+  TEST_ASSERT_NOT_NULL(strstr(buf, "0:test_tmp_func:test_tmp.c:100"));
 
   remove(temp_file);
   free(temp_file);
 }
+
+// Helper wrappers for testing cme_return
+static cme_error_t return_level1(void) {
+  return cme_errorf(200, "Level1 error");
+}
+
+static cme_error_t return_level2(void) { return cme_return(return_level1()); }
+
+void test_cme_return_macro(void) {
+  cme_error_t err = return_level2();
+  TEST_ASSERT_NOT_NULL(err);
+  TEST_ASSERT_EQUAL(200, err->code);
+
+  // Expect two frames: level1 then level2
+  TEST_ASSERT_EQUAL(2, err->stack_length);
+
+  const struct cme_StackSymbol *sym0 = &err->stack_symbols[0];
+  const struct cme_StackSymbol *sym1 = &err->stack_symbols[1];
+
+  // First symbol should come from return_level1()
+  TEST_ASSERT_TRUE(
+      strstr(sym0->source_file, "test_c_minilib_error_with_backtrace.c"));
+  TEST_ASSERT_EQUAL_STRING("return_level1", sym0->source_func);
+  TEST_ASSERT_TRUE(sym0->source_line > 0);
+
+  // Second symbol should come from return_level2()
+  TEST_ASSERT_TRUE(
+      strstr(sym1->source_file, "test_c_minilib_error_with_backtrace.c"));
+  TEST_ASSERT_EQUAL_STRING("return_level2", sym1->source_func);
+  TEST_ASSERT_TRUE(sym1->source_line > 0);
+
+  cme_error_destroy(err);
+}
