/* EXPORTED */ void VG_(sigframe_create)( ThreadId tid, Addr sp_top_of_frame, const vki_siginfo_t *siginfo, const struct vki_ucontext *siguc, void *handler, UInt flags, const vki_sigset_t *mask, void *restorer ) { Addr sp; ThreadState* tst = VG_(get_ThreadState)(tid); if (flags & VKI_SA_SIGINFO) sp = build_rt_sigframe(tst, sp_top_of_frame, siginfo, siguc, flags, mask, restorer); else sp = build_sigframe(tst, sp_top_of_frame, siginfo, siguc, flags, mask, restorer); /* Set the thread so it will next run the handler. */ VG_(set_SP)(tid, sp); VG_TRACK( post_reg_write, Vg_CoreSignal, tid, VG_O_STACK_PTR, sizeof(Addr)); tst->arch.vex.guest_IA = (Addr) handler; /* We might have interrupted a repeating instruction that uses the guest counter. Since our VEX requires that a new instruction will see a guest counter == 0, we have to set it here. The old value will be restored by restore_vg_sigframe. */ tst->arch.vex.guest_counter = 0; /* This thread needs to be marked runnable, but we leave that the caller to do. */ }
void VG_(sigframe_create)( ThreadId tid, Addr rsp_top_of_frame, const vki_siginfo_t *siginfo, const struct vki_ucontext *siguc, void *handler, UInt flags, const vki_sigset_t *mask, void *restorer ) { Addr rsp; struct rt_sigframe *frame; ThreadState* tst = VG_(get_ThreadState)(tid); rsp = build_rt_sigframe(tst, rsp_top_of_frame, siginfo, siguc, handler, flags, mask, restorer); frame = (struct rt_sigframe *)rsp; /* Set the thread so it will next run the handler. */ /* tst->m_rsp = rsp; also notify the tool we've updated RSP */ VG_(set_SP)(tid, rsp); VG_TRACK( post_reg_write, Vg_CoreSignal, tid, VG_O_STACK_PTR, sizeof(Addr)); //VG_(printf)("handler = %p\n", handler); tst->arch.vex.guest_RIP = (Addr) handler; tst->arch.vex.guest_RDI = (ULong) siginfo->si_signo; tst->arch.vex.guest_RSI = (Addr) &frame->sigInfo; tst->arch.vex.guest_RDX = (Addr) &frame->uContext; /* This thread needs to be marked runnable, but we leave that the caller to do. */ if (0) VG_(printf)("pushed signal frame; %%RSP now = %#lx, " "next %%RIP = %#llx, status=%d\n", rsp, tst->arch.vex.guest_RIP, tst->status); }
void VG_(sigframe_create)( ThreadId tid, Addr esp_top_of_frame, const vki_siginfo_t *siginfo, const struct vki_ucontext *siguc, void *handler, UInt flags, const vki_sigset_t *mask, void *restorer ) { Addr esp; ThreadState* tst = VG_(get_ThreadState)(tid); if (flags & VKI_SA_SIGINFO) esp = build_rt_sigframe(tst, esp_top_of_frame, siginfo, siguc, flags, mask, restorer); else esp = build_sigframe(tst, esp_top_of_frame, siginfo, siguc, flags, mask, restorer); VG_(set_SP)(tid, esp); VG_TRACK( post_reg_write, Vg_CoreSignal, tid, VG_O_STACK_PTR, sizeof(Addr)); tst->arch.vex.guest_EIP = (Addr) handler; if (0) VG_(printf)("pushed signal frame; %%ESP now = %#lx, " "next %%EIP = %#x, status=%d\n", esp, tst->arch.vex.guest_EIP, tst->status); }
/* EXPORTED */ void VG_(sigframe_create)( ThreadId tid, Addr esp_top_of_frame, const vki_siginfo_t *siginfo, const struct vki_ucontext *siguc, void *handler, UInt flags, const vki_sigset_t *mask, void *restorer ) { Addr esp; ThreadState* tst = VG_(get_ThreadState)(tid); if (flags & VKI_SA_SIGINFO) esp = build_rt_sigframe(tst, esp_top_of_frame, siginfo, siguc, handler, flags, mask, restorer); else esp = build_sigframe(tst, esp_top_of_frame, siginfo, siguc, handler, flags, mask, restorer); /* Set the thread so it will next run the handler. */ /* tst->m_esp = esp; also notify the tool we've updated ESP */ VG_(set_SP)(tid, esp); VG_TRACK( post_reg_write, Vg_CoreSignal, tid, VG_O_STACK_PTR, sizeof(Addr)); //VG_(printf)("handler = %p\n", handler); tst->arch.vex.guest_EIP = (Addr) handler; /* This thread needs to be marked runnable, but we leave that the caller to do. */ if (0) VG_(printf)("pushed signal frame; %%ESP now = %#lx, " "next %%EIP = %#x, status=%d\n", esp, tst->arch.vex.guest_EIP, tst->status); }