/*      $OpenBSD: process_machdep.c,v 1.6 2021/07/30 13:10:12 kettenis Exp $    */

/*
 * Copyright (c) 2014 Patrick Wildt <patrick@blueri.se>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

/*
 * This file may seem a bit stylized, but that so that it's easier to port.
 * Functions to be implemented here are:
 *
 * process_read_regs(proc, regs)
 *      Get the current user-visible register set from the process
 *      and copy it into the regs structure (<machine/reg.h>).
 *      The process is stopped at the time read_regs is called.
 *
 * process_write_regs(proc, regs)
 *      Update the current register set from the passed in regs
 *      structure.  Take care to avoid clobbering special CPU
 *      registers or privileged bits in the PSL.
 *      The process is stopped at the time write_regs is called.
 *
 * process_sstep(proc, sstep)
 *      Arrange for the process to trap or not trap depending on sstep
 *      after executing a single instruction.
 *
 * process_set_pc(proc)
 *      Set the process's program counter.
 */

#include <sys/param.h>

#include <sys/proc.h>
#include <sys/ptrace.h>
#include <sys/systm.h>
#include <sys/user.h>

#include <machine/pcb.h>
#include <machine/reg.h>

int
process_read_regs(struct proc *p, struct reg *regs)
{
        struct trapframe *tf = p->p_addr->u_pcb.pcb_tf;

        memcpy(&regs->r_t[0], &tf->tf_t[0], sizeof(regs->r_t));
        memcpy(&regs->r_s[0], &tf->tf_s[0], sizeof(regs->r_s));
        memcpy(&regs->r_a[0], &tf->tf_a[0], sizeof(regs->r_a));
        regs->r_ra = tf->tf_ra;
        regs->r_sp = tf->tf_sp;
        regs->r_gp = tf->tf_gp;
        regs->r_tp = tf->tf_tp;
        regs->r_sepc = tf->tf_sepc;
        regs->r_sstatus = tf->tf_sstatus;

        return(0);
}

int
process_read_fpregs(struct proc *p, struct fpreg *regs)
{
        struct trapframe *tf = p->p_addr->u_pcb.pcb_tf;

        if (p->p_addr->u_pcb.pcb_flags & PCB_FPU)
                fpu_save(p, tf);

        if (p->p_addr->u_pcb.pcb_flags & PCB_FPU)
                memcpy(regs, &p->p_addr->u_pcb.pcb_fpstate, sizeof(*regs));
        else
                memset(regs, 0, sizeof(*regs));

        return(0);
}

#ifdef PTRACE

int
process_write_regs(struct proc *p, struct reg *regs)
{
        struct trapframe *tf = p->p_addr->u_pcb.pcb_tf;

        memcpy(&tf->tf_t[0], &regs->r_t[0], sizeof(tf->tf_t));
        memcpy(&tf->tf_s[0], &regs->r_s[0], sizeof(tf->tf_s));
        memcpy(&tf->tf_a[0], &regs->r_a[0], sizeof(tf->tf_a));
        tf->tf_ra = regs->r_ra;
        tf->tf_sp = regs->r_sp;
        tf->tf_gp = regs->r_gp;
        tf->tf_tp = regs->r_tp;
        tf->tf_sepc = regs->r_sepc;

        return(0);
}

int
process_write_fpregs(struct proc *p,  struct fpreg *regs)
{
        struct trapframe *tf = p->p_addr->u_pcb.pcb_tf;

        memcpy(&p->p_addr->u_pcb.pcb_fpstate, regs,
            sizeof(p->p_addr->u_pcb.pcb_fpstate));
        p->p_addr->u_pcb.pcb_flags |= PCB_FPU;

        /* drop FPU state */
        tf->tf_sstatus &= ~SSTATUS_FS_MASK;
        tf->tf_sstatus |= SSTATUS_FS_OFF;

        return(0);
}

int
process_sstep(struct proc *p, int sstep)
{
        return (EOPNOTSUPP);
}

int
process_set_pc(struct proc *p, caddr_t addr)
{
        struct trapframe *tf = p->p_addr->u_pcb.pcb_tf;
        tf->tf_sepc = (uint64_t)addr;
        return (0);
}

#endif  /* PTRACE */