Support passing stacktrace to (re)raise (#128)

Instead of ignoring the stacktrace passed to `:erlang.raise/3` it
properly (?) handles it. Thans to that, the following code:
```elixir
try do
  # This needs a fix BTW
  inspect(fn x -> x + 1 end)
rescue
  e -> {e, __STACKTRACE__}
end
```

that used to return:

```elixir
{%ArgumentError{message: "argument error"},
 [
   {:elixir, :eval_external_handler, 3,
    [file: ~c"patches/estdlib/elixir.erl", line: 145]},
   {:erl_eval, :avmo_do_apply, 4, [file: ~c"erl_eval", line: 754]},
   {:erl_eval, :avmo_do_apply, 7, [file: ~c"erl_eval", line: 750]},
   {:erl_eval, :avmo_try_clauses, 10, [file: ~c"erl_eval", line: 1052]},
   {:erl_eval, :avmo_try_clauses, 10, [file: ~c"erl_eval", line: 1060]},
   {:erl_eval, :avmo_try_clauses, 10, [file: ~c"erl_eval", line: 1077]},
   {:elixir, :avmo_eval_forms, 4, [file: ~c"src/elixir.erl", line: 364]},
   {:elixir, :avmo_eval_forms, 4, [file: ~c"src/elixir.erl", line: 374]},
   {Module.ParallelChecker, :verify, 1,
    [file: ~c"lib/module/parallel_checker.ex", line: 112]},
   {Module.ParallelChecker, :verify, 1,
    [file: ~c"lib/module/parallel_checker.ex", line: 111]},
   {Code, :avmo_validated_eval_string, 3, [file: ~c"lib/code.ex", line: 572]},
   {RunExpr, :run, 1,
    [file: ~c"tmp/modules/117000009/_build/code.ex", line: 17]},
   {RunExpr, :start, 0,
    [file: ~c"tmp/modules/117000009/_build/code.ex", line: 6]}
 ]}
```

now returns:

```elixir
{%ArgumentError{message: "argument error"},
 [
   {Inspect.Function, :uniq, 1, [file: ~c"lib/inspect.ex", line: 497]},
   {Inspect.Function, :default_inspect, 2,
    [file: ~c"lib/inspect.ex", line: 479]},
   {Inspect.Algebra, :to_doc, 2, [file: ~c"lib/inspect/algebra.ex", line: 396]},
   {Kernel, :inspect, 2, [file: ~c"lib/kernel.ex", line: 2381]},
   {:elixir_eval, :__FILE__, 1,
    [
      file: ~c"/Users/matheksm/ewr/fission_lib/tmp/modules/117000009/_build/code.ex",
      line: 18
    ]},
   {:elixir, :eval_external_handler, 3,
    [file: ~c"patches/estdlib/elixir.erl", line: 98]},
   {:elixir, :eval_external_handler, 3,
    [file: ~c"patches/estdlib/elixir.erl", line: 99]},
   {:erl_eval, :avmo_do_apply, 4, [file: ~c"erl_eval", line: 754]},
   {:erl_eval, :avmo_do_apply, 7, [file: ~c"erl_eval", line: 750]},
   {:erl_eval, :avmo_try_clauses, 10, [file: ~c"erl_eval", line: 1052]},
   {:erl_eval, :avmo_try_clauses, 10, [file: ~c"erl_eval", line: 1060]},
   {:erl_eval, :avmo_try_clauses, 10, [file: ~c"erl_eval", line: 1077]},
   {:elixir, :avmo_eval_forms, 4, [file: ~c"src/elixir.erl", line: 364]},
   {:elixir, :avmo_eval_forms, 4, [file: ~c"src/elixir.erl", line: 374]},
   {Module.ParallelChecker, :verify, 1,
    [file: ~c"lib/module/parallel_checker.ex", line: 112]},
   {Module.ParallelChecker, :verify, 1,
    [file: ~c"lib/module/parallel_checker.ex", line: 111]},
   {Code, :avmo_validated_eval_string, 3, [file: ~c"lib/code.ex", line: 572]},
   {RunExpr, :run, 1,
    [file: ~c"tmp/modules/117000009/_build/code.ex", line: 17]}
 ]}
```

However, I'm not 100% sure this doesn't break something ¯\\_(ツ)\_/¯ I
plan to upstream this shortly and hopefully get some feedback.

cc @bblaszkow06 @FKubisSWM

---

These changes are made under both the "Apache 2.0" and the "GNU Lesser
General
Public License 2.1 or later" license terms (dual license).

SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later
Signed-off-by: Mateusz Front <[email protected]>

Author: mat-hek

src/libAtomVM/bif.c

@@ -45,12 +45,14 @@
 #define RAISE_ERROR(error_type_atom) \
     ctx->x[0] = ERROR_ATOM;          \
     ctx->x[1] = (error_type_atom);   \
+    ctx->x[2] = term_nil();          \
     return term_invalid_term();
 
 #define RAISE_ERROR_BIF(fail_label, error_type_atom) \
     if (fail_label == 0) {                           \
         ctx->x[0] = ERROR_ATOM;                      \
         ctx->x[1] = (error_type_atom);               \
+        ctx->x[2] = term_nil();                      \
     }                                                \
     return term_invalid_term();
 

src/libAtomVM/nifs.c

@@ -69,6 +69,7 @@
 #define RAISE(a, b)  \
     ctx->x[0] = (a); \
     ctx->x[1] = (b); \
+    ctx->x[2] = term_nil(); \
     return term_invalid_term();
 
 #ifndef MAX
@@ -2983,9 +2984,7 @@ static term nif_erlang_system_flag(Context *ctx, int argc, term argv[])
         int new_value = term_to_int(value);
         int nb_processors = smp_get_online_processors();
         if (UNLIKELY(new_value < 1) || UNLIKELY(new_value > nb_processors)) {
-            argv[0] = ERROR_ATOM;
-            argv[1] = BADARG_ATOM;
-            return term_invalid_term();
+            RAISE_ERROR(BADARG_ATOM);
         }
         while (!ATOMIC_COMPARE_EXCHANGE_WEAK_INT(&ctx->global->online_schedulers, &old_value, new_value)) {};
         return term_from_int32(old_value);
@@ -3531,6 +3530,7 @@ static term nif_erlang_throw(Context *ctx, int argc, term argv[])
 
     ctx->x[0] = THROW_ATOM;
     ctx->x[1] = t;
+    ctx->x[2] = term_nil();
     return term_invalid_term();
 }
 
@@ -3544,7 +3544,7 @@ static term nif_erlang_raise(Context *ctx, int argc, term argv[])
     }
     ctx->x[0] = ex_class;
     ctx->x[1] = argv[1];
-    ctx->x[2] = term_nil();
+    ctx->x[2] = argv[2];
     return term_invalid_term();
 }
 

src/libAtomVM/nifs.h

@@ -38,12 +38,14 @@ extern "C" {
     if (UNLIKELY(!verify_function((value)))) { \
         argv[0] = ERROR_ATOM;                  \
         argv[1] = BADARG_ATOM;                 \
+        argv[2] = term_nil();                  \
         return term_invalid_term();            \
     }
 
 #define RAISE_ERROR(error_type_atom) \
     ctx->x[0] = ERROR_ATOM;          \
     ctx->x[1] = (error_type_atom);   \
+    ctx->x[2] = term_nil();   \
     return term_invalid_term();
 
 const struct Nif *nifs_get(const char *mfa);

src/libAtomVM/opcodesswitch.h

@@ -1170,7 +1170,7 @@ static void destroy_extended_registers(Context *ctx, unsigned int live)
 #define PROCESS_MAYBE_TRAP_RETURN_VALUE(return_value)           \
     if (term_is_invalid_term(return_value)) {                   \
         if (UNLIKELY(!context_get_flags(ctx, Trap))) {          \
-            HANDLE_ERROR();                                     \
+            HANDLE_ERROR_MAYBE_STACKTRACE();                    \
         } else {                                                \
             SCHEDULE_WAIT(mod, pc);                             \
         }                                                       \
@@ -1180,7 +1180,7 @@ static void destroy_extended_registers(Context *ctx, unsigned int live)
     if (term_is_invalid_term(return_value)) {                             \
         if (UNLIKELY(!context_get_flags(ctx, Trap))) {                    \
             pc = rest_pc;                                                 \
-            HANDLE_ERROR();                                               \
+            HANDLE_ERROR_MAYBE_STACKTRACE();                              \
         } else {                                                          \
             SCHEDULE_WAIT(mod, pc);                                       \
         }                                                                 \
@@ -1189,7 +1189,7 @@ static void destroy_extended_registers(Context *ctx, unsigned int live)
 #define PROCESS_MAYBE_TRAP_RETURN_VALUE_LAST(return_value)      \
     if (term_is_invalid_term(return_value)) {                   \
         if (UNLIKELY(!context_get_flags(ctx, Trap))) {          \
-            HANDLE_ERROR();                                     \
+            HANDLE_ERROR_MAYBE_STACKTRACE();                    \
         } else {                                                \
             DO_RETURN();                                        \
             SCHEDULE_WAIT(mod, pc);                             \
@@ -1216,6 +1216,10 @@ static void destroy_extended_registers(Context *ctx, unsigned int live)
     x_regs[2] = stacktrace_create_raw(ctx, mod, pc - code, x_regs[0]);  \
     goto handle_error;
 
+#define HANDLE_ERROR_MAYBE_STACKTRACE() \
+    x_regs[2] = x_regs[2] == term_nil() ? stacktrace_create_raw(ctx, mod, pc - code, x_regs[0]) : x_regs[2];  \
+    goto handle_error;
+
 #define VERIFY_IS_INTEGER(t, opcode_name, label)           \
     if (UNLIKELY(!term_is_integer(t))) {                   \
         TRACE(opcode_name ": " #t " is not an integer\n"); \
@@ -3741,9 +3745,13 @@ HOT_FUNC int scheduler_entry_point(GlobalContext *glb)
 
                 #ifdef IMPL_EXECUTE_LOOP
                     TRACE("raise/2 stacktrace=0x%lx exc_value=0x%lx\n", stacktrace, exc_value);
-                    x_regs[0] = stacktrace_exception_class(stacktrace);
-                    x_regs[1] = exc_value;
-                    x_regs[2] = stacktrace_create_raw(ctx, mod, saved_pc - code, x_regs[0]);
+                    if (stacktrace_is_built(stacktrace)) {
+                        x_regs[2] = stacktrace;
+                    } else {
+                        x_regs[0] = stacktrace_exception_class(stacktrace);
+                        x_regs[1] = exc_value;
+                        x_regs[2] = stacktrace_create_raw(ctx, mod, saved_pc - code, x_regs[0]);
+                    }
                     goto handle_error;
                 #endif
 
@@ -3780,7 +3788,7 @@ HOT_FUNC int scheduler_entry_point(GlobalContext *glb)
                             break;
 
                         case ERROR_ATOM_INDEX: {
-                            x_regs[2] = stacktrace_build(ctx, &x_regs[2], 3);
+                            x_regs[2] = stacktrace_ensure_built(ctx, &x_regs[2], 3);
                             // MEMORY_CAN_SHRINK because catch_end is classified as gc in beam_ssa_codegen.erl
                             if (UNLIKELY(memory_ensure_free_with_roots(ctx, TUPLE_SIZE(2) * 2, 2, x_regs + 1, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
                                 RAISE_ERROR(OUT_OF_MEMORY_ATOM);
@@ -6249,7 +6257,7 @@ HOT_FUNC int scheduler_entry_point(GlobalContext *glb)
 
                 #ifdef IMPL_EXECUTE_LOOP
 
-                    x_regs[0] = stacktrace_build(ctx, &x_regs[0], 1);
+                    x_regs[0] = stacktrace_ensure_built(ctx, &x_regs[0], 1);
 
                 #endif
                 break;

src/libAtomVM/stacktrace.c

@@ -33,6 +33,20 @@ term stacktrace_create_raw(Context *ctx, Module *mod, int current_offset, term e
     return exception_class;
 }
 
+bool stacktrace_is_built(term stack_info_or_stacktrace)
+{
+    UNUSED(stack_info_or_stacktrace);
+    return true;
+}
+
+term stacktrace_ensure_built(Context *ctx, term *stack_info_or_stacktrace, uint32_t live)
+{
+    UNUSED(ctx);
+    UNUSED(stack_info_or_stacktrace);
+    UNUSED(live);
+    return UNDEFINED_ATOM;
+}
+
 term stacktrace_build(Context *ctx, term *stack_info, uint32_t live)
 {
     UNUSED(ctx);
@@ -257,6 +271,27 @@ static term find_path_created(const void *key, struct ModulePathPair *module_pat
     return term_invalid_term();
 }
 
+bool stacktrace_is_built(term stack_info_or_stacktrace)
+{
+    TERM_DEBUG_ASSERT(term_is_tuple(stack_info_or_stacktrace) || term_is_list(stack_info_or_stacktrace));
+    if (term_is_tuple(stack_info_or_stacktrace)) {
+        return false;
+    } else if (term_is_list(stack_info_or_stacktrace)) {
+        return true;
+    } else {
+        fprintf(stderr, "Error: invalid stack_info or stacktrace passed to stacktrace_is_built");
+        return false;
+    }
+}
+
+term stacktrace_ensure_built(Context *ctx, term *stack_info_or_stacktrace, uint32_t live)
+{
+    if (stacktrace_is_built(*stack_info_or_stacktrace)) {
+        return *stack_info_or_stacktrace;
+    }
+    return stacktrace_build(ctx, stack_info_or_stacktrace, live);
+}
+
 term stacktrace_build(Context *ctx, term *stack_info, uint32_t live)
 {
     GlobalContext *glb = ctx->global;

src/libAtomVM/stacktrace.h

@@ -30,6 +30,8 @@ extern "C" {
 #endif
 
 term stacktrace_create_raw(Context *ctx, Module *mod, int current_offset, term exception_class);
+bool stacktrace_is_built(term stack_info_or_stacktrace);
+term stacktrace_ensure_built(Context *ctx, term *stack_info_or_stacktrace, uint32_t live);
 /**
  * @brief Build a stack trace
  * @param ctx           context

src/platforms/generic_unix/lib/platform_nifs.c

@@ -40,12 +40,14 @@
     if (UNLIKELY(!verify_function((value)))) { \
         argv[0] = ERROR_ATOM;                  \
         argv[1] = BADARG_ATOM;                 \
+        ctx->x[2] = term_nil();                \
         return term_invalid_term();            \
     }
 
 #define RAISE_ERROR(error_type_atom) \
     ctx->x[0] = ERROR_ATOM;          \
     ctx->x[1] = (error_type_atom);   \
+    ctx->x[2] = term_nil();          \
     return term_invalid_term();
 
 #if ATOMVM_HAS_MBEDTLS

src/platforms/rp2/src/lib/platform_nifs.c

@@ -48,6 +48,7 @@
     if (UNLIKELY(!verify_function((value)))) { \
         argv[0] = ERROR_ATOM;                  \
         argv[1] = BADARG_ATOM;                 \
+        ctx->x[2] = term_nil();                \
         return term_invalid_term();            \
     }