1 /* Get previous frame state for an existing frame state. 2 Copyright (C) 2013, 2014 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, ®no)) 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 & ((uint64_t) 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, ®no)) 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 ((uint64_t) 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 struct eval_stack { 105 Dwarf_Addr *addrs; 106 size_t used; 107 size_t allocated; 108 }; 109 110 static bool 111 do_push (struct eval_stack *stack, Dwarf_Addr val) 112 { 113 if (stack->used >= DWARF_EXPR_STACK_MAX) 114 { 115 __libdwfl_seterrno (DWFL_E_INVALID_DWARF); 116 return false; 117 } 118 if (stack->used == stack->allocated) 119 { 120 stack->allocated = MAX (stack->allocated * 2, 32); 121 Dwarf_Addr *new_addrs; 122 new_addrs = realloc (stack->addrs, 123 stack->allocated * sizeof (*stack->addrs)); 124 if (new_addrs == NULL) 125 { 126 __libdwfl_seterrno (DWFL_E_NOMEM); 127 return false; 128 } 129 stack->addrs = new_addrs; 130 } 131 stack->addrs[stack->used++] = val; 132 return true; 133 } 134 135 static bool 136 do_pop (struct eval_stack *stack, Dwarf_Addr *val) 137 { 138 if (stack->used == 0) 139 { 140 __libdwfl_seterrno (DWFL_E_INVALID_DWARF); 141 return false; 142 } 143 *val = stack->addrs[--stack->used]; 144 return true; 145 } 146 147 /* If FRAME is NULL is are computing CFI frame base. In such case another 148 DW_OP_call_frame_cfa is no longer permitted. */ 149 150 static bool 151 expr_eval (Dwfl_Frame *state, Dwarf_Frame *frame, const Dwarf_Op *ops, 152 size_t nops, Dwarf_Addr *result, Dwarf_Addr bias) 153 { 154 Dwfl_Process *process = state->thread->process; 155 if (nops == 0) 156 { 157 __libdwfl_seterrno (DWFL_E_INVALID_DWARF); 158 return false; 159 } 160 struct eval_stack stack = 161 { 162 .addrs = NULL, 163 .used = 0, 164 .allocated = 0 165 }; 166 167 #define pop(x) do_pop(&stack, x) 168 #define push(x) do_push(&stack, x) 169 170 Dwarf_Addr val1, val2; 171 bool is_location = false; 172 size_t steps_count = 0; 173 for (const Dwarf_Op *op = ops; op < ops + nops; op++) 174 { 175 if (++steps_count > DWARF_EXPR_STEPS_MAX) 176 { 177 __libdwfl_seterrno (DWFL_E_INVALID_DWARF); 178 return false; 179 } 180 switch (op->atom) 181 { 182 /* DW_OP_* order matches libgcc/unwind-dw2.c execute_stack_op: */ 183 case DW_OP_lit0 ... DW_OP_lit31: 184 if (! push (op->atom - DW_OP_lit0)) 185 { 186 free (stack.addrs); 187 return false; 188 } 189 break; 190 case DW_OP_addr: 191 if (! push (op->number + bias)) 192 { 193 free (stack.addrs); 194 return false; 195 } 196 break; 197 case DW_OP_GNU_encoded_addr: 198 /* Missing support in the rest of elfutils. */ 199 __libdwfl_seterrno (DWFL_E_UNSUPPORTED_DWARF); 200 return false; 201 case DW_OP_const1u: 202 case DW_OP_const1s: 203 case DW_OP_const2u: 204 case DW_OP_const2s: 205 case DW_OP_const4u: 206 case DW_OP_const4s: 207 case DW_OP_const8u: 208 case DW_OP_const8s: 209 case DW_OP_constu: 210 case DW_OP_consts: 211 if (! push (op->number)) 212 { 213 free (stack.addrs); 214 return false; 215 } 216 break; 217 case DW_OP_reg0 ... DW_OP_reg31: 218 if (! state_get_reg (state, op->atom - DW_OP_reg0, &val1) 219 || ! push (val1)) 220 { 221 free (stack.addrs); 222 return false; 223 } 224 break; 225 case DW_OP_regx: 226 if (! state_get_reg (state, op->number, &val1) || ! push (val1)) 227 { 228 free (stack.addrs); 229 return false; 230 } 231 break; 232 case DW_OP_breg0 ... DW_OP_breg31: 233 if (! state_get_reg (state, op->atom - DW_OP_breg0, &val1)) 234 { 235 free (stack.addrs); 236 return false; 237 } 238 val1 += op->number; 239 if (! push (val1)) 240 { 241 free (stack.addrs); 242 return false; 243 } 244 break; 245 case DW_OP_bregx: 246 if (! state_get_reg (state, op->number, &val1)) 247 { 248 free (stack.addrs); 249 return false; 250 } 251 val1 += op->number2; 252 if (! push (val1)) 253 { 254 free (stack.addrs); 255 return false; 256 } 257 break; 258 case DW_OP_dup: 259 if (! pop (&val1) || ! push (val1) || ! push (val1)) 260 { 261 free (stack.addrs); 262 return false; 263 } 264 break; 265 case DW_OP_drop: 266 if (! pop (&val1)) 267 { 268 free (stack.addrs); 269 return false; 270 } 271 break; 272 case DW_OP_pick: 273 if (stack.used <= op->number) 274 { 275 free (stack.addrs); 276 __libdwfl_seterrno (DWFL_E_INVALID_DWARF); 277 return false; 278 } 279 if (! push (stack.addrs[stack.used - 1 - op->number])) 280 { 281 free (stack.addrs); 282 return false; 283 } 284 break; 285 case DW_OP_over: 286 if (! pop (&val1) || ! pop (&val2) 287 || ! push (val2) || ! push (val1) || ! push (val2)) 288 { 289 free (stack.addrs); 290 return false; 291 } 292 break; 293 case DW_OP_swap: 294 if (! pop (&val1) || ! pop (&val2) || ! push (val1) || ! push (val2)) 295 { 296 free (stack.addrs); 297 return false; 298 } 299 break; 300 case DW_OP_rot: 301 { 302 Dwarf_Addr val3; 303 if (! pop (&val1) || ! pop (&val2) || ! pop (&val3) 304 || ! push (val1) || ! push (val3) || ! push (val2)) 305 { 306 free (stack.addrs); 307 return false; 308 } 309 } 310 break; 311 case DW_OP_deref: 312 case DW_OP_deref_size: 313 if (process->callbacks->memory_read == NULL) 314 { 315 free (stack.addrs); 316 __libdwfl_seterrno (DWFL_E_INVALID_ARGUMENT); 317 return false; 318 } 319 if (! pop (&val1) 320 || ! process->callbacks->memory_read (process->dwfl, val1, &val1, 321 process->callbacks_arg)) 322 { 323 free (stack.addrs); 324 return false; 325 } 326 if (op->atom == DW_OP_deref_size) 327 { 328 const int elfclass = frame->cache->e_ident[EI_CLASS]; 329 const unsigned addr_bytes = elfclass == ELFCLASS32 ? 4 : 8; 330 if (op->number > addr_bytes) 331 { 332 free (stack.addrs); 333 __libdwfl_seterrno (DWFL_E_INVALID_DWARF); 334 return false; 335 } 336 #if BYTE_ORDER == BIG_ENDIAN 337 if (op->number == 0) 338 val1 = 0; 339 else 340 val1 >>= (addr_bytes - op->number) * 8; 341 #else 342 if (op->number < 8) 343 val1 &= (1 << (op->number * 8)) - 1; 344 #endif 345 } 346 if (! push (val1)) 347 { 348 free (stack.addrs); 349 return false; 350 } 351 break; 352 #define UNOP(atom, expr) \ 353 case atom: \ 354 if (! pop (&val1) || ! push (expr)) \ 355 { \ 356 free (stack.addrs); \ 357 return false; \ 358 } \ 359 break; 360 UNOP (DW_OP_abs, llabs ((int64_t) val1)) 361 UNOP (DW_OP_neg, -(int64_t) val1) 362 UNOP (DW_OP_not, ~val1) 363 #undef UNOP 364 case DW_OP_plus_uconst: 365 if (! pop (&val1) || ! push (val1 + op->number)) 366 { 367 free (stack.addrs); 368 return false; 369 } 370 break; 371 #define BINOP(atom, op) \ 372 case atom: \ 373 if (! pop (&val2) || ! pop (&val1) || ! push (val1 op val2)) \ 374 { \ 375 free (stack.addrs); \ 376 return false; \ 377 } \ 378 break; 379 #define BINOP_SIGNED(atom, op) \ 380 case atom: \ 381 if (! pop (&val2) || ! pop (&val1) \ 382 || ! push ((int64_t) val1 op (int64_t) val2)) \ 383 { \ 384 free (stack.addrs); \ 385 return false; \ 386 } \ 387 break; 388 BINOP (DW_OP_and, &) 389 case DW_OP_div: 390 if (! pop (&val2) || ! pop (&val1)) 391 { 392 free (stack.addrs); 393 return false; 394 } 395 if (val2 == 0) 396 { 397 free (stack.addrs); 398 __libdwfl_seterrno (DWFL_E_INVALID_DWARF); 399 return false; 400 } 401 if (! push ((int64_t) val1 / (int64_t) val2)) 402 { 403 free (stack.addrs); 404 return false; 405 } 406 break; 407 BINOP (DW_OP_minus, -) 408 case DW_OP_mod: 409 if (! pop (&val2) || ! pop (&val1)) 410 { 411 free (stack.addrs); 412 return false; 413 } 414 if (val2 == 0) 415 { 416 free (stack.addrs); 417 __libdwfl_seterrno (DWFL_E_INVALID_DWARF); 418 return false; 419 } 420 if (! push (val1 % val2)) 421 { 422 free (stack.addrs); 423 return false; 424 } 425 break; 426 BINOP (DW_OP_mul, *) 427 BINOP (DW_OP_or, |) 428 BINOP (DW_OP_plus, +) 429 BINOP (DW_OP_shl, <<) 430 BINOP (DW_OP_shr, >>) 431 BINOP_SIGNED (DW_OP_shra, >>) 432 BINOP (DW_OP_xor, ^) 433 BINOP_SIGNED (DW_OP_le, <=) 434 BINOP_SIGNED (DW_OP_ge, >=) 435 BINOP_SIGNED (DW_OP_eq, ==) 436 BINOP_SIGNED (DW_OP_lt, <) 437 BINOP_SIGNED (DW_OP_gt, >) 438 BINOP_SIGNED (DW_OP_ne, !=) 439 #undef BINOP 440 #undef BINOP_SIGNED 441 case DW_OP_bra: 442 if (! pop (&val1)) 443 { 444 free (stack.addrs); 445 return false; 446 } 447 if (val1 == 0) 448 break; 449 /* FALLTHRU */ 450 case DW_OP_skip:; 451 Dwarf_Word offset = op->offset + 1 + 2 + (int16_t) op->number; 452 const Dwarf_Op *found = bsearch ((void *) (uintptr_t) offset, ops, nops, 453 sizeof (*ops), bra_compar); 454 if (found == NULL) 455 { 456 free (stack.addrs); 457 /* PPC32 vDSO has such invalid operations. */ 458 __libdwfl_seterrno (DWFL_E_INVALID_DWARF); 459 return false; 460 } 461 /* Undo the 'for' statement increment. */ 462 op = found - 1; 463 break; 464 case DW_OP_nop: 465 break; 466 /* DW_OP_* not listed in libgcc/unwind-dw2.c execute_stack_op: */ 467 case DW_OP_call_frame_cfa:; 468 // Not used by CFI itself but it is synthetized by elfutils internation. 469 Dwarf_Op *cfa_ops; 470 size_t cfa_nops; 471 Dwarf_Addr cfa; 472 if (frame == NULL 473 || dwarf_frame_cfa (frame, &cfa_ops, &cfa_nops) != 0 474 || ! expr_eval (state, NULL, cfa_ops, cfa_nops, &cfa, bias) 475 || ! push (cfa)) 476 { 477 __libdwfl_seterrno (DWFL_E_LIBDW); 478 free (stack.addrs); 479 return false; 480 } 481 is_location = true; 482 break; 483 case DW_OP_stack_value: 484 // Not used by CFI itself but it is synthetized by elfutils internation. 485 is_location = false; 486 break; 487 default: 488 __libdwfl_seterrno (DWFL_E_INVALID_DWARF); 489 return false; 490 } 491 } 492 if (! pop (result)) 493 { 494 free (stack.addrs); 495 return false; 496 } 497 free (stack.addrs); 498 if (is_location) 499 { 500 if (process->callbacks->memory_read == NULL) 501 { 502 __libdwfl_seterrno (DWFL_E_INVALID_ARGUMENT); 503 return false; 504 } 505 if (! process->callbacks->memory_read (process->dwfl, *result, result, 506 process->callbacks_arg)) 507 return false; 508 } 509 return true; 510 #undef push 511 #undef pop 512 } 513 514 static void 515 new_unwound (Dwfl_Frame *state) 516 { 517 assert (state->unwound == NULL); 518 Dwfl_Thread *thread = state->thread; 519 Dwfl_Process *process = thread->process; 520 Ebl *ebl = process->ebl; 521 size_t nregs = ebl_frame_nregs (ebl); 522 assert (nregs > 0); 523 Dwfl_Frame *unwound; 524 unwound = malloc (sizeof (*unwound) + sizeof (*unwound->regs) * nregs); 525 state->unwound = unwound; 526 unwound->thread = thread; 527 unwound->unwound = NULL; 528 unwound->signal_frame = false; 529 unwound->initial_frame = false; 530 unwound->pc_state = DWFL_FRAME_STATE_ERROR; 531 memset (unwound->regs_set, 0, sizeof (unwound->regs_set)); 532 } 533 534 /* The logic is to call __libdwfl_seterrno for any CFI bytecode interpretation 535 error so one can easily catch the problem with a debugger. Still there are 536 archs with invalid CFI for some registers where the registers are never used 537 later. Therefore we continue unwinding leaving the registers undefined. */ 538 539 static void 540 handle_cfi (Dwfl_Frame *state, Dwarf_Addr pc, Dwarf_CFI *cfi, Dwarf_Addr bias) 541 { 542 Dwarf_Frame *frame; 543 if (INTUSE(dwarf_cfi_addrframe) (cfi, pc, &frame) != 0) 544 { 545 __libdwfl_seterrno (DWFL_E_LIBDW); 546 return; 547 } 548 new_unwound (state); 549 Dwfl_Frame *unwound = state->unwound; 550 unwound->signal_frame = frame->fde->cie->signal_frame; 551 Dwfl_Thread *thread = state->thread; 552 Dwfl_Process *process = thread->process; 553 Ebl *ebl = process->ebl; 554 size_t nregs = ebl_frame_nregs (ebl); 555 assert (nregs > 0); 556 557 /* The return register is special for setting the unwound->pc_state. */ 558 unsigned ra = frame->fde->cie->return_address_register; 559 bool ra_set = false; 560 ebl_dwarf_to_regno (ebl, &ra); 561 562 for (unsigned regno = 0; regno < nregs; regno++) 563 { 564 Dwarf_Op reg_ops_mem[3], *reg_ops; 565 size_t reg_nops; 566 if (dwarf_frame_register (frame, regno, reg_ops_mem, ®_ops, 567 ®_nops) != 0) 568 { 569 __libdwfl_seterrno (DWFL_E_LIBDW); 570 continue; 571 } 572 Dwarf_Addr regval; 573 if (reg_nops == 0) 574 { 575 if (reg_ops == reg_ops_mem) 576 { 577 /* REGNO is undefined. */ 578 if (regno == ra) 579 unwound->pc_state = DWFL_FRAME_STATE_PC_UNDEFINED; 580 continue; 581 } 582 else if (reg_ops == NULL) 583 { 584 /* REGNO is same-value. */ 585 if (! state_get_reg (state, regno, ®val)) 586 continue; 587 } 588 else 589 { 590 __libdwfl_seterrno (DWFL_E_INVALID_DWARF); 591 continue; 592 } 593 } 594 else if (! expr_eval (state, frame, reg_ops, reg_nops, ®val, bias)) 595 { 596 /* PPC32 vDSO has various invalid operations, ignore them. The 597 register will look as unset causing an error later, if used. 598 But PPC32 does not use such registers. */ 599 continue; 600 } 601 602 /* Some architectures encode some extra info in the return address. */ 603 if (regno == frame->fde->cie->return_address_register) 604 regval &= ebl_func_addr_mask (ebl); 605 606 /* This is another strange PPC[64] case. There are two 607 registers numbers that can represent the same DWARF return 608 register number. We only want one to actually set the return 609 register value. But we always want to override the value if 610 the register is the actual CIE return address register. */ 611 if (ra_set && regno != frame->fde->cie->return_address_register) 612 { 613 unsigned r = regno; 614 if (ebl_dwarf_to_regno (ebl, &r) && r == ra) 615 continue; 616 } 617 618 if (! __libdwfl_frame_reg_set (unwound, regno, regval)) 619 { 620 __libdwfl_seterrno (DWFL_E_INVALID_REGISTER); 621 continue; 622 } 623 else if (! ra_set) 624 { 625 unsigned r = regno; 626 if (ebl_dwarf_to_regno (ebl, &r) && r == ra) 627 ra_set = true; 628 } 629 } 630 if (unwound->pc_state == DWFL_FRAME_STATE_ERROR 631 && __libdwfl_frame_reg_get (unwound, 632 frame->fde->cie->return_address_register, 633 &unwound->pc)) 634 { 635 /* PPC32 __libc_start_main properly CFI-unwinds PC as zero. Currently 636 none of the archs supported for unwinding have zero as a valid PC. */ 637 if (unwound->pc == 0) 638 unwound->pc_state = DWFL_FRAME_STATE_PC_UNDEFINED; 639 else 640 { 641 unwound->pc_state = DWFL_FRAME_STATE_PC_SET; 642 /* In SPARC the return address register actually contains 643 the address of the call instruction instead of the return 644 address. Therefore we add here an offset defined by the 645 backend. Most likely 0. */ 646 unwound->pc += ebl_ra_offset (ebl); 647 } 648 } 649 free (frame); 650 } 651 652 static bool 653 setfunc (int firstreg, unsigned nregs, const Dwarf_Word *regs, void *arg) 654 { 655 Dwfl_Frame *state = arg; 656 Dwfl_Frame *unwound = state->unwound; 657 if (firstreg < 0) 658 { 659 assert (firstreg == -1); 660 assert (nregs == 1); 661 assert (unwound->pc_state == DWFL_FRAME_STATE_PC_UNDEFINED); 662 unwound->pc = *regs; 663 unwound->pc_state = DWFL_FRAME_STATE_PC_SET; 664 return true; 665 } 666 while (nregs--) 667 if (! __libdwfl_frame_reg_set (unwound, firstreg++, *regs++)) 668 return false; 669 return true; 670 } 671 672 static bool 673 getfunc (int firstreg, unsigned nregs, Dwarf_Word *regs, void *arg) 674 { 675 Dwfl_Frame *state = arg; 676 assert (firstreg >= 0); 677 while (nregs--) 678 if (! __libdwfl_frame_reg_get (state, firstreg++, regs++)) 679 return false; 680 return true; 681 } 682 683 static bool 684 readfunc (Dwarf_Addr addr, Dwarf_Word *datap, void *arg) 685 { 686 Dwfl_Frame *state = arg; 687 Dwfl_Thread *thread = state->thread; 688 Dwfl_Process *process = thread->process; 689 return process->callbacks->memory_read (process->dwfl, addr, datap, 690 process->callbacks_arg); 691 } 692 693 void 694 internal_function 695 __libdwfl_frame_unwind (Dwfl_Frame *state) 696 { 697 if (state->unwound) 698 return; 699 /* Do not ask dwfl_frame_pc for ISACTIVATION, it would try to unwind STATE 700 which would deadlock us. */ 701 Dwarf_Addr pc; 702 bool ok = INTUSE(dwfl_frame_pc) (state, &pc, NULL); 703 assert (ok); 704 /* Check whether this is the initial frame or a signal frame. 705 Then we need to unwind from the original, unadjusted PC. */ 706 if (! state->initial_frame && ! state->signal_frame) 707 pc--; 708 Dwfl_Module *mod = INTUSE(dwfl_addrmodule) (state->thread->process->dwfl, pc); 709 if (mod == NULL) 710 __libdwfl_seterrno (DWFL_E_NO_DWARF); 711 else 712 { 713 Dwarf_Addr bias; 714 Dwarf_CFI *cfi_eh = INTUSE(dwfl_module_eh_cfi) (mod, &bias); 715 if (cfi_eh) 716 { 717 handle_cfi (state, pc - bias, cfi_eh, bias); 718 if (state->unwound) 719 return; 720 } 721 Dwarf_CFI *cfi_dwarf = INTUSE(dwfl_module_dwarf_cfi) (mod, &bias); 722 if (cfi_dwarf) 723 { 724 handle_cfi (state, pc - bias, cfi_dwarf, bias); 725 if (state->unwound) 726 return; 727 } 728 } 729 assert (state->unwound == NULL); 730 Dwfl_Thread *thread = state->thread; 731 Dwfl_Process *process = thread->process; 732 Ebl *ebl = process->ebl; 733 new_unwound (state); 734 state->unwound->pc_state = DWFL_FRAME_STATE_PC_UNDEFINED; 735 // &Dwfl_Frame.signal_frame cannot be passed as it is a bitfield. 736 bool signal_frame = false; 737 if (! ebl_unwind (ebl, pc, setfunc, getfunc, readfunc, state, &signal_frame)) 738 { 739 // Discard the unwind attempt. During next __libdwfl_frame_unwind call 740 // we may have for example the appropriate Dwfl_Module already mapped. 741 assert (state->unwound->unwound == NULL); 742 free (state->unwound); 743 state->unwound = NULL; 744 // __libdwfl_seterrno has been called above. 745 return; 746 } 747 assert (state->unwound->pc_state == DWFL_FRAME_STATE_PC_SET); 748 state->unwound->signal_frame = signal_frame; 749 } 750
