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
50bool
51internal_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       & ((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
67bool
68internal_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		((uint64_t) 1U << (regno % (sizeof (*state->regs_set) * 8)));
81  state->regs[regno] = val;
82  return true;
83}
84
85static bool
86state_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
96static int
97bra_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
104struct eval_stack {
105  Dwarf_Addr *addrs;
106  size_t used;
107  size_t allocated;
108};
109
110static bool
111do_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
135static bool
136do_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
150static bool
151expr_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
514static void
515new_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
539static void
540handle_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, &reg_ops,
567				&reg_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, &regval))
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, &regval, 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
652static bool
653setfunc (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
672static bool
673getfunc (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
683static bool
684readfunc (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
693void
694internal_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