libdwfl/frame_unwind.c

   1 /* Get previous frame state for an existing frame state.
   2    Copyright (C) 2013 Red Hat, Inc.
   3    This file is part of elfutils.
   4
   5    This file is free software; you can redistribute it and/or modify
   6    it under the terms of either
   7
   8      * the GNU Lesser General Public License as published by the Free
   9        Software Foundation; either version 3 of the License, or (at
  10        your option) any later version
  11
  12    or
  13
  14      * the GNU General Public License as published by the Free
  15        Software Foundation; either version 2 of the License, or (at
  16        your option) any later version
  17
  18    or both in parallel, as here.
  19
  20    elfutils is distributed in the hope that it will be useful, but
  21    WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23    General Public License for more details.
  24
  25    You should have received copies of the GNU General Public License and
  26    the GNU Lesser General Public License along with this program.  If
  27    not, see <http://www.gnu.org/licenses/>.  */
  28
  29 #ifdef HAVE_CONFIG_H
  30 # include <config.h>
  31 #endif
  32
  33 #include "cfi.h"
  34 #include <stdlib.h>
  35 #include "libdwflP.h"
  36 #include "../libdw/dwarf.h"
  37 #include <sys/ptrace.h>
  38
  39 /* Maximum number of DWARF expression stack slots before returning an error.  */
  40 #define DWARF_EXPR_STACK_MAX 0x100
  41
  42 /* Maximum number of DWARF expression executed operations before returning an
  43    error.  */
  44 #define DWARF_EXPR_STEPS_MAX 0x1000
  45
  46 #ifndef MAX
  47 # define MAX(a, b) ((a) > (b) ? (a) : (b))
  48 #endif
  49
  50 bool
  51 internal_function
  52 __libdwfl_frame_reg_get (Dwfl_Frame *state, unsigned regno, Dwarf_Addr *val)
  53 {
  54   Ebl *ebl = state->thread->process->ebl;
  55   if (! ebl_dwarf_to_regno (ebl, &regno))
  56     return false;
  57   if (regno >= ebl_frame_nregs (ebl))
  58     return false;
  59   if ((state->regs_set[regno / sizeof (*state->regs_set) / 8]
  60        & (1U << (regno % (sizeof (*state->regs_set) * 8)))) == 0)
  61     return false;
  62   if (val)
  63     *val = state->regs[regno];
  64   return true;
  65 }
  66
  67 bool
  68 internal_function
  69 __libdwfl_frame_reg_set (Dwfl_Frame *state, unsigned regno, Dwarf_Addr val)
  70 {
  71   Ebl *ebl = state->thread->process->ebl;
  72   if (! ebl_dwarf_to_regno (ebl, &regno))
  73     return false;
  74   if (regno >= ebl_frame_nregs (ebl))
  75     return false;
  76   /* For example i386 user_regs_struct has signed fields.  */
  77   if (ebl_get_elfclass (ebl) == ELFCLASS32)
  78     val &= 0xffffffff;
  79   state->regs_set[regno / sizeof (*state->regs_set) / 8] |=
  80                               (1U << (regno % (sizeof (*state->regs_set) * 8)));
  81   state->regs[regno] = val;
  82   return true;
  83 }
  84
  85 static bool
  86 state_get_reg (Dwfl_Frame *state, unsigned regno, Dwarf_Addr *val)
  87 {
  88   if (! __libdwfl_frame_reg_get (state, regno, val))
  89     {
  90       __libdwfl_seterrno (DWFL_E_INVALID_REGISTER);
  91       return false;
  92     }
  93   return true;
  94 }
  95
  96 static int
  97 bra_compar (const void *key_voidp, const void *elem_voidp)
  98 {
  99   Dwarf_Word offset = (uintptr_t) key_voidp;
 100   const Dwarf_Op *op = elem_voidp;
 101   return (offset > op->offset) - (offset < op->offset);
 102 }
 103
 104 /* If FRAME is NULL is are computing CFI frame base.  In such case another
 105    DW_OP_call_frame_cfa is no longer permitted.  */
 106
 107 static bool
 108 expr_eval (Dwfl_Frame *state, Dwarf_Frame *frame, const Dwarf_Op *ops,
 109            size_t nops, Dwarf_Addr *result, Dwarf_Addr bias)
 110 {
 111   Dwfl_Process *process = state->thread->process;
 112   if (nops == 0)
 113     {
 114       __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
 115       return false;
 116     }
 117   Dwarf_Addr *stack = NULL;
 118   size_t stack_used = 0, stack_allocated = 0;
 119
 120   bool
 121   push (Dwarf_Addr val)
 122   {
 123     if (stack_used >= DWARF_EXPR_STACK_MAX)
 124       {
 125         __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
 126         return false;
 127       }
 128     if (stack_used == stack_allocated)
 129       {
 130         stack_allocated = MAX (stack_allocated * 2, 32);
 131         Dwarf_Addr *stack_new = realloc (stack, stack_allocated * sizeof (*stack));
 132         if (stack_new == NULL)
 133           {
 134             __libdwfl_seterrno (DWFL_E_NOMEM);
 135             return false;
 136           }
 137         stack = stack_new;
 138       }
 139     stack[stack_used++] = val;
 140     return true;
 141   }
 142
 143   bool
 144   pop (Dwarf_Addr *val)
 145   {
 146     if (stack_used == 0)
 147       {
 148         __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
 149         return false;
 150       }
 151     *val = stack[--stack_used];
 152     return true;
 153   }
 154
 155   Dwarf_Addr val1, val2;
 156   bool is_location = false;
 157   size_t steps_count = 0;
 158   for (const Dwarf_Op *op = ops; op < ops + nops; op++)
 159     {
 160       if (++steps_count > DWARF_EXPR_STEPS_MAX)
 161         {
 162           __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
 163           return false;
 164         }
 165       switch (op->atom)
 166       {
 167         /* DW_OP_* order matches libgcc/unwind-dw2.c execute_stack_op:  */
 168         case DW_OP_lit0 ... DW_OP_lit31:
 169           if (! push (op->atom - DW_OP_lit0))
 170             {
 171               free (stack);
 172               return false;
 173             }
 174           break;
 175         case DW_OP_addr:
 176           if (! push (op->number + bias))
 177             {
 178               free (stack);
 179               return false;
 180             }
 181           break;
 182         case DW_OP_GNU_encoded_addr:
 183           /* Missing support in the rest of elfutils.  */
 184           __libdwfl_seterrno (DWFL_E_UNSUPPORTED_DWARF);
 185           return false;
 186         case DW_OP_const1u:
 187         case DW_OP_const1s:
 188         case DW_OP_const2u:
 189         case DW_OP_const2s:
 190         case DW_OP_const4u:
 191         case DW_OP_const4s:
 192         case DW_OP_const8u:
 193         case DW_OP_const8s:
 194         case DW_OP_constu:
 195         case DW_OP_consts:
 196           if (! push (op->number))
 197             {
 198               free (stack);
 199               return false;
 200             }
 201           break;
 202         case DW_OP_reg0 ... DW_OP_reg31:
 203           if (! state_get_reg (state, op->atom - DW_OP_reg0, &val1)
 204               || ! push (val1))
 205             {
 206               free (stack);
 207               return false;
 208             }
 209           break;
 210         case DW_OP_regx:
 211           if (! state_get_reg (state, op->number, &val1) || ! push (val1))
 212             {
 213               free (stack);
 214               return false;
 215             }
 216           break;
 217         case DW_OP_breg0 ... DW_OP_breg31:
 218           if (! state_get_reg (state, op->atom - DW_OP_breg0, &val1))
 219             {
 220               free (stack);
 221               return false;
 222             }
 223           val1 += op->number;
 224           if (! push (val1))
 225             {
 226               free (stack);
 227               return false;
 228             }
 229           break;
 230         case DW_OP_bregx:
 231           if (! state_get_reg (state, op->number, &val1))
 232             {
 233               free (stack);
 234               return false;
 235             }
 236           val1 += op->number2;
 237           if (! push (val1))
 238             {
 239               free (stack);
 240               return false;
 241             }
 242           break;
 243         case DW_OP_dup:
 244           if (! pop (&val1) || ! push (val1) || ! push (val1))
 245             {
 246               free (stack);
 247               return false;
 248             }
 249           break;
 250         case DW_OP_drop:
 251           if (! pop (&val1))
 252             {
 253               free (stack);
 254               return false;
 255             }
 256           break;
 257         case DW_OP_pick:
 258           if (stack_used <= op->number)
 259             {
 260               free (stack);
 261               __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
 262               return false;
 263             }
 264           if (! push (stack[stack_used - 1 - op->number]))
 265             {
 266               free (stack);
 267               return false;
 268             }
 269           break;
 270         case DW_OP_over:
 271           if (! pop (&val1) || ! pop (&val2)
 272               || ! push (val2) || ! push (val1) || ! push (val2))
 273             {
 274               free (stack);
 275               return false;
 276             }
 277           break;
 278         case DW_OP_swap:
 279           if (! pop (&val1) || ! pop (&val2) || ! push (val1) || ! push (val2))
 280             {
 281               free (stack);
 282               return false;
 283             }
 284           break;
 285         case DW_OP_rot:
 286           {
 287             Dwarf_Addr val3;
 288             if (! pop (&val1) || ! pop (&val2) || ! pop (&val3)
 289                 || ! push (val1) || ! push (val3) || ! push (val2))
 290               {
 291                 free (stack);
 292                 return false;
 293               }
 294           }
 295           break;
 296         case DW_OP_deref:
 297         case DW_OP_deref_size:
 298           if (process->callbacks->memory_read == NULL)
 299             {
 300               free (stack);
 301               __libdwfl_seterrno (DWFL_E_INVALID_ARGUMENT);
 302               return false;
 303             }
 304           if (! pop (&val1)
 305               || ! process->callbacks->memory_read (process->dwfl, val1, &val1,
 306                                                     process->callbacks_arg))
 307             {
 308               free (stack);
 309               return false;
 310             }
 311           if (op->atom == DW_OP_deref_size)
 312             {
 313               const int elfclass = frame->cache->e_ident[EI_CLASS];
 314               const unsigned addr_bytes = elfclass == ELFCLASS32 ? 4 : 8;
 315               if (op->number > addr_bytes)
 316                 {
 317                   free (stack);
 318                   __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
 319                   return false;
 320                 }
 321 #if BYTE_ORDER == BIG_ENDIAN
 322               if (op->number == 0)
 323                 val1 = 0;
 324               else
 325                 val1 >>= (addr_bytes - op->number) * 8;
 326 #else
 327               if (op->number < 8)
 328                 val1 &= (1 << (op->number * 8)) - 1;
 329 #endif
 330             }
 331           if (! push (val1))
 332             {
 333               free (stack);
 334               return false;
 335             }
 336           break;
 337 #define UNOP(atom, expr)                                                \
 338         case atom:                                                      \
 339           if (! pop (&val1) || ! push (expr))                           \
 340             {                                                           \
 341               free (stack);                                             \
 342               return false;                                             \
 343             }                                                           \
 344           break;
 345         UNOP (DW_OP_abs, abs ((int64_t) val1))
 346         UNOP (DW_OP_neg, -(int64_t) val1)
 347         UNOP (DW_OP_not, ~val1)
 348 #undef UNOP
 349         case DW_OP_plus_uconst:
 350           if (! pop (&val1) || ! push (val1 + op->number))
 351             {
 352               free (stack);
 353               return false;
 354             }
 355           break;
 356 #define BINOP(atom, op)                                                 \
 357         case atom:                                                      \
 358           if (! pop (&val2) || ! pop (&val1) || ! push (val1 op val2))  \
 359             {                                                           \
 360               free (stack);                                             \
 361               return false;                                             \
 362             }                                                           \
 363           break;
 364 #define BINOP_SIGNED(atom, op)                                          \
 365         case atom:                                                      \
 366           if (! pop (&val2) || ! pop (&val1)                            \
 367               || ! push ((int64_t) val1 op (int64_t) val2))             \
 368             {                                                           \
 369               free (stack);                                             \
 370               return false;                                             \
 371             }                                                           \
 372           break;
 373         BINOP (DW_OP_and, &)
 374         case DW_OP_div:
 375           if (! pop (&val2) || ! pop (&val1))
 376             {
 377               free (stack);
 378               return false;
 379             }
 380           if (val2 == 0)
 381             {
 382               free (stack);
 383               __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
 384               return false;
 385             }
 386           if (! push ((int64_t) val1 / (int64_t) val2))
 387             {
 388               free (stack);
 389               return false;
 390             }
 391           break;
 392         BINOP (DW_OP_minus, -)
 393         case DW_OP_mod:
 394           if (! pop (&val2) || ! pop (&val1))
 395             {
 396               free (stack);
 397               return false;
 398             }
 399           if (val2 == 0)
 400             {
 401               free (stack);
 402               __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
 403               return false;
 404             }
 405           if (! push (val1 % val2))
 406             {
 407               free (stack);
 408               return false;
 409             }
 410           break;
 411         BINOP (DW_OP_mul, *)
 412         BINOP (DW_OP_or, |)
 413         BINOP (DW_OP_plus, +)
 414         BINOP (DW_OP_shl, <<)
 415         BINOP (DW_OP_shr, >>)
 416         BINOP_SIGNED (DW_OP_shra, >>)
 417         BINOP (DW_OP_xor, ^)
 418         BINOP_SIGNED (DW_OP_le, <=)
 419         BINOP_SIGNED (DW_OP_ge, >=)
 420         BINOP_SIGNED (DW_OP_eq, ==)
 421         BINOP_SIGNED (DW_OP_lt, <)
 422         BINOP_SIGNED (DW_OP_gt, >)
 423         BINOP_SIGNED (DW_OP_ne, !=)
 424 #undef BINOP
 425 #undef BINOP_SIGNED
 426         case DW_OP_bra:
 427           if (! pop (&val1))
 428             {
 429               free (stack);
 430               return false;
 431             }
 432           if (val1 == 0)
 433             break;
 434           /* FALLTHRU */
 435         case DW_OP_skip:;
 436           Dwarf_Word offset = op->offset + 1 + 2 + (int16_t) op->number;
 437           const Dwarf_Op *found = bsearch ((void *) (uintptr_t) offset, ops, nops,
 438                                            sizeof (*ops), bra_compar);
 439           if (found == NULL)
 440             {
 441               free (stack);
 442               /* PPC32 vDSO has such invalid operations.  */
 443               __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
 444               return false;
 445             }
 446           /* Undo the 'for' statement increment.  */
 447           op = found - 1;
 448           break;
 449         case DW_OP_nop:
 450           break;
 451         /* DW_OP_* not listed in libgcc/unwind-dw2.c execute_stack_op:  */
 452         case DW_OP_call_frame_cfa:;
 453           // Not used by CFI itself but it is synthetized by elfutils internation.
 454           Dwarf_Op *cfa_ops;
 455           size_t cfa_nops;
 456           Dwarf_Addr cfa;
 457           if (frame == NULL
 458               || dwarf_frame_cfa (frame, &cfa_ops, &cfa_nops) != 0
 459               || ! expr_eval (state, NULL, cfa_ops, cfa_nops, &cfa, bias)
 460               || ! push (cfa))
 461             {
 462               __libdwfl_seterrno (DWFL_E_LIBDW);
 463               free (stack);
 464               return false;
 465             }
 466           is_location = true;
 467           break;
 468         case DW_OP_stack_value:
 469           // Not used by CFI itself but it is synthetized by elfutils internation.
 470           is_location = false;
 471           break;
 472         default:
 473           __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
 474           return false;
 475       }
 476     }
 477   if (! pop (result))
 478     {
 479       free (stack);
 480       return false;
 481     }
 482   free (stack);
 483   if (is_location)
 484     {
 485       if (process->callbacks->memory_read == NULL)
 486         {
 487           __libdwfl_seterrno (DWFL_E_INVALID_ARGUMENT);
 488           return false;
 489         }
 490       if (! process->callbacks->memory_read (process->dwfl, *result, result,
 491                                              process->callbacks_arg))
 492         return false;
 493     }
 494   return true;
 495 }
 496
 497 static void
 498 new_unwound (Dwfl_Frame *state)
 499 {
 500   assert (state->unwound == NULL);
 501   Dwfl_Thread *thread = state->thread;
 502   Dwfl_Process *process = thread->process;
 503   Ebl *ebl = process->ebl;
 504   size_t nregs = ebl_frame_nregs (ebl);
 505   assert (nregs > 0);
 506   Dwfl_Frame *unwound;
 507   unwound = malloc (sizeof (*unwound) + sizeof (*unwound->regs) * nregs);
 508   state->unwound = unwound;
 509   unwound->thread = thread;
 510   unwound->unwound = NULL;
 511   unwound->signal_frame = false;
 512   unwound->initial_frame = false;
 513   unwound->pc_state = DWFL_FRAME_STATE_ERROR;
 514   memset (unwound->regs_set, 0, sizeof (unwound->regs_set));
 515 }
 516
 517 /* The logic is to call __libdwfl_seterrno for any CFI bytecode interpretation
 518    error so one can easily catch the problem with a debugger.  Still there are
 519    archs with invalid CFI for some registers where the registers are never used
 520    later.  Therefore we continue unwinding leaving the registers undefined.  */
 521
 522 static void
 523 handle_cfi (Dwfl_Frame *state, Dwarf_Addr pc, Dwarf_CFI *cfi, Dwarf_Addr bias)
 524 {
 525   Dwarf_Frame *frame;
 526   if (INTUSE(dwarf_cfi_addrframe) (cfi, pc, &frame) != 0)
 527     {
 528       __libdwfl_seterrno (DWFL_E_LIBDW);
 529       return;
 530     }
 531   new_unwound (state);
 532   Dwfl_Frame *unwound = state->unwound;
 533   unwound->signal_frame = frame->fde->cie->signal_frame;
 534   Dwfl_Thread *thread = state->thread;
 535   Dwfl_Process *process = thread->process;
 536   Ebl *ebl = process->ebl;
 537   size_t nregs = ebl_frame_nregs (ebl);
 538   assert (nregs > 0);
 539
 540   /* The return register is special for setting the unwound->pc_state.  */
 541   unsigned ra = frame->fde->cie->return_address_register;
 542   bool ra_set = false;
 543   ebl_dwarf_to_regno (ebl, &ra);
 544
 545   for (unsigned regno = 0; regno < nregs; regno++)
 546     {
 547       Dwarf_Op reg_ops_mem[3], *reg_ops;
 548       size_t reg_nops;
 549       if (dwarf_frame_register (frame, regno, reg_ops_mem, &reg_ops,
 550                                 &reg_nops) != 0)
 551         {
 552           __libdwfl_seterrno (DWFL_E_LIBDW);
 553           continue;
 554         }
 555       Dwarf_Addr regval;
 556       if (reg_nops == 0)
 557         {
 558           if (reg_ops == reg_ops_mem)
 559             {
 560               /* REGNO is undefined.  */
 561               if (regno == ra)
 562                 unwound->pc_state = DWFL_FRAME_STATE_PC_UNDEFINED;
 563               continue;
 564             }
 565           else if (reg_ops == NULL)
 566             {
 567               /* REGNO is same-value.  */
 568               if (! state_get_reg (state, regno, &regval))
 569                 continue;
 570             }
 571           else
 572             {
 573               __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
 574               continue;
 575             }
 576         }
 577       else if (! expr_eval (state, frame, reg_ops, reg_nops, &regval, bias))
 578         {
 579           /* PPC32 vDSO has various invalid operations, ignore them.  The
 580              register will look as unset causing an error later, if used.
 581              But PPC32 does not use such registers.  */
 582           continue;
 583         }
 584
 585       /* This is another strange PPC[64] case.  There are two
 586          registers numbers that can represent the same DWARF return
 587          register number.  We only want one to actually set the return
 588          register value.  */
 589       if (ra_set)
 590         {
 591           unsigned r = regno;
 592           if (ebl_dwarf_to_regno (ebl, &r) && r == ra)
 593             continue;
 594         }
 595
 596       if (! __libdwfl_frame_reg_set (unwound, regno, regval))
 597         {
 598           __libdwfl_seterrno (DWFL_E_INVALID_REGISTER);
 599           continue;
 600         }
 601       else if (! ra_set)
 602         {
 603           unsigned r = regno;
 604           if (ebl_dwarf_to_regno (ebl, &r) && r == ra)
 605             ra_set = true;
 606         }
 607     }
 608   if (unwound->pc_state == DWFL_FRAME_STATE_ERROR
 609       && __libdwfl_frame_reg_get (unwound,
 610                                   frame->fde->cie->return_address_register,
 611                                   &unwound->pc))
 612     {
 613       /* PPC32 __libc_start_main properly CFI-unwinds PC as zero.  Currently
 614          none of the archs supported for unwinding have zero as a valid PC.  */
 615       if (unwound->pc == 0)
 616         unwound->pc_state = DWFL_FRAME_STATE_PC_UNDEFINED;
 617       else
 618         unwound->pc_state = DWFL_FRAME_STATE_PC_SET;
 619     }
 620   free (frame);
 621 }
 622
 623 static bool
 624 setfunc (int firstreg, unsigned nregs, const Dwarf_Word *regs, void *arg)
 625 {
 626   Dwfl_Frame *state = arg;
 627   Dwfl_Frame *unwound = state->unwound;
 628   if (firstreg < 0)
 629     {
 630       assert (firstreg == -1);
 631       assert (nregs == 1);
 632       assert (unwound->pc_state == DWFL_FRAME_STATE_PC_UNDEFINED);
 633       unwound->pc = *regs;
 634       unwound->pc_state = DWFL_FRAME_STATE_PC_SET;
 635       return true;
 636     }
 637   while (nregs--)
 638     if (! __libdwfl_frame_reg_set (unwound, firstreg++, *regs++))
 639       return false;
 640   return true;
 641 }
 642
 643 static bool
 644 getfunc (int firstreg, unsigned nregs, Dwarf_Word *regs, void *arg)
 645 {
 646   Dwfl_Frame *state = arg;
 647   assert (firstreg >= 0);
 648   while (nregs--)
 649     if (! __libdwfl_frame_reg_get (state, firstreg++, regs++))
 650       return false;
 651   return true;
 652 }
 653
 654 static bool
 655 readfunc (Dwarf_Addr addr, Dwarf_Word *datap, void *arg)
 656 {
 657   Dwfl_Frame *state = arg;
 658   Dwfl_Thread *thread = state->thread;
 659   Dwfl_Process *process = thread->process;
 660   return process->callbacks->memory_read (process->dwfl, addr, datap,
 661                                           process->callbacks_arg);
 662 }
 663
 664 void
 665 internal_function
 666 __libdwfl_frame_unwind (Dwfl_Frame *state)
 667 {
 668   if (state->unwound)
 669     return;
 670   /* Do not ask dwfl_frame_pc for ISACTIVATION, it would try to unwind STATE
 671      which would deadlock us.  */
 672   Dwarf_Addr pc;
 673   bool ok = INTUSE(dwfl_frame_pc) (state, &pc, NULL);
 674   assert (ok);
 675   /* Check whether this is the initial frame or a signal frame.
 676      Then we need to unwind from the original, unadjusted PC.  */
 677   if (! state->initial_frame && ! state->signal_frame)
 678     pc--;
 679   Dwfl_Module *mod = INTUSE(dwfl_addrmodule) (state->thread->process->dwfl, pc);
 680   if (mod == NULL)
 681     __libdwfl_seterrno (DWFL_E_NO_DWARF);
 682   else
 683     {
 684       Dwarf_Addr bias;
 685       Dwarf_CFI *cfi_eh = INTUSE(dwfl_module_eh_cfi) (mod, &bias);
 686       if (cfi_eh)
 687         {
 688           handle_cfi (state, pc - bias, cfi_eh, bias);
 689           if (state->unwound)
 690             return;
 691         }
 692       Dwarf_CFI *cfi_dwarf = INTUSE(dwfl_module_dwarf_cfi) (mod, &bias);
 693       if (cfi_dwarf)
 694         {
 695           handle_cfi (state, pc - bias, cfi_dwarf, bias);
 696           if (state->unwound)
 697             return;
 698         }
 699     }
 700   assert (state->unwound == NULL);
 701   Dwfl_Thread *thread = state->thread;
 702   Dwfl_Process *process = thread->process;
 703   Ebl *ebl = process->ebl;
 704   new_unwound (state);
 705   state->unwound->pc_state = DWFL_FRAME_STATE_PC_UNDEFINED;
 706   // &Dwfl_Frame.signal_frame cannot be passed as it is a bitfield.
 707   bool signal_frame = false;
 708   if (! ebl_unwind (ebl, pc, setfunc, getfunc, readfunc, state, &signal_frame))
 709     {
 710       // Discard the unwind attempt.  During next __libdwfl_frame_unwind call
 711       // we may have for example the appropriate Dwfl_Module already mapped.
 712       assert (state->unwound->unwound == NULL);
 713       free (state->unwound);
 714       state->unwound = NULL;
 715       // __libdwfl_seterrno has been called above.
 716       return;
 717     }
 718   assert (state->unwound->pc_state == DWFL_FRAME_STATE_PC_SET);
 719   state->unwound->signal_frame = signal_frame;
 720 }