m2-internship/libunwind-eh_elf
1
0
Fork 0
mirror of https://github.com/tobast/libunwind-eh_elf.git synced 2024-11-14 04:18:11 +01:00
Code Issues Releases Activity

Leave ret_addr_column out of the data that gets copied when pushing/popping

Browse source 
data on/off the register state stack.
This commit is contained in:
Doug Moore 2017-05-20 14:36:25 -05:00
parent c66661f73c
commit 27f5f9fa0b
6 changed files with 125 additions and 117 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
include/dwarf.h
View file

@ -249,18 +249,24 @@ dwarf_where_t;
#define DWARF_CFA_REG_COLUMN DWARF_NUM_PRESERVED_REGS
#define DWARF_CFA_OFF_COLUMN (DWARF_NUM_PRESERVED_REGS + 1)
typedef struct dwarf_reg_only_state
{
char where[DWARF_NUM_PRESERVED_REGS + 2]; /* how is the register saved? */
unw_word_t val[DWARF_NUM_PRESERVED_REGS + 2]; /* where it's saved */
}
dwarf_reg_only_state_t;
typedef struct dwarf_reg_state
{
unw_word_t ret_addr_column; /* which column in rule table represents return address */
char where[DWARF_NUM_PRESERVED_REGS + 2]; /* how is the register saved? */
unw_word_t val[DWARF_NUM_PRESERVED_REGS + 2]; /* where it's saved */
dwarf_reg_only_state_t reg;
}
dwarf_reg_state_t;
typedef struct dwarf_stackable_reg_state
{
struct dwarf_stackable_reg_state *next; /* for rs_stack */
dwarf_reg_state_t state;
dwarf_reg_only_state_t state;
}
dwarf_stackable_reg_state_t;

66
src/aarch64/Gstash_frame.c
View file

@ -36,13 +36,13 @@ tdep_stash_frame (struct dwarf_cursor *d, struct dwarf_reg_state *rs)
" ra=0x%lx fp [where=%d val=%ld @0x%lx] lr [where=%d val=%ld @0x%lx] "
"sp [where=%d val=%ld @0x%lx]\n",
d->ip, d->cfa, f->frame_type,
rs->where[DWARF_CFA_REG_COLUMN],
rs->val[DWARF_CFA_REG_COLUMN],
rs->val[DWARF_CFA_OFF_COLUMN],
rs->reg.where[DWARF_CFA_REG_COLUMN],
rs->reg.val[DWARF_CFA_REG_COLUMN],
rs->reg.val[DWARF_CFA_OFF_COLUMN],
DWARF_GET_LOC(d->loc[rs->ret_addr_column]),
rs->where[FP], rs->val[FP], DWARF_GET_LOC(d->loc[FP]),
rs->where[LR], rs->val[LR], DWARF_GET_LOC(d->loc[LR]),
rs->where[SP], rs->val[SP], DWARF_GET_LOC(d->loc[SP]));
rs->reg.where[FP], rs->reg.val[FP], DWARF_GET_LOC(d->loc[FP]),
rs->reg.where[LR], rs->reg.val[LR], DWARF_GET_LOC(d->loc[LR]),
rs->reg.where[SP], rs->reg.val[SP], DWARF_GET_LOC(d->loc[SP]));
/* A standard frame is defined as:
- CFA is register-relative offset off FP or SP;
@ -51,37 +51,37 @@ tdep_stash_frame (struct dwarf_cursor *d, struct dwarf_reg_state *rs)
- LR is unsaved or saved at CFA+offset, offset != -1;
- SP is unsaved or saved at CFA+offset, offset != -1. */
if (f->frame_type == UNW_AARCH64_FRAME_OTHER
&& (rs->where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_REG)
&& (rs->val[DWARF_CFA_REG_COLUMN] == FP
|| rs->val[DWARF_CFA_REG_COLUMN] == SP)
&& labs(rs->val[DWARF_CFA_OFF_COLUMN]) < (1 << 29)
&& (rs->reg.where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_REG)
&& (rs->reg.val[DWARF_CFA_REG_COLUMN] == FP
|| rs->reg.val[DWARF_CFA_REG_COLUMN] == SP)
&& labs(rs->reg.val[DWARF_CFA_OFF_COLUMN]) < (1 << 29)
&& rs->ret_addr_column == LR
&& (rs->where[FP] == DWARF_WHERE_UNDEF
|| rs->where[FP] == DWARF_WHERE_SAME
|| (rs->where[FP] == DWARF_WHERE_CFAREL
&& labs(rs->val[FP]) < (1 << 29)
&& rs->val[FP]+1 != 0))
&& (rs->where[LR] == DWARF_WHERE_UNDEF
|| rs->where[LR] == DWARF_WHERE_SAME
|| (rs->where[LR] == DWARF_WHERE_CFAREL
&& labs(rs->val[LR]) < (1 << 29)
&& rs->val[LR]+1 != 0))
&& (rs->where[SP] == DWARF_WHERE_UNDEF
|| rs->where[SP] == DWARF_WHERE_SAME
|| (rs->where[SP] == DWARF_WHERE_CFAREL
&& labs(rs->val[SP]) < (1 << 29)
&& rs->val[SP]+1 != 0)))
&& (rs->reg.where[FP] == DWARF_WHERE_UNDEF
|| rs->reg.where[FP] == DWARF_WHERE_SAME
|| (rs->reg.where[FP] == DWARF_WHERE_CFAREL
&& labs(rs->reg.val[FP]) < (1 << 29)
&& rs->reg.val[FP]+1 != 0))
&& (rs->reg.where[LR] == DWARF_WHERE_UNDEF
|| rs->reg.where[LR] == DWARF_WHERE_SAME
|| (rs->reg.where[LR] == DWARF_WHERE_CFAREL
&& labs(rs->reg.val[LR]) < (1 << 29)
&& rs->reg.val[LR]+1 != 0))
&& (rs->reg.where[SP] == DWARF_WHERE_UNDEF
|| rs->reg.where[SP] == DWARF_WHERE_SAME
|| (rs->reg.where[SP] == DWARF_WHERE_CFAREL
&& labs(rs->reg.val[SP]) < (1 << 29)
&& rs->reg.val[SP]+1 != 0)))
{
/* Save information for a standard frame. */
f->frame_type = UNW_AARCH64_FRAME_STANDARD;
f->cfa_reg_sp = (rs->val[DWARF_CFA_REG_COLUMN] == SP);
f->cfa_reg_offset = rs->val[DWARF_CFA_OFF_COLUMN];
if (rs->where[FP] == DWARF_WHERE_CFAREL)
f->fp_cfa_offset = rs->val[FP];
if (rs->where[LR] == DWARF_WHERE_CFAREL)
f->lr_cfa_offset = rs->val[LR];
if (rs->where[SP] == DWARF_WHERE_CFAREL)
f->sp_cfa_offset = rs->val[SP];
f->cfa_reg_sp = (rs->reg.val[DWARF_CFA_REG_COLUMN] == SP);
f->cfa_reg_offset = rs->reg.val[DWARF_CFA_OFF_COLUMN];
if (rs->reg.where[FP] == DWARF_WHERE_CFAREL)
f->fp_cfa_offset = rs->reg.val[FP];
if (rs->reg.where[LR] == DWARF_WHERE_CFAREL)
f->lr_cfa_offset = rs->reg.val[LR];
if (rs->reg.where[SP] == DWARF_WHERE_CFAREL)
f->sp_cfa_offset = rs->reg.val[SP];
Debug (4, " standard frame\n");
}
else

66
src/arm/Gstash_frame.c
View file

@ -36,13 +36,13 @@ tdep_stash_frame (struct dwarf_cursor *d, struct dwarf_reg_state *rs)
" ra=0x%x r7 [where=%d val=%d @0x%x] lr [where=%d val=%d @0x%x] "
"sp [where=%d val=%d @0x%x]\n",
d->ip, d->cfa, f->frame_type,
rs->where[DWARF_CFA_REG_COLUMN],
rs->val[DWARF_CFA_REG_COLUMN],
rs->val[DWARF_CFA_OFF_COLUMN],
rs->reg.where[DWARF_CFA_REG_COLUMN],
rs->reg.val[DWARF_CFA_REG_COLUMN],
rs->reg.val[DWARF_CFA_OFF_COLUMN],
DWARF_GET_LOC(d->loc[rs->ret_addr_column]),
rs->where[R7], rs->val[R7], DWARF_GET_LOC(d->loc[R7]),
rs->where[LR], rs->val[LR], DWARF_GET_LOC(d->loc[LR]),
rs->where[SP], rs->val[SP], DWARF_GET_LOC(d->loc[SP]));
rs->reg.where[R7], rs->reg.val[R7], DWARF_GET_LOC(d->loc[R7]),
rs->reg.where[LR], rs->reg.val[LR], DWARF_GET_LOC(d->loc[LR]),
rs->reg.where[SP], rs->reg.val[SP], DWARF_GET_LOC(d->loc[SP]));
/* A standard frame is defined as:
- CFA is register-relative offset off R7 or SP;
@ -51,37 +51,37 @@ tdep_stash_frame (struct dwarf_cursor *d, struct dwarf_reg_state *rs)
- LR is unsaved or saved at CFA+offset, offset != -1;
- SP is unsaved or saved at CFA+offset, offset != -1. */
if (f->frame_type == UNW_ARM_FRAME_OTHER
&& (rs->where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_REG)
&& (rs->val[DWARF_CFA_REG_COLUMN] == R7
|| rs->val[DWARF_CFA_REG_COLUMN] == SP)
&& labs(rs->val[DWARF_CFA_OFF_COLUMN]) < (1 << 29)
&& (rs->reg.where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_REG)
&& (rs->reg.val[DWARF_CFA_REG_COLUMN] == R7
|| rs->reg.val[DWARF_CFA_REG_COLUMN] == SP)
&& labs(rs->reg.val[DWARF_CFA_OFF_COLUMN]) < (1 << 29)
&& rs->ret_addr_column == LR
&& (rs->where[R7] == DWARF_WHERE_UNDEF
|| rs->where[R7] == DWARF_WHERE_SAME
|| (rs->where[R7] == DWARF_WHERE_CFAREL
&& labs(rs->val[R7]) < (1 << 29)
&& rs->val[R7]+1 != 0))
&& (rs->where[LR] == DWARF_WHERE_UNDEF
|| rs->where[LR] == DWARF_WHERE_SAME
|| (rs->where[LR] == DWARF_WHERE_CFAREL
&& labs(rs->val[LR]) < (1 << 29)
&& rs->val[LR]+1 != 0))
&& (rs->where[SP] == DWARF_WHERE_UNDEF
|| rs->where[SP] == DWARF_WHERE_SAME
|| (rs->where[SP] == DWARF_WHERE_CFAREL
&& labs(rs->val[SP]) < (1 << 29)
&& rs->val[SP]+1 != 0)))
&& (rs->reg.where[R7] == DWARF_WHERE_UNDEF
|| rs->reg.where[R7] == DWARF_WHERE_SAME
|| (rs->reg.where[R7] == DWARF_WHERE_CFAREL
&& labs(rs->reg.val[R7]) < (1 << 29)
&& rs->reg.val[R7]+1 != 0))
&& (rs->reg.where[LR] == DWARF_WHERE_UNDEF
|| rs->reg.where[LR] == DWARF_WHERE_SAME
|| (rs->reg.where[LR] == DWARF_WHERE_CFAREL
&& labs(rs->reg.val[LR]) < (1 << 29)
&& rs->reg.val[LR]+1 != 0))
&& (rs->reg.where[SP] == DWARF_WHERE_UNDEF
|| rs->reg.where[SP] == DWARF_WHERE_SAME
|| (rs->reg.where[SP] == DWARF_WHERE_CFAREL
&& labs(rs->reg.val[SP]) < (1 << 29)
&& rs->reg.val[SP]+1 != 0)))
{
/* Save information for a standard frame. */
f->frame_type = UNW_ARM_FRAME_STANDARD;
f->cfa_reg_sp = (rs->val[DWARF_CFA_REG_COLUMN] == SP);
f->cfa_reg_offset = rs->val[DWARF_CFA_OFF_COLUMN];
if (rs->where[R7] == DWARF_WHERE_CFAREL)
f->r7_cfa_offset = rs->val[R7];
if (rs->where[LR] == DWARF_WHERE_CFAREL)
f->lr_cfa_offset = rs->val[LR];
if (rs->where[SP] == DWARF_WHERE_CFAREL)
f->sp_cfa_offset = rs->val[SP];
f->cfa_reg_sp = (rs->reg.val[DWARF_CFA_REG_COLUMN] == SP);
f->cfa_reg_offset = rs->reg.val[DWARF_CFA_OFF_COLUMN];
if (rs->reg.where[R7] == DWARF_WHERE_CFAREL)
f->r7_cfa_offset = rs->reg.val[R7];
if (rs->reg.where[LR] == DWARF_WHERE_CFAREL)
f->lr_cfa_offset = rs->reg.val[LR];
if (rs->reg.where[SP] == DWARF_WHERE_CFAREL)
f->sp_cfa_offset = rs->reg.val[SP];
Debug (4, " standard frame\n");
}
else

38
src/dwarf/Gparser.c
View file

@ -55,8 +55,8 @@ static inline void
set_reg (dwarf_state_record_t *sr, unw_word_t regnum, dwarf_where_t where,
unw_word_t val)
{
sr->rs_current.where[regnum] = where;
sr->rs_current.val[regnum] = val;
sr->rs_current.reg.where[regnum] = where;
sr->rs_current.reg.val[regnum] = val;
}
static inline int
@ -218,8 +218,8 @@ run_cfi_program (struct dwarf_cursor *c, dwarf_state_record_t *sr,
ret = -UNW_EINVAL;
break;
}
sr->rs_current.where[regnum] = sr->rs_initial.where[regnum];
sr->rs_current.val[regnum] = sr->rs_initial.val[regnum];
sr->rs_current.reg.where[regnum] = sr->rs_initial.reg.where[regnum];
sr->rs_current.reg.val[regnum] = sr->rs_initial.reg.val[regnum];
Debug (15, "CFA_restore r%lu\n", (long) regnum);
break;
@ -233,8 +233,8 @@ run_cfi_program (struct dwarf_cursor *c, dwarf_state_record_t *sr,
ret = -UNW_EINVAL;
break;
}
sr->rs_current.where[regnum] = sr->rs_initial.where[regnum];
sr->rs_current.val[regnum] = sr->rs_initial.val[regnum];
sr->rs_current.reg.where[regnum] = sr->rs_initial.reg.where[regnum];
sr->rs_current.reg.val[regnum] = sr->rs_initial.reg.val[regnum];
Debug (15, "CFA_restore_extended r%lu\n", (long) regnum);
break;
@ -785,32 +785,32 @@ apply_reg_state (struct dwarf_cursor *c, struct dwarf_reg_state *rs)
/* Evaluate the CFA first, because it may be referred to by other
expressions. */
if (rs->where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_REG)
if (rs->reg.where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_REG)
{
/* CFA is equal to [reg] + offset: */
/* As a special-case, if the stack-pointer is the CFA and the
stack-pointer wasn't saved, popping the CFA implicitly pops
the stack-pointer as well. */
if ((rs->val[DWARF_CFA_REG_COLUMN] == UNW_TDEP_SP)
&& (UNW_TDEP_SP < ARRAY_SIZE(rs->val))
&& (rs->where[UNW_TDEP_SP] == DWARF_WHERE_SAME))
if ((rs->reg.val[DWARF_CFA_REG_COLUMN] == UNW_TDEP_SP)
&& (UNW_TDEP_SP < ARRAY_SIZE(rs->reg.val))
&& (rs->reg.where[UNW_TDEP_SP] == DWARF_WHERE_SAME))
cfa = c->cfa;
else
{
regnum = dwarf_to_unw_regnum (rs->val[DWARF_CFA_REG_COLUMN]);
regnum = dwarf_to_unw_regnum (rs->reg.val[DWARF_CFA_REG_COLUMN]);
if ((ret = unw_get_reg ((unw_cursor_t *) c, regnum, &cfa)) < 0)
return ret;
}
cfa += rs->val[DWARF_CFA_OFF_COLUMN];
cfa += rs->reg.val[DWARF_CFA_OFF_COLUMN];
}
else
{
/* CFA is equal to EXPR: */
assert (rs->where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_EXPR);
assert (rs->reg.where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_EXPR);
addr = rs->val[DWARF_CFA_REG_COLUMN];
addr = rs->reg.val[DWARF_CFA_REG_COLUMN];
if ((ret = eval_location_expr (c, as, a, addr, &cfa_loc, arg)) < 0)
return ret;
/* the returned location better be a memory location... */
@ -821,7 +821,7 @@ apply_reg_state (struct dwarf_cursor *c, struct dwarf_reg_state *rs)
for (i = 0; i < DWARF_NUM_PRESERVED_REGS; ++i)
{
switch ((dwarf_where_t) rs->where[i])
switch ((dwarf_where_t) rs->reg.where[i])
{
case DWARF_WHERE_UNDEF:
c->loc[i] = DWARF_NULL_LOC;
@ -831,21 +831,21 @@ apply_reg_state (struct dwarf_cursor *c, struct dwarf_reg_state *rs)
break;
case DWARF_WHERE_CFAREL:
c->loc[i] = DWARF_MEM_LOC (c, cfa + rs->val[i]);
c->loc[i] = DWARF_MEM_LOC (c, cfa + rs->reg.val[i]);
break;
case DWARF_WHERE_REG:
c->loc[i] = DWARF_REG_LOC (c, dwarf_to_unw_regnum (rs->val[i]));
c->loc[i] = DWARF_REG_LOC (c, dwarf_to_unw_regnum (rs->reg.val[i]));
break;
case DWARF_WHERE_EXPR:
addr = rs->val[i];
addr = rs->reg.val[i];
if ((ret = eval_location_expr (c, as, a, addr, c->loc + i, arg)) < 0)
return ret;
break;
case DWARF_WHERE_VAL_EXPR:
addr = rs->val[i];
addr = rs->reg.val[i];
if ((ret = eval_location_expr (c, as, a, addr, c->loc + i, arg)) < 0)
return ret;
c->loc[i] = DWARF_VAL_LOC (c, DWARF_GET_LOC (c->loc[i]));

58
src/x86_64/Gstash_frame.c
View file

@ -34,20 +34,20 @@ tdep_stash_frame (struct dwarf_cursor *d, struct dwarf_reg_state *rs)
Debug (4, "ip=0x%lx cfa=0x%lx type %d cfa [where=%d val=%ld] cfaoff=%ld"
" ra=0x%lx rbp [where=%d val=%ld @0x%lx] rsp [where=%d val=%ld @0x%lx]\n",
d->ip, d->cfa, f->frame_type,
rs->where[DWARF_CFA_REG_COLUMN],
rs->val[DWARF_CFA_REG_COLUMN],
rs->val[DWARF_CFA_OFF_COLUMN],
rs->reg.where[DWARF_CFA_REG_COLUMN],
rs->reg.val[DWARF_CFA_REG_COLUMN],
rs->reg.val[DWARF_CFA_OFF_COLUMN],
DWARF_GET_LOC(d->loc[rs->ret_addr_column]),
rs->where[RBP], rs->val[RBP], DWARF_GET_LOC(d->loc[RBP]),
rs->where[RSP], rs->val[RSP], DWARF_GET_LOC(d->loc[RSP]));
rs->reg.where[RBP], rs->reg.val[RBP], DWARF_GET_LOC(d->loc[RBP]),
rs->reg.where[RSP], rs->reg.val[RSP], DWARF_GET_LOC(d->loc[RSP]));
if (rs->where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_EXPR &&
rs->where[RBP] == DWARF_WHERE_EXPR) {
if (rs->reg.where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_EXPR &&
rs->reg.where[RBP] == DWARF_WHERE_EXPR) {
/* Check for GCC generated alignment frame for rsp. A simple
* def_cfa_expr that loads a constant offset from rbp, where the
* addres of the rip was pushed on the stack */
unw_word_t cfa_addr = rs->val[DWARF_CFA_REG_COLUMN];
unw_word_t rbp_addr = rs->val[RBP];
unw_word_t cfa_addr = rs->reg.val[DWARF_CFA_REG_COLUMN];
unw_word_t rbp_addr = rs->reg.val[RBP];
unw_word_t cfa_offset;
int ret = dwarf_stack_aligned(d, cfa_addr, rbp_addr, &cfa_offset);
@ -64,30 +64,30 @@ tdep_stash_frame (struct dwarf_cursor *d, struct dwarf_reg_state *rs)
- RBP is unsaved or saved at CFA+offset, offset != -1;
- RSP is unsaved or saved at CFA+offset, offset != -1. */
if (f->frame_type == UNW_X86_64_FRAME_OTHER
&& (rs->where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_REG)
&& (rs->val[DWARF_CFA_REG_COLUMN] == RBP
|| rs->val[DWARF_CFA_REG_COLUMN] == RSP)
&& labs((long) rs->val[DWARF_CFA_OFF_COLUMN]) < (1 << 28)
&& (rs->reg.where[DWARF_CFA_REG_COLUMN] == DWARF_WHERE_REG)
&& (rs->reg.val[DWARF_CFA_REG_COLUMN] == RBP
|| rs->reg.val[DWARF_CFA_REG_COLUMN] == RSP)
&& labs((long) rs->reg.val[DWARF_CFA_OFF_COLUMN]) < (1 << 28)
&& DWARF_GET_LOC(d->loc[rs->ret_addr_column]) == d->cfa-8
&& (rs->where[RBP] == DWARF_WHERE_UNDEF
|| rs->where[RBP] == DWARF_WHERE_SAME
|| (rs->where[RBP] == DWARF_WHERE_CFAREL
&& labs((long) rs->val[RBP]) < (1 << 14)
&& rs->val[RBP]+1 != 0))
&& (rs->where[RSP] == DWARF_WHERE_UNDEF
|| rs->where[RSP] == DWARF_WHERE_SAME
|| (rs->where[RSP] == DWARF_WHERE_CFAREL
&& labs((long) rs->val[RSP]) < (1 << 14)
&& rs->val[RSP]+1 != 0)))
&& (rs->reg.where[RBP] == DWARF_WHERE_UNDEF
|| rs->reg.where[RBP] == DWARF_WHERE_SAME
|| (rs->reg.where[RBP] == DWARF_WHERE_CFAREL
&& labs((long) rs->reg.val[RBP]) < (1 << 14)
&& rs->reg.val[RBP]+1 != 0))
&& (rs->reg.where[RSP] == DWARF_WHERE_UNDEF
|| rs->reg.where[RSP] == DWARF_WHERE_SAME
|| (rs->reg.where[RSP] == DWARF_WHERE_CFAREL
&& labs((long) rs->reg.val[RSP]) < (1 << 14)
&& rs->reg.val[RSP]+1 != 0)))
{
/* Save information for a standard frame. */
f->frame_type = UNW_X86_64_FRAME_STANDARD;
f->cfa_reg_rsp = (rs->val[DWARF_CFA_REG_COLUMN] == RSP);
f->cfa_reg_offset = rs->val[DWARF_CFA_OFF_COLUMN];
if (rs->where[RBP] == DWARF_WHERE_CFAREL)
f->rbp_cfa_offset = rs->val[RBP];
if (rs->where[RSP] == DWARF_WHERE_CFAREL)
f->rsp_cfa_offset = rs->val[RSP];
f->cfa_reg_rsp = (rs->reg.val[DWARF_CFA_REG_COLUMN] == RSP);
f->cfa_reg_offset = rs->reg.val[DWARF_CFA_OFF_COLUMN];
if (rs->reg.where[RBP] == DWARF_WHERE_CFAREL)
f->rbp_cfa_offset = rs->reg.val[RBP];
if (rs->reg.where[RSP] == DWARF_WHERE_CFAREL)
f->rsp_cfa_offset = rs->reg.val[RSP];
Debug (4, " standard frame\n");
}

2
tests/Ltest-init-local-signal.c
View file

@ -35,6 +35,7 @@ void handler(int num, siginfo_t* info, void* ucontext) {
int ucontext_steps = stepper(&c);
ret = unw_init_local(&c, &context);
(void)ret;
assert(!ret);
int getcontext_steps = stepper(&c);
if (ucontext_steps == getcontext_steps - 2) {
@ -54,4 +55,5 @@ int main(){
sigaction(SIGSEGV, &a, NULL);
foo(NULL);
return 0;
}