/src/elfutils/libdwfl/frame_unwind.c

Source (jump to first uncovered line)
/* Get previous frame state for an existing frame state.
   Copyright (C) 2013, 2014, 2016, 2024 Red Hat, Inc.
   This file is part of elfutils.

   This file is free software; you can redistribute it and/or modify
   it under the terms of either

     * the GNU Lesser General Public License as published by the Free
       Software Foundation; either version 3 of the License, or (at
       your option) any later version

   or

     * the GNU General Public License as published by the Free
       Software Foundation; either version 2 of the License, or (at
       your option) any later version

   or both in parallel, as here.

   elfutils is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.

   You should have received copies of the GNU General Public License and
   the GNU Lesser General Public License along with this program.  If
   not, see <http://www.gnu.org/licenses/>.  */

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include "cfi.h"
#include <stdlib.h>
#include "libdwflP.h"
#include "dwarf.h"
#include <system.h>

/* Maximum number of DWARF expression stack slots before returning an error.  */
#define DWARF_EXPR_STACK_MAX 0x100

/* Maximum number of DWARF expression executed operations before returning an
   error.  */
#define DWARF_EXPR_STEPS_MAX 0x1000

int
internal_function
__libdwfl_frame_reg_get (Dwfl_Frame *state, unsigned regno, Dwarf_Addr *val)
{
  Ebl *ebl = state->thread->process->ebl;
  if (! ebl_dwarf_to_regno (ebl, &regno))
    return -1;
  if (regno >= ebl_frame_nregs (ebl))
    return -1;
  if ((state->regs_set[regno / sizeof (*state->regs_set) / 8]
       & ((uint64_t) 1U << (regno % (sizeof (*state->regs_set) * 8)))) == 0)
    return 1;
  if (val)
    *val = state->regs[regno];
  return 0;
}

bool
internal_function
__libdwfl_frame_reg_set (Dwfl_Frame *state, unsigned regno, Dwarf_Addr val)
{
  Ebl *ebl = state->thread->process->ebl;
  if (! ebl_dwarf_to_regno (ebl, &regno))
    return false;
  if (regno >= ebl_frame_nregs (ebl))
    return false;
  /* For example i386 user_regs_struct has signed fields.  */
  if (ebl_get_elfclass (ebl) == ELFCLASS32)
    val &= 0xffffffff;
  state->regs_set[regno / sizeof (*state->regs_set) / 8] |=
    ((uint64_t) 1U << (regno % (sizeof (*state->regs_set) * 8)));
  state->regs[regno] = val;
  return true;
}

static int
bra_compar (const void *key_voidp, const void *elem_voidp)
{
  Dwarf_Word offset = (uintptr_t) key_voidp;
  const Dwarf_Op *op = elem_voidp;
  return (offset > op->offset) - (offset < op->offset);
}

struct eval_stack {
  Dwarf_Addr *addrs;
  size_t used;
  size_t allocated;
};

static bool
do_push (struct eval_stack *stack, Dwarf_Addr val)
{
  if (stack->used >= DWARF_EXPR_STACK_MAX)
    {
      __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
      return false;
    }
  if (stack->used == stack->allocated)
    {
      stack->allocated = MAX (stack->allocated * 2, 32);
      Dwarf_Addr *new_addrs;
      new_addrs = realloc (stack->addrs,
         stack->allocated * sizeof (*stack->addrs));
      if (new_addrs == NULL)
        {
          __libdwfl_seterrno (DWFL_E_NOMEM);
          return false;
        }
      stack->addrs = new_addrs;
    }
  stack->addrs[stack->used++] = val;
  return true;
}

static bool
do_pop (struct eval_stack *stack, Dwarf_Addr *val)
{
  if (stack->used == 0)
    {
      __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
      return false;
    }
  *val = stack->addrs[--stack->used];
  return true;
}

/* If FRAME is NULL is are computing CFI frame base.  In such case another
   DW_OP_call_frame_cfa is no longer permitted.  */

static bool
expr_eval (Dwfl_Frame *state, Dwarf_Frame *frame, const Dwarf_Op *ops,
     size_t nops, Dwarf_Addr *result, Dwarf_Addr bias)
{
  Dwfl_Process *process = state->thread->process;
  if (nops == 0)
    {
      __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
      return false;
    }
  struct eval_stack stack =
    {
      .addrs = NULL,
      .used = 0,
      .allocated = 0
    };

#define pop(x) do_pop(&stack, x)
#define push(x) do_push(&stack, x)

  Dwarf_Addr val1, val2;
  bool is_location = false;
  size_t steps_count = 0;
  for (const Dwarf_Op *op = ops; op < ops + nops; op++)
    {
      if (++steps_count > DWARF_EXPR_STEPS_MAX)
  {
    __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
    return false;
  }
      switch (op->atom)
      {
  /* DW_OP_* order matches libgcc/unwind-dw2.c execute_stack_op:  */
  case DW_OP_lit0 ... DW_OP_lit31:
    if (! push (op->atom - DW_OP_lit0))
      {
        free (stack.addrs);
        return false;
      }
    break;
  case DW_OP_addr:
    if (! push (op->number + bias))
      {
        free (stack.addrs);
        return false;
      }
    break;
  case DW_OP_GNU_encoded_addr:
    /* Missing support in the rest of elfutils.  */
    __libdwfl_seterrno (DWFL_E_UNSUPPORTED_DWARF);
    return false;
  case DW_OP_const1u:
  case DW_OP_const1s:
  case DW_OP_const2u:
  case DW_OP_const2s:
  case DW_OP_const4u:
  case DW_OP_const4s:
  case DW_OP_const8u:
  case DW_OP_const8s:
  case DW_OP_constu:
  case DW_OP_consts:
    if (! push (op->number))
      {
        free (stack.addrs);
        return false;
      }
    break;
  case DW_OP_reg0 ... DW_OP_reg31:
    if (INTUSE (dwfl_frame_reg) (state, op->atom - DW_OP_reg0, &val1) != 0
        || ! push (val1))
      {
        free (stack.addrs);
        return false;
      }
    break;
  case DW_OP_regx:
    if (INTUSE (dwfl_frame_reg) (state, op->number, &val1) != 0 || ! push (val1))
      {
        free (stack.addrs);
        return false;
      }
    break;
  case DW_OP_breg0 ... DW_OP_breg31:
    if (INTUSE (dwfl_frame_reg) (state, op->atom - DW_OP_breg0, &val1) != 0)
      {
        free (stack.addrs);
        return false;
      }
    val1 += op->number;
    if (! push (val1))
      {
        free (stack.addrs);
        return false;
      }
    break;
  case DW_OP_bregx:
    if (INTUSE (dwfl_frame_reg) (state, op->number, &val1) != 0)
      {
        free (stack.addrs);
        return false;
      }
    val1 += op->number2;
    if (! push (val1))
      {
        free (stack.addrs);
        return false;
      }
    break;
  case DW_OP_dup:
    if (! pop (&val1) || ! push (val1) || ! push (val1))
      {
        free (stack.addrs);
        return false;
      }
    break;
  case DW_OP_drop:
    if (! pop (&val1))
      {
        free (stack.addrs);
        return false;
      }
    break;
  case DW_OP_pick:
    if (stack.used <= op->number)
      {
        free (stack.addrs);
        __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
        return false;
      }
    if (! push (stack.addrs[stack.used - 1 - op->number]))
      {
        free (stack.addrs);
        return false;
      }
    break;
  case DW_OP_over:
    if (! pop (&val1) || ! pop (&val2)
        || ! push (val2) || ! push (val1) || ! push (val2))
      {
        free (stack.addrs);
        return false;
      }
    break;
  case DW_OP_swap:
    if (! pop (&val1) || ! pop (&val2) || ! push (val1) || ! push (val2))
      {
        free (stack.addrs);
        return false;
      }
    break;
  case DW_OP_rot:
    {
      Dwarf_Addr val3;
      if (! pop (&val1) || ! pop (&val2) || ! pop (&val3)
    || ! push (val1) || ! push (val3) || ! push (val2))
        {
    free (stack.addrs);
    return false;
        }
    }
    break;
  case DW_OP_deref:
  case DW_OP_deref_size:
    if (process->callbacks->memory_read == NULL)
      {
        free (stack.addrs);
        __libdwfl_seterrno (DWFL_E_INVALID_ARGUMENT);
        return false;
      }
    if (! pop (&val1)
        || ! process->callbacks->memory_read (process->dwfl, val1, &val1,
                process->callbacks_arg))
      {
        free (stack.addrs);
        return false;
      }
    if (op->atom == DW_OP_deref_size)
      {
        const int elfclass = frame->cache->e_ident[EI_CLASS];
        const unsigned addr_bytes = elfclass == ELFCLASS32 ? 4 : 8;
        if (op->number > addr_bytes)
    {
      free (stack.addrs);
      __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
      return false;
    }
#if BYTE_ORDER == BIG_ENDIAN
        if (op->number == 0)
    val1 = 0;
        else
    val1 >>= (addr_bytes - op->number) * 8;
#else
        if (op->number < 8)
    val1 &= (1ULL << (op->number * 8)) - 1;
#endif
      }
    if (! push (val1))
      {
        free (stack.addrs);
        return false;
      }
    break;
#define UNOP(atom, expr)            \
  case atom:              \
    if (! pop (&val1) || ! push (expr))        \
      {               \
        free (stack.addrs);         \
        return false;           \
      }                \
    break;
  UNOP (DW_OP_abs, llabs ((int64_t) val1))
  UNOP (DW_OP_neg, -(int64_t) val1)
  UNOP (DW_OP_not, ~val1)
#undef UNOP
  case DW_OP_plus_uconst:
    if (! pop (&val1) || ! push (val1 + op->number))
      {
        free (stack.addrs);
        return false;
      }
    break;
#define BINOP(atom, op)             \
  case atom:              \
    if (! pop (&val2) || ! pop (&val1) || ! push (val1 op val2))  \
      {               \
        free (stack.addrs);         \
        return false;           \
      }                \
    break;
#define BINOP_SIGNED(atom, op)            \
  case atom:              \
    if (! pop (&val2) || ! pop (&val1)        \
        || ! push ((int64_t) val1 op (int64_t) val2))    \
      {               \
        free (stack.addrs);         \
        return false;           \
      }                \
    break;
  BINOP (DW_OP_and, &)
  case DW_OP_div:
    if (! pop (&val2) || ! pop (&val1))
      {
        free (stack.addrs);
        return false;
      }
    if (val2 == 0)
      {
        free (stack.addrs);
        __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
        return false;
      }
    if (! push ((int64_t) val1 / (int64_t) val2))
      {
        free (stack.addrs);
        return false;
      }
    break;
  BINOP (DW_OP_minus, -)
  case DW_OP_mod:
    if (! pop (&val2) || ! pop (&val1))
      {
        free (stack.addrs);
        return false;
      }
    if (val2 == 0)
      {
        free (stack.addrs);
        __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
        return false;
      }
    if (! push (val1 % val2))
      {
        free (stack.addrs);
        return false;
      }
    break;
  BINOP (DW_OP_mul, *)
  BINOP (DW_OP_or, |)
  BINOP (DW_OP_plus, +)
  BINOP (DW_OP_shl, <<)
  BINOP (DW_OP_shr, >>)
  BINOP_SIGNED (DW_OP_shra, >>)
  BINOP (DW_OP_xor, ^)
  BINOP_SIGNED (DW_OP_le, <=)
  BINOP_SIGNED (DW_OP_ge, >=)
  BINOP_SIGNED (DW_OP_eq, ==)
  BINOP_SIGNED (DW_OP_lt, <)
  BINOP_SIGNED (DW_OP_gt, >)
  BINOP_SIGNED (DW_OP_ne, !=)
#undef BINOP
#undef BINOP_SIGNED
  case DW_OP_bra:
    if (! pop (&val1))
      {
        free (stack.addrs);
        return false;
      }
    if (val1 == 0)
      break;
    FALLTHROUGH;
  case DW_OP_skip:;
    Dwarf_Word offset = op->offset + 1 + 2 + (int16_t) op->number;
    const Dwarf_Op *found = bsearch ((void *) (uintptr_t) offset, ops, nops,
             sizeof (*ops), bra_compar);
    if (found == NULL)
      {
        free (stack.addrs);
        /* PPC32 vDSO has such invalid operations.  */
        __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
        return false;
      }
    /* Undo the 'for' statement increment.  */
    op = found - 1;
    break;
  case DW_OP_nop:
    break;
  /* DW_OP_* not listed in libgcc/unwind-dw2.c execute_stack_op:  */
  case DW_OP_call_frame_cfa:;
    // Not used by CFI itself but it is synthetized by elfutils internation.
    Dwarf_Op *cfa_ops;
    size_t cfa_nops;
    Dwarf_Addr cfa;
    if (frame == NULL
        || dwarf_frame_cfa (frame, &cfa_ops, &cfa_nops) != 0
        || ! expr_eval (state, NULL, cfa_ops, cfa_nops, &cfa, bias)
        || ! push (cfa))
      {
        __libdwfl_seterrno (DWFL_E_LIBDW);
        free (stack.addrs);
        return false;
      }
    is_location = true;
    break;
  case DW_OP_stack_value:
    // Not used by CFI itself but it is synthetized by elfutils internation.
    is_location = false;
    break;
  default:
    __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
    return false;
      }
    }
  if (! pop (result))
    {
      free (stack.addrs);
      return false;
    }
  free (stack.addrs);
  if (is_location)
    {
      if (process->callbacks->memory_read == NULL)
  {
    __libdwfl_seterrno (DWFL_E_INVALID_ARGUMENT);
    return false;
  }
      if (! process->callbacks->memory_read (process->dwfl, *result, result,
               process->callbacks_arg))
  return false;
    }
  return true;
#undef push
#undef pop
}

static Dwfl_Frame *
new_unwound (Dwfl_Frame *state)
{
  assert (state->unwound == NULL);
  Dwfl_Thread *thread = state->thread;
  Dwfl_Process *process = thread->process;
  Ebl *ebl = process->ebl;
  size_t nregs = ebl_frame_nregs (ebl);
  assert (nregs > 0);
  Dwfl_Frame *unwound;
  unwound = malloc (sizeof (*unwound) + sizeof (*unwound->regs) * nregs);
  if (unlikely (unwound == NULL))
    return NULL;
  state->unwound = unwound;
  unwound->thread = thread;
  unwound->unwound = NULL;
  unwound->signal_frame = false;
  unwound->initial_frame = false;
  unwound->pc_state = DWFL_FRAME_STATE_ERROR;
  unwound->unwound_source = DWFL_UNWOUND_NONE;
  memset (unwound->regs_set, 0, sizeof (unwound->regs_set));
  return unwound;
}

/* The logic is to call __libdwfl_seterrno for any CFI bytecode interpretation
   error so one can easily catch the problem with a debugger.  Still there are
   archs with invalid CFI for some registers where the registers are never used
   later.  Therefore we continue unwinding leaving the registers undefined.  */

static void
handle_cfi (Dwfl_Frame *state, Dwarf_Addr pc, Dwarf_CFI *cfi, Dwarf_Addr bias)
{
  Dwarf_Frame *frame;
  if (INTUSE(dwarf_cfi_addrframe) (cfi, pc, &frame) != 0)
    {
      __libdwfl_seterrno (DWFL_E_LIBDW);
      return;
    }

  Dwfl_Frame *unwound = new_unwound (state);
  if (unwound == NULL)
    {
      __libdwfl_seterrno (DWFL_E_NOMEM);
      return;
    }

  unwound->signal_frame = frame->fde->cie->signal_frame;
  Dwfl_Thread *thread = state->thread;
  Dwfl_Process *process = thread->process;
  Ebl *ebl = process->ebl;
  size_t nregs = ebl_frame_nregs (ebl);
  assert (nregs > 0);

  /* The return register is special for setting the unwound->pc_state.  */
  unsigned ra = frame->fde->cie->return_address_register;
  bool ra_set = false;
  if (! ebl_dwarf_to_regno (ebl, &ra))
    {
      __libdwfl_seterrno (DWFL_E_INVALID_REGISTER);
      return;
    }

  for (unsigned regno = 0; regno < nregs; regno++)
    {
      Dwarf_Op reg_ops_mem[3], *reg_ops;
      size_t reg_nops;
      if (dwarf_frame_register (frame, regno, reg_ops_mem, &reg_ops,
        &reg_nops) != 0)
  {
    __libdwfl_seterrno (DWFL_E_LIBDW);
    continue;
  }
      Dwarf_Addr regval;
      if (reg_nops == 0)
  {
    if (reg_ops == reg_ops_mem)
      {
        /* REGNO is undefined.  */
        if (regno == ra)
    unwound->pc_state = DWFL_FRAME_STATE_PC_UNDEFINED;
        continue;
      }
    else if (reg_ops == NULL)
      {
        /* REGNO is same-value.  */
        if (INTUSE (dwfl_frame_reg) (state, regno, &regval) != 0)
    continue;
      }
    else
      {
        __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
        continue;
      }
  }
      else if (! expr_eval (state, frame, reg_ops, reg_nops, &regval, bias))
  {
    /* PPC32 vDSO has various invalid operations, ignore them.  The
       register will look as unset causing an error later, if used.
       But PPC32 does not use such registers.  */
    continue;
  }

      /* Some architectures encode some extra info in the return address.  */
      if (regno == frame->fde->cie->return_address_register)
  {
    regval &= ebl_func_addr_mask (ebl);

    /* In aarch64, pseudo-register RA_SIGN_STATE indicates whether the
       return address needs demangling using the PAC mask from the
       thread. */
    if (cfi->e_machine == EM_AARCH64 &&
        frame->nregs > DW_AARCH64_RA_SIGN_STATE &&
        frame->regs[DW_AARCH64_RA_SIGN_STATE].value & 0x1)
      {
        regval &= ~(state->thread->aarch64.pauth_insn_mask);
      }
  }

      /* This is another strange PPC[64] case.  There are two
   registers numbers that can represent the same DWARF return
   register number.  We only want one to actually set the return
   register value.  But we always want to override the value if
   the register is the actual CIE return address register.  */
      if (ra_set && regno != frame->fde->cie->return_address_register)
  {
    unsigned r = regno;
    if (ebl_dwarf_to_regno (ebl, &r) && r == ra)
      continue;
  }

      if (! __libdwfl_frame_reg_set (unwound, regno, regval))
  {
    __libdwfl_seterrno (DWFL_E_INVALID_REGISTER);
    continue;
  }
      else if (! ra_set)
  {
    unsigned r = regno;
          if (ebl_dwarf_to_regno (ebl, &r) && r == ra)
      ra_set = true;
  }
    }
  if (unwound->pc_state == DWFL_FRAME_STATE_ERROR)
    {
      int res = INTUSE (dwfl_frame_reg) (unwound,
          frame->fde->cie->return_address_register,
          &unwound->pc);
      if (res == 0)
  {
    /* PPC32 __libc_start_main properly CFI-unwinds PC as zero.
       Currently none of the archs supported for unwinding have
       zero as a valid PC.  */
    if (unwound->pc == 0)
      unwound->pc_state = DWFL_FRAME_STATE_PC_UNDEFINED;
    else
      {
        unwound->pc_state = DWFL_FRAME_STATE_PC_SET;
        /* In SPARC the return address register actually contains
     the address of the call instruction instead of the return
     address.  Therefore we add here an offset defined by the
     backend.  Most likely 0.  */
        unwound->pc += ebl_ra_offset (ebl);
      }
  }
      else
  {
    /* We couldn't set the return register, either it was bogus,
       or the return pc is undefined, maybe end of call stack.  */
    unsigned pcreg = frame->fde->cie->return_address_register;
    if (! ebl_dwarf_to_regno (ebl, &pcreg)
        || pcreg >= ebl_frame_nregs (ebl))
      __libdwfl_seterrno (DWFL_E_INVALID_REGISTER);
    else
      unwound->pc_state = DWFL_FRAME_STATE_PC_UNDEFINED;
  }
    }
  free (frame);
}

static bool
setfunc (int firstreg, unsigned nregs, const Dwarf_Word *regs, void *arg)
{
  Dwfl_Frame *state = arg;
  Dwfl_Frame *unwound = state->unwound;
  if (firstreg < 0)
    {
      assert (firstreg == -1);
      assert (nregs == 1);
      assert (unwound->pc_state == DWFL_FRAME_STATE_PC_UNDEFINED);
      unwound->pc = *regs;
      unwound->pc_state = DWFL_FRAME_STATE_PC_SET;
      return true;
    }
  while (nregs--)
    if (! __libdwfl_frame_reg_set (unwound, firstreg++, *regs++))
      return false;
  return true;
}

static bool
getfunc (int firstreg, unsigned nregs, Dwarf_Word *regs, void *arg)
{
  Dwfl_Frame *state = arg;
  assert (firstreg >= 0);
  while (nregs--)
    if (INTUSE (dwfl_frame_reg) (state, firstreg++, regs++) != 0)
      return false;
  return true;
}

static bool
readfunc (Dwarf_Addr addr, Dwarf_Word *datap, void *arg)
{
  Dwfl_Frame *state = arg;
  Dwfl_Thread *thread = state->thread;
  Dwfl_Process *process = thread->process;
  return process->callbacks->memory_read (process->dwfl, addr, datap,
            process->callbacks_arg);
}

void
internal_function
__libdwfl_frame_unwind (Dwfl_Frame *state)
{
  if (state->unwound)
    return;
  /* Do not ask dwfl_frame_pc for ISACTIVATION, it would try to unwind STATE
     which would deadlock us.  */
  Dwarf_Addr pc;
  bool ok = INTUSE(dwfl_frame_pc) (state, &pc, NULL);
  if (!ok)
    return;
  /* Check whether this is the initial frame or a signal frame.
     Then we need to unwind from the original, unadjusted PC.  */
  if (! state->initial_frame && ! state->signal_frame)
    pc--;
  Dwfl_Module *mod = INTUSE(dwfl_addrmodule) (state->thread->process->dwfl, pc);
  if (mod == NULL)
    __libdwfl_seterrno (DWFL_E_NO_DWARF);
  else
    {
      Dwarf_Addr bias;
      Dwarf_CFI *cfi_eh = INTUSE(dwfl_module_eh_cfi) (mod, &bias);
      if (cfi_eh)
  {
    handle_cfi (state, pc - bias, cfi_eh, bias);
    if (state->unwound)
      {
        state->unwound->unwound_source = DWFL_UNWOUND_EH_CFI;
        return;
      }
  }
      Dwarf_CFI *cfi_dwarf = INTUSE(dwfl_module_dwarf_cfi) (mod, &bias);
      if (cfi_dwarf)
  {
    handle_cfi (state, pc - bias, cfi_dwarf, bias);
    if (state->unwound)
      {
        state->unwound->unwound_source = DWFL_UNWOUND_DWARF_CFI;
        return;
      }
  }
    }
  assert (state->unwound == NULL);
  Dwfl_Thread *thread = state->thread;
  Dwfl_Process *process = thread->process;
  Ebl *ebl = process->ebl;
  if (new_unwound (state) == NULL)
    {
      __libdwfl_seterrno (DWFL_E_NOMEM);
      return;
    }
  state->unwound->pc_state = DWFL_FRAME_STATE_PC_UNDEFINED;
  // &Dwfl_Frame.signal_frame cannot be passed as it is a bitfield.
  bool signal_frame = false;
  if (! ebl_unwind (ebl, pc, setfunc, getfunc, readfunc, state, &signal_frame))
    {
      // Discard the unwind attempt.  During next __libdwfl_frame_unwind call
      // we may have for example the appropriate Dwfl_Module already mapped.
      assert (state->unwound->unwound == NULL);
      free (state->unwound);
      state->unwound = NULL;
      // __libdwfl_seterrno has been called above.
      return;
    }
  state->unwound->unwound_source = DWFL_UNWOUND_EBL;
  assert (state->unwound->pc_state == DWFL_FRAME_STATE_PC_SET);
  state->unwound->signal_frame = signal_frame;
}

Coverage Report

Created: 2025-07-18 06:08