/* 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 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); }
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 sigframe *frame; ThreadState* tst = VG_(get_ThreadState)(tid); rsp = build_sigframe(tst, rsp_top_of_frame, siginfo, siguc, handler, flags, mask, restorer); frame = (struct 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. */ }
/* 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); }
/* EXPORTED */ void VG_(sigframe_create)( ThreadId tid, Bool on_altstack, 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 ) { ThreadState *tst; Addr sp = sp_top_of_frame; Int sigNo = siginfo->si_signo; UInt size; tst = VG_(get_ThreadState)(tid); size = sizeof(struct rt_sigframe); sp -= size; sp = VG_ROUNDDN(sp, 16); if (! ML_(sf_maybe_extend_stack)(tst, sp, size, flags)) return; // Give up. No idea if this is correct struct rt_sigframe *rsf = (struct rt_sigframe *)sp; /* Track our writes to siginfo */ VG_TRACK( pre_mem_write, Vg_CoreSignal, tst->tid, /* VVVVV */ "signal handler siginfo", (Addr)rsf, offsetof(struct rt_sigframe, sig)); VG_(memcpy)(&rsf->info, siginfo, sizeof(vki_siginfo_t)); if (sigNo == VKI_SIGILL && siginfo->si_code > 0) { rsf->info._sifields._sigfault._addr = (Addr*)(tst)->arch.vex.guest_PC; } VG_TRACK( post_mem_write, Vg_CoreSignal, tst->tid, /* ^^^^^ */ (Addr)rsf, offsetof(struct rt_sigframe, sig)); build_sigframe(tst, &rsf->sig, siginfo, siguc, handler, flags, mask, restorer); tst->arch.vex.guest_X1 = (Addr)&rsf->info; tst->arch.vex.guest_X2 = (Addr)&rsf->sig.uc; VG_(set_SP)(tid, sp); VG_TRACK( post_reg_write, Vg_CoreSignal, tid, VG_O_STACK_PTR, sizeof(Addr)); tst->arch.vex.guest_X0 = sigNo; if (flags & VKI_SA_RESTORER) tst->arch.vex.guest_X30 = (Addr)restorer; else tst->arch.vex.guest_X30 = (Addr)&VG_(arm64_linux_SUBST_FOR_rt_sigreturn); tst->arch.vex.guest_PC = (Addr)handler; }
/* 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 ) { // struct vg_sig_private *priv; Addr sp = sp_top_of_frame; ThreadState *tst; Int sigNo = siginfo->si_signo; // Addr faultaddr; UInt size; tst = VG_(get_ThreadState)(tid); size = flags & VKI_SA_SIGINFO ? sizeof(struct rt_sigframe) : sizeof(struct sigframe); sp -= size; sp = VG_ROUNDDN(sp, 16); if(!extend(tst, sp, size)) I_die_here; // XXX Incorrect behavior if (flags & VKI_SA_SIGINFO){ struct rt_sigframe *rsf = (struct rt_sigframe *)sp; /* Track our writes to siginfo */ VG_TRACK( pre_mem_write, Vg_CoreSignal, tst->tid, /* VVVVV */ "signal handler siginfo", (Addr)rsf, offsetof(struct rt_sigframe, sig)); VG_(memcpy)(&rsf->info, siginfo, sizeof(vki_siginfo_t)); if(sigNo == VKI_SIGILL && siginfo->si_code > 0) { rsf->info._sifields._sigfault._addr = (Addr *) (tst)->arch.vex.guest_R12; /* IP */ } VG_TRACK( post_mem_write, Vg_CoreSignal, tst->tid, /* ^^^^^ */ (Addr)rsf, offsetof(struct rt_sigframe, sig)); build_sigframe(tst, &rsf->sig, siginfo, siguc, handler, flags, mask, restorer); tst->arch.vex.guest_R1 = (Addr)&rsf->info; tst->arch.vex.guest_R2 = (Addr)&rsf->sig.uc; } else {