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.
5 This file is free software; you can redistribute it and/or modify
6 it under the terms of either
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
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
18 or both in parallel, as here.
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.
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/>. */
36 #include "../libdw/dwarf.h"
37 #include <sys/ptrace.h>
39 /* Maximum number of DWARF expression stack slots before returning an error. */
40 #define DWARF_EXPR_STACK_MAX 0x100
42 /* Maximum number of DWARF expression executed operations before returning an
44 #define DWARF_EXPR_STEPS_MAX 0x1000
47 # define MAX(a, b) ((a) > (b) ? (a) : (b))
52 __libdwfl_frame_reg_get (Dwfl_Frame *state, unsigned regno, Dwarf_Addr *val)
54 Ebl *ebl = state->thread->process->ebl;
55 if (! ebl_dwarf_to_regno (ebl, ®no))
57 if (regno >= ebl_frame_nregs (ebl))
59 if ((state->regs_set[regno / sizeof (*state->regs_set) / 8]
60 & ((uint64_t) 1U << (regno % (sizeof (*state->regs_set) * 8)))) == 0)
63 *val = state->regs[regno];
69 __libdwfl_frame_reg_set (Dwfl_Frame *state, unsigned regno, Dwarf_Addr val)
71 Ebl *ebl = state->thread->process->ebl;
72 if (! ebl_dwarf_to_regno (ebl, ®no))
74 if (regno >= ebl_frame_nregs (ebl))
76 /* For example i386 user_regs_struct has signed fields. */
77 if (ebl_get_elfclass (ebl) == ELFCLASS32)
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;
86 state_get_reg (Dwfl_Frame *state, unsigned regno, Dwarf_Addr *val)
88 if (! __libdwfl_frame_reg_get (state, regno, val))
90 __libdwfl_seterrno (DWFL_E_INVALID_REGISTER);
97 bra_compar (const void *key_voidp, const void *elem_voidp)
99 Dwarf_Word offset = (uintptr_t) key_voidp;
100 const Dwarf_Op *op = elem_voidp;
101 return (offset > op->offset) - (offset < op->offset);
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. */
108 expr_eval (Dwfl_Frame *state, Dwarf_Frame *frame, const Dwarf_Op *ops,
109 size_t nops, Dwarf_Addr *result, Dwarf_Addr bias)
111 Dwfl_Process *process = state->thread->process;
114 __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
117 Dwarf_Addr *stack = NULL;
118 size_t stack_used = 0, stack_allocated = 0;
121 push (Dwarf_Addr val)
123 if (stack_used >= DWARF_EXPR_STACK_MAX)
125 __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
128 if (stack_used == stack_allocated)
130 stack_allocated = MAX (stack_allocated * 2, 32);
131 Dwarf_Addr *stack_new = realloc (stack, stack_allocated * sizeof (*stack));
132 if (stack_new == NULL)
134 __libdwfl_seterrno (DWFL_E_NOMEM);
139 stack[stack_used++] = val;
144 pop (Dwarf_Addr *val)
148 __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
151 *val = stack[--stack_used];
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++)
160 if (++steps_count > DWARF_EXPR_STEPS_MAX)
162 __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
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))
176 if (! push (op->number + bias))
182 case DW_OP_GNU_encoded_addr:
183 /* Missing support in the rest of elfutils. */
184 __libdwfl_seterrno (DWFL_E_UNSUPPORTED_DWARF);
196 if (! push (op->number))
202 case DW_OP_reg0 ... DW_OP_reg31:
203 if (! state_get_reg (state, op->atom - DW_OP_reg0, &val1)
211 if (! state_get_reg (state, op->number, &val1) || ! push (val1))
217 case DW_OP_breg0 ... DW_OP_breg31:
218 if (! state_get_reg (state, op->atom - DW_OP_breg0, &val1))
231 if (! state_get_reg (state, op->number, &val1))
244 if (! pop (&val1) || ! push (val1) || ! push (val1))
258 if (stack_used <= op->number)
261 __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
264 if (! push (stack[stack_used - 1 - op->number]))
271 if (! pop (&val1) || ! pop (&val2)
272 || ! push (val2) || ! push (val1) || ! push (val2))
279 if (! pop (&val1) || ! pop (&val2) || ! push (val1) || ! push (val2))
288 if (! pop (&val1) || ! pop (&val2) || ! pop (&val3)
289 || ! push (val1) || ! push (val3) || ! push (val2))
297 case DW_OP_deref_size:
298 if (process->callbacks->memory_read == NULL)
301 __libdwfl_seterrno (DWFL_E_INVALID_ARGUMENT);
305 || ! process->callbacks->memory_read (process->dwfl, val1, &val1,
306 process->callbacks_arg))
311 if (op->atom == DW_OP_deref_size)
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)
318 __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
321 #if BYTE_ORDER == BIG_ENDIAN
325 val1 >>= (addr_bytes - op->number) * 8;
328 val1 &= (1 << (op->number * 8)) - 1;
337 #define UNOP(atom, expr) \
339 if (! pop (&val1) || ! push (expr)) \
345 UNOP (DW_OP_abs, llabs ((int64_t) val1))
346 UNOP (DW_OP_neg, -(int64_t) val1)
347 UNOP (DW_OP_not, ~val1)
349 case DW_OP_plus_uconst:
350 if (! pop (&val1) || ! push (val1 + op->number))
356 #define BINOP(atom, op) \
358 if (! pop (&val2) || ! pop (&val1) || ! push (val1 op val2)) \
364 #define BINOP_SIGNED(atom, op) \
366 if (! pop (&val2) || ! pop (&val1) \
367 || ! push ((int64_t) val1 op (int64_t) val2)) \
375 if (! pop (&val2) || ! pop (&val1))
383 __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
386 if (! push ((int64_t) val1 / (int64_t) val2))
392 BINOP (DW_OP_minus, -)
394 if (! pop (&val2) || ! pop (&val1))
402 __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
405 if (! push (val1 % val2))
413 BINOP (DW_OP_plus, +)
414 BINOP (DW_OP_shl, <<)
415 BINOP (DW_OP_shr, >>)
416 BINOP_SIGNED (DW_OP_shra, >>)
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, !=)
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);
442 /* PPC32 vDSO has such invalid operations. */
443 __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
446 /* Undo the 'for' statement increment. */
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.
458 || dwarf_frame_cfa (frame, &cfa_ops, &cfa_nops) != 0
459 || ! expr_eval (state, NULL, cfa_ops, cfa_nops, &cfa, bias)
462 __libdwfl_seterrno (DWFL_E_LIBDW);
468 case DW_OP_stack_value:
469 // Not used by CFI itself but it is synthetized by elfutils internation.
473 __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
485 if (process->callbacks->memory_read == NULL)
487 __libdwfl_seterrno (DWFL_E_INVALID_ARGUMENT);
490 if (! process->callbacks->memory_read (process->dwfl, *result, result,
491 process->callbacks_arg))
498 new_unwound (Dwfl_Frame *state)
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);
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));
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. */
523 handle_cfi (Dwfl_Frame *state, Dwarf_Addr pc, Dwarf_CFI *cfi, Dwarf_Addr bias)
526 if (INTUSE(dwarf_cfi_addrframe) (cfi, pc, &frame) != 0)
528 __libdwfl_seterrno (DWFL_E_LIBDW);
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);
540 /* The return register is special for setting the unwound->pc_state. */
541 unsigned ra = frame->fde->cie->return_address_register;
543 ebl_dwarf_to_regno (ebl, &ra);
545 for (unsigned regno = 0; regno < nregs; regno++)
547 Dwarf_Op reg_ops_mem[3], *reg_ops;
549 if (dwarf_frame_register (frame, regno, reg_ops_mem, ®_ops,
552 __libdwfl_seterrno (DWFL_E_LIBDW);
558 if (reg_ops == reg_ops_mem)
560 /* REGNO is undefined. */
562 unwound->pc_state = DWFL_FRAME_STATE_PC_UNDEFINED;
565 else if (reg_ops == NULL)
567 /* REGNO is same-value. */
568 if (! state_get_reg (state, regno, ®val))
573 __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
577 else if (! expr_eval (state, frame, reg_ops, reg_nops, ®val, bias))
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. */
585 /* Some architectures encode some extra info in the return address. */
586 if (regno == frame->fde->cie->return_address_register)
587 regval &= ebl_func_addr_mask (ebl);
589 /* This is another strange PPC[64] case. There are two
590 registers numbers that can represent the same DWARF return
591 register number. We only want one to actually set the return
592 register value. But we always want to override the value if
593 the register is the actual CIE return address register. */
594 if (ra_set && regno != frame->fde->cie->return_address_register)
597 if (ebl_dwarf_to_regno (ebl, &r) && r == ra)
601 if (! __libdwfl_frame_reg_set (unwound, regno, regval))
603 __libdwfl_seterrno (DWFL_E_INVALID_REGISTER);
609 if (ebl_dwarf_to_regno (ebl, &r) && r == ra)
613 if (unwound->pc_state == DWFL_FRAME_STATE_ERROR
614 && __libdwfl_frame_reg_get (unwound,
615 frame->fde->cie->return_address_register,
618 /* PPC32 __libc_start_main properly CFI-unwinds PC as zero. Currently
619 none of the archs supported for unwinding have zero as a valid PC. */
620 if (unwound->pc == 0)
621 unwound->pc_state = DWFL_FRAME_STATE_PC_UNDEFINED;
623 unwound->pc_state = DWFL_FRAME_STATE_PC_SET;
629 setfunc (int firstreg, unsigned nregs, const Dwarf_Word *regs, void *arg)
631 Dwfl_Frame *state = arg;
632 Dwfl_Frame *unwound = state->unwound;
635 assert (firstreg == -1);
637 assert (unwound->pc_state == DWFL_FRAME_STATE_PC_UNDEFINED);
639 unwound->pc_state = DWFL_FRAME_STATE_PC_SET;
643 if (! __libdwfl_frame_reg_set (unwound, firstreg++, *regs++))
649 getfunc (int firstreg, unsigned nregs, Dwarf_Word *regs, void *arg)
651 Dwfl_Frame *state = arg;
652 assert (firstreg >= 0);
654 if (! __libdwfl_frame_reg_get (state, firstreg++, regs++))
660 readfunc (Dwarf_Addr addr, Dwarf_Word *datap, void *arg)
662 Dwfl_Frame *state = arg;
663 Dwfl_Thread *thread = state->thread;
664 Dwfl_Process *process = thread->process;
665 return process->callbacks->memory_read (process->dwfl, addr, datap,
666 process->callbacks_arg);
671 __libdwfl_frame_unwind (Dwfl_Frame *state)
675 /* Do not ask dwfl_frame_pc for ISACTIVATION, it would try to unwind STATE
676 which would deadlock us. */
678 bool ok = INTUSE(dwfl_frame_pc) (state, &pc, NULL);
680 /* Check whether this is the initial frame or a signal frame.
681 Then we need to unwind from the original, unadjusted PC. */
682 if (! state->initial_frame && ! state->signal_frame)
684 Dwfl_Module *mod = INTUSE(dwfl_addrmodule) (state->thread->process->dwfl, pc);
686 __libdwfl_seterrno (DWFL_E_NO_DWARF);
690 Dwarf_CFI *cfi_eh = INTUSE(dwfl_module_eh_cfi) (mod, &bias);
693 handle_cfi (state, pc - bias, cfi_eh, bias);
697 Dwarf_CFI *cfi_dwarf = INTUSE(dwfl_module_dwarf_cfi) (mod, &bias);
700 handle_cfi (state, pc - bias, cfi_dwarf, bias);
705 assert (state->unwound == NULL);
706 Dwfl_Thread *thread = state->thread;
707 Dwfl_Process *process = thread->process;
708 Ebl *ebl = process->ebl;
710 state->unwound->pc_state = DWFL_FRAME_STATE_PC_UNDEFINED;
711 // &Dwfl_Frame.signal_frame cannot be passed as it is a bitfield.
712 bool signal_frame = false;
713 if (! ebl_unwind (ebl, pc, setfunc, getfunc, readfunc, state, &signal_frame))
715 // Discard the unwind attempt. During next __libdwfl_frame_unwind call
716 // we may have for example the appropriate Dwfl_Module already mapped.
717 assert (state->unwound->unwound == NULL);
718 free (state->unwound);
719 state->unwound = NULL;
720 // __libdwfl_seterrno has been called above.
723 assert (state->unwound->pc_state == DWFL_FRAME_STATE_PC_SET);
724 state->unwound->signal_frame = signal_frame;