1 /* Get previous frame state for an existing frame state.
2 Copyright (C) 2013, 2014, 2016 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 <system.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 int
47 internal_function
__libdwfl_frame_reg_get(Dwfl_Frame * state,unsigned regno,Dwarf_Addr * val)48 __libdwfl_frame_reg_get (Dwfl_Frame *state, unsigned regno, Dwarf_Addr *val)
49 {
50 Ebl *ebl = state->thread->process->ebl;
51 if (! ebl_dwarf_to_regno (ebl, ®no))
52 return -1;
53 if (regno >= ebl_frame_nregs (ebl))
54 return -1;
55 if ((state->regs_set[regno / sizeof (*state->regs_set) / 8]
56 & ((uint64_t) 1U << (regno % (sizeof (*state->regs_set) * 8)))) == 0)
57 return 1;
58 if (val)
59 *val = state->regs[regno];
60 return 0;
61 }
62
63 bool
64 internal_function
__libdwfl_frame_reg_set(Dwfl_Frame * state,unsigned regno,Dwarf_Addr val)65 __libdwfl_frame_reg_set (Dwfl_Frame *state, unsigned regno, Dwarf_Addr val)
66 {
67 Ebl *ebl = state->thread->process->ebl;
68 if (! ebl_dwarf_to_regno (ebl, ®no))
69 return false;
70 if (regno >= ebl_frame_nregs (ebl))
71 return false;
72 /* For example i386 user_regs_struct has signed fields. */
73 if (ebl_get_elfclass (ebl) == ELFCLASS32)
74 val &= 0xffffffff;
75 state->regs_set[regno / sizeof (*state->regs_set) / 8] |=
76 ((uint64_t) 1U << (regno % (sizeof (*state->regs_set) * 8)));
77 state->regs[regno] = val;
78 return true;
79 }
80
81 static int
bra_compar(const void * key_voidp,const void * elem_voidp)82 bra_compar (const void *key_voidp, const void *elem_voidp)
83 {
84 Dwarf_Word offset = (uintptr_t) key_voidp;
85 const Dwarf_Op *op = elem_voidp;
86 return (offset > op->offset) - (offset < op->offset);
87 }
88
89 struct eval_stack {
90 Dwarf_Addr *addrs;
91 size_t used;
92 size_t allocated;
93 };
94
95 static bool
do_push(struct eval_stack * stack,Dwarf_Addr val)96 do_push (struct eval_stack *stack, Dwarf_Addr val)
97 {
98 if (stack->used >= DWARF_EXPR_STACK_MAX)
99 {
100 __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
101 return false;
102 }
103 if (stack->used == stack->allocated)
104 {
105 stack->allocated = MAX (stack->allocated * 2, 32);
106 Dwarf_Addr *new_addrs;
107 new_addrs = realloc (stack->addrs,
108 stack->allocated * sizeof (*stack->addrs));
109 if (new_addrs == NULL)
110 {
111 __libdwfl_seterrno (DWFL_E_NOMEM);
112 return false;
113 }
114 stack->addrs = new_addrs;
115 }
116 stack->addrs[stack->used++] = val;
117 return true;
118 }
119
120 static bool
do_pop(struct eval_stack * stack,Dwarf_Addr * val)121 do_pop (struct eval_stack *stack, Dwarf_Addr *val)
122 {
123 if (stack->used == 0)
124 {
125 __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
126 return false;
127 }
128 *val = stack->addrs[--stack->used];
129 return true;
130 }
131
132 /* If FRAME is NULL is are computing CFI frame base. In such case another
133 DW_OP_call_frame_cfa is no longer permitted. */
134
135 static bool
expr_eval(Dwfl_Frame * state,Dwarf_Frame * frame,const Dwarf_Op * ops,size_t nops,Dwarf_Addr * result,Dwarf_Addr bias)136 expr_eval (Dwfl_Frame *state, Dwarf_Frame *frame, const Dwarf_Op *ops,
137 size_t nops, Dwarf_Addr *result, Dwarf_Addr bias)
138 {
139 Dwfl_Process *process = state->thread->process;
140 if (nops == 0)
141 {
142 __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
143 return false;
144 }
145 struct eval_stack stack =
146 {
147 .addrs = NULL,
148 .used = 0,
149 .allocated = 0
150 };
151
152 #define pop(x) do_pop(&stack, x)
153 #define push(x) do_push(&stack, x)
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.addrs);
172 return false;
173 }
174 break;
175 case DW_OP_addr:
176 if (! push (op->number + bias))
177 {
178 free (stack.addrs);
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.addrs);
199 return false;
200 }
201 break;
202 case DW_OP_reg0 ... DW_OP_reg31:
203 if (INTUSE (dwfl_frame_reg) (state, op->atom - DW_OP_reg0, &val1) != 0
204 || ! push (val1))
205 {
206 free (stack.addrs);
207 return false;
208 }
209 break;
210 case DW_OP_regx:
211 if (INTUSE (dwfl_frame_reg) (state, op->number, &val1) != 0 || ! push (val1))
212 {
213 free (stack.addrs);
214 return false;
215 }
216 break;
217 case DW_OP_breg0 ... DW_OP_breg31:
218 if (INTUSE (dwfl_frame_reg) (state, op->atom - DW_OP_breg0, &val1) != 0)
219 {
220 free (stack.addrs);
221 return false;
222 }
223 val1 += op->number;
224 if (! push (val1))
225 {
226 free (stack.addrs);
227 return false;
228 }
229 break;
230 case DW_OP_bregx:
231 if (INTUSE (dwfl_frame_reg) (state, op->number, &val1) != 0)
232 {
233 free (stack.addrs);
234 return false;
235 }
236 val1 += op->number2;
237 if (! push (val1))
238 {
239 free (stack.addrs);
240 return false;
241 }
242 break;
243 case DW_OP_dup:
244 if (! pop (&val1) || ! push (val1) || ! push (val1))
245 {
246 free (stack.addrs);
247 return false;
248 }
249 break;
250 case DW_OP_drop:
251 if (! pop (&val1))
252 {
253 free (stack.addrs);
254 return false;
255 }
256 break;
257 case DW_OP_pick:
258 if (stack.used <= op->number)
259 {
260 free (stack.addrs);
261 __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
262 return false;
263 }
264 if (! push (stack.addrs[stack.used - 1 - op->number]))
265 {
266 free (stack.addrs);
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.addrs);
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.addrs);
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.addrs);
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.addrs);
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.addrs);
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.addrs);
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 &= (1ULL << (op->number * 8)) - 1;
329 #endif
330 }
331 if (! push (val1))
332 {
333 free (stack.addrs);
334 return false;
335 }
336 break;
337 #define UNOP(atom, expr) \
338 case atom: \
339 if (! pop (&val1) || ! push (expr)) \
340 { \
341 free (stack.addrs); \
342 return false; \
343 } \
344 break;
345 UNOP (DW_OP_abs, llabs ((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.addrs);
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.addrs); \
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.addrs); \
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.addrs);
378 return false;
379 }
380 if (val2 == 0)
381 {
382 free (stack.addrs);
383 __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
384 return false;
385 }
386 if (! push ((int64_t) val1 / (int64_t) val2))
387 {
388 free (stack.addrs);
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.addrs);
397 return false;
398 }
399 if (val2 == 0)
400 {
401 free (stack.addrs);
402 __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
403 return false;
404 }
405 if (! push (val1 % val2))
406 {
407 free (stack.addrs);
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.addrs);
430 return false;
431 }
432 if (val1 == 0)
433 break;
434 FALLTHROUGH;
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.addrs);
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.addrs);
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.addrs);
480 return false;
481 }
482 free (stack.addrs);
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 #undef push
496 #undef pop
497 }
498
499 static Dwfl_Frame *
new_unwound(Dwfl_Frame * state)500 new_unwound (Dwfl_Frame *state)
501 {
502 assert (state->unwound == NULL);
503 Dwfl_Thread *thread = state->thread;
504 Dwfl_Process *process = thread->process;
505 Ebl *ebl = process->ebl;
506 size_t nregs = ebl_frame_nregs (ebl);
507 assert (nregs > 0);
508 Dwfl_Frame *unwound;
509 unwound = malloc (sizeof (*unwound) + sizeof (*unwound->regs) * nregs);
510 if (unlikely (unwound == NULL))
511 return NULL;
512 state->unwound = unwound;
513 unwound->thread = thread;
514 unwound->unwound = NULL;
515 unwound->signal_frame = false;
516 unwound->initial_frame = false;
517 unwound->pc_state = DWFL_FRAME_STATE_ERROR;
518 memset (unwound->regs_set, 0, sizeof (unwound->regs_set));
519 return unwound;
520 }
521
522 /* The logic is to call __libdwfl_seterrno for any CFI bytecode interpretation
523 error so one can easily catch the problem with a debugger. Still there are
524 archs with invalid CFI for some registers where the registers are never used
525 later. Therefore we continue unwinding leaving the registers undefined. */
526
527 static void
handle_cfi(Dwfl_Frame * state,Dwarf_Addr pc,Dwarf_CFI * cfi,Dwarf_Addr bias)528 handle_cfi (Dwfl_Frame *state, Dwarf_Addr pc, Dwarf_CFI *cfi, Dwarf_Addr bias)
529 {
530 Dwarf_Frame *frame;
531 if (INTUSE(dwarf_cfi_addrframe) (cfi, pc, &frame) != 0)
532 {
533 __libdwfl_seterrno (DWFL_E_LIBDW);
534 return;
535 }
536
537 Dwfl_Frame *unwound = new_unwound (state);
538 if (unwound == NULL)
539 {
540 __libdwfl_seterrno (DWFL_E_NOMEM);
541 return;
542 }
543
544 unwound->signal_frame = frame->fde->cie->signal_frame;
545 Dwfl_Thread *thread = state->thread;
546 Dwfl_Process *process = thread->process;
547 Ebl *ebl = process->ebl;
548 size_t nregs = ebl_frame_nregs (ebl);
549 assert (nregs > 0);
550
551 /* The return register is special for setting the unwound->pc_state. */
552 unsigned ra = frame->fde->cie->return_address_register;
553 bool ra_set = false;
554 if (! ebl_dwarf_to_regno (ebl, &ra))
555 {
556 __libdwfl_seterrno (DWFL_E_INVALID_REGISTER);
557 return;
558 }
559
560 for (unsigned regno = 0; regno < nregs; regno++)
561 {
562 Dwarf_Op reg_ops_mem[3], *reg_ops;
563 size_t reg_nops;
564 if (dwarf_frame_register (frame, regno, reg_ops_mem, ®_ops,
565 ®_nops) != 0)
566 {
567 __libdwfl_seterrno (DWFL_E_LIBDW);
568 continue;
569 }
570 Dwarf_Addr regval;
571 if (reg_nops == 0)
572 {
573 if (reg_ops == reg_ops_mem)
574 {
575 /* REGNO is undefined. */
576 if (regno == ra)
577 unwound->pc_state = DWFL_FRAME_STATE_PC_UNDEFINED;
578 continue;
579 }
580 else if (reg_ops == NULL)
581 {
582 /* REGNO is same-value. */
583 if (INTUSE (dwfl_frame_reg) (state, regno, ®val) != 0)
584 continue;
585 }
586 else
587 {
588 __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
589 continue;
590 }
591 }
592 else if (! expr_eval (state, frame, reg_ops, reg_nops, ®val, bias))
593 {
594 /* PPC32 vDSO has various invalid operations, ignore them. The
595 register will look as unset causing an error later, if used.
596 But PPC32 does not use such registers. */
597 continue;
598 }
599
600 /* Some architectures encode some extra info in the return address. */
601 if (regno == frame->fde->cie->return_address_register)
602 regval &= ebl_func_addr_mask (ebl);
603
604 /* This is another strange PPC[64] case. There are two
605 registers numbers that can represent the same DWARF return
606 register number. We only want one to actually set the return
607 register value. But we always want to override the value if
608 the register is the actual CIE return address register. */
609 if (ra_set && regno != frame->fde->cie->return_address_register)
610 {
611 unsigned r = regno;
612 if (ebl_dwarf_to_regno (ebl, &r) && r == ra)
613 continue;
614 }
615
616 if (! __libdwfl_frame_reg_set (unwound, regno, regval))
617 {
618 __libdwfl_seterrno (DWFL_E_INVALID_REGISTER);
619 continue;
620 }
621 else if (! ra_set)
622 {
623 unsigned r = regno;
624 if (ebl_dwarf_to_regno (ebl, &r) && r == ra)
625 ra_set = true;
626 }
627 }
628 if (unwound->pc_state == DWFL_FRAME_STATE_ERROR)
629 {
630 int res = INTUSE (dwfl_frame_reg) (unwound,
631 frame->fde->cie->return_address_register,
632 &unwound->pc);
633 if (res == 0)
634 {
635 /* PPC32 __libc_start_main properly CFI-unwinds PC as zero.
636 Currently none of the archs supported for unwinding have
637 zero as a valid PC. */
638 if (unwound->pc == 0)
639 unwound->pc_state = DWFL_FRAME_STATE_PC_UNDEFINED;
640 else
641 {
642 unwound->pc_state = DWFL_FRAME_STATE_PC_SET;
643 /* In SPARC the return address register actually contains
644 the address of the call instruction instead of the return
645 address. Therefore we add here an offset defined by the
646 backend. Most likely 0. */
647 unwound->pc += ebl_ra_offset (ebl);
648 }
649 }
650 else
651 {
652 /* We couldn't set the return register, either it was bogus,
653 or the return pc is undefined, maybe end of call stack. */
654 unsigned pcreg = frame->fde->cie->return_address_register;
655 if (! ebl_dwarf_to_regno (ebl, &pcreg)
656 || pcreg >= ebl_frame_nregs (ebl))
657 __libdwfl_seterrno (DWFL_E_INVALID_REGISTER);
658 else
659 unwound->pc_state = DWFL_FRAME_STATE_PC_UNDEFINED;
660 }
661 }
662 free (frame);
663 }
664
665 static bool
setfunc(int firstreg,unsigned nregs,const Dwarf_Word * regs,void * arg)666 setfunc (int firstreg, unsigned nregs, const Dwarf_Word *regs, void *arg)
667 {
668 Dwfl_Frame *state = arg;
669 Dwfl_Frame *unwound = state->unwound;
670 if (firstreg < 0)
671 {
672 assert (firstreg == -1);
673 assert (nregs == 1);
674 assert (unwound->pc_state == DWFL_FRAME_STATE_PC_UNDEFINED);
675 unwound->pc = *regs;
676 unwound->pc_state = DWFL_FRAME_STATE_PC_SET;
677 return true;
678 }
679 while (nregs--)
680 if (! __libdwfl_frame_reg_set (unwound, firstreg++, *regs++))
681 return false;
682 return true;
683 }
684
685 static bool
getfunc(int firstreg,unsigned nregs,Dwarf_Word * regs,void * arg)686 getfunc (int firstreg, unsigned nregs, Dwarf_Word *regs, void *arg)
687 {
688 Dwfl_Frame *state = arg;
689 assert (firstreg >= 0);
690 while (nregs--)
691 if (INTUSE (dwfl_frame_reg) (state, firstreg++, regs++) != 0)
692 return false;
693 return true;
694 }
695
696 static bool
readfunc(Dwarf_Addr addr,Dwarf_Word * datap,void * arg)697 readfunc (Dwarf_Addr addr, Dwarf_Word *datap, void *arg)
698 {
699 Dwfl_Frame *state = arg;
700 Dwfl_Thread *thread = state->thread;
701 Dwfl_Process *process = thread->process;
702 return process->callbacks->memory_read (process->dwfl, addr, datap,
703 process->callbacks_arg);
704 }
705
706 void
707 internal_function
__libdwfl_frame_unwind(Dwfl_Frame * state)708 __libdwfl_frame_unwind (Dwfl_Frame *state)
709 {
710 if (state->unwound)
711 return;
712 /* Do not ask dwfl_frame_pc for ISACTIVATION, it would try to unwind STATE
713 which would deadlock us. */
714 Dwarf_Addr pc;
715 bool ok = INTUSE(dwfl_frame_pc) (state, &pc, NULL);
716 if (!ok)
717 return;
718 /* Check whether this is the initial frame or a signal frame.
719 Then we need to unwind from the original, unadjusted PC. */
720 if (! state->initial_frame && ! state->signal_frame)
721 pc--;
722 Dwfl_Module *mod = INTUSE(dwfl_addrmodule) (state->thread->process->dwfl, pc);
723 if (mod == NULL)
724 __libdwfl_seterrno (DWFL_E_NO_DWARF);
725 else
726 {
727 Dwarf_Addr bias;
728 Dwarf_CFI *cfi_eh = INTUSE(dwfl_module_eh_cfi) (mod, &bias);
729 if (cfi_eh)
730 {
731 handle_cfi (state, pc - bias, cfi_eh, bias);
732 if (state->unwound)
733 return;
734 }
735 Dwarf_CFI *cfi_dwarf = INTUSE(dwfl_module_dwarf_cfi) (mod, &bias);
736 if (cfi_dwarf)
737 {
738 handle_cfi (state, pc - bias, cfi_dwarf, bias);
739 if (state->unwound)
740 return;
741 }
742 }
743 assert (state->unwound == NULL);
744 Dwfl_Thread *thread = state->thread;
745 Dwfl_Process *process = thread->process;
746 Ebl *ebl = process->ebl;
747 if (new_unwound (state) == NULL)
748 {
749 __libdwfl_seterrno (DWFL_E_NOMEM);
750 return;
751 }
752 state->unwound->pc_state = DWFL_FRAME_STATE_PC_UNDEFINED;
753 // &Dwfl_Frame.signal_frame cannot be passed as it is a bitfield.
754 bool signal_frame = false;
755 if (! ebl_unwind (ebl, pc, setfunc, getfunc, readfunc, state, &signal_frame))
756 {
757 // Discard the unwind attempt. During next __libdwfl_frame_unwind call
758 // we may have for example the appropriate Dwfl_Module already mapped.
759 assert (state->unwound->unwound == NULL);
760 free (state->unwound);
761 state->unwound = NULL;
762 // __libdwfl_seterrno has been called above.
763 return;
764 }
765 assert (state->unwound->pc_state == DWFL_FRAME_STATE_PC_SET);
766 state->unwound->signal_frame = signal_frame;
767 }
768