Return to process_machdep.c CVS log

Up to [local] / sys / arch / hppa64 / hppa64

Annotation of sys/arch/hppa64/hppa64/process_machdep.c, Revision 1.1.1.1

1.1       nbrk        1: /*     $OpenBSD: process_machdep.c,v 1.1 2005/04/01 10:40:47 mickey Exp $      */
                      2:
                      3: /*
                      4:  * Copyright (c) 2005 Michael Shalayeff
                      5:  * All rights reserved.
                      6:  *
                      7:  * Permission to use, copy, modify, and distribute this software for any
                      8:  * purpose with or without fee is hereby granted, provided that the above
                      9:  * copyright notice and this permission notice appear in all copies.
                     10:  *
                     11:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
                     12:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
                     13:  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
                     14:  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
                     15:  * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER IN
                     16:  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
                     17:  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
                     18:  */
                     19:
                     20:
                     21: #include <sys/param.h>
                     22: #include <sys/systm.h>
                     23: #include <sys/proc.h>
                     24: #include <sys/ptrace.h>
                     25: #include <sys/user.h>
                     26:
                     27: int
                     28: process_read_regs(p, regs)
                     29:        struct proc *p;
                     30:        struct reg *regs;
                     31: {
                     32:        struct trapframe *tf = p->p_md.md_regs;
                     33:
                     34:        regs->r_regs[0] = tf->tf_sar;
                     35:        bcopy(&tf->tf_r1, &regs->r_regs[1], 31*8);
                     36:        regs->r_pc  = tf->tf_iioq[0];
                     37:        regs->r_npc = tf->tf_iioq[1];
                     38:
                     39:        return (0);
                     40: }
                     41:
                     42: int
                     43: process_read_fpregs(p, fpregs)
                     44:        struct proc *p;
                     45:        struct fpreg *fpregs;
                     46: {
                     47:        extern paddr_t fpu_curpcb;
                     48:        extern u_int fpu_enable;
                     49:
                     50:        if (p->p_md.md_regs->tf_cr30 == fpu_curpcb) {
                     51:                mtctl(fpu_enable, CR_CCR);
                     52:                fpu_save((vaddr_t)p->p_addr->u_pcb.pcb_fpregs);
                     53:                mtctl(0, CR_CCR);
                     54:        }
                     55:        bcopy(p->p_addr->u_pcb.pcb_fpregs, fpregs, 32*8);
                     56:
                     57:        return (0);
                     58: }
                     59:
                     60: #ifdef PTRACE
                     61:
                     62: int
                     63: process_write_regs(p, regs)
                     64:        struct proc *p;
                     65:        struct reg *regs;
                     66: {
                     67:        struct trapframe *tf = p->p_md.md_regs;
                     68:
                     69:        tf->tf_sar = regs->r_regs[0];
                     70:        bcopy(&regs->r_regs[1], &tf->tf_r1, 31*8);
                     71:        tf->tf_iioq[0] = regs->r_pc | 3;
                     72:        tf->tf_iioq[1] = regs->r_npc | 3;
                     73:
                     74:        return (0);
                     75: }
                     76:
                     77: int
                     78: process_write_fpregs(p, fpregs)
                     79:        struct proc *p;
                     80:        struct fpreg *fpregs;
                     81: {
                     82:        extern paddr_t fpu_curpcb;
                     83:
                     84:        if (p->p_md.md_regs->tf_cr30 == fpu_curpcb) {
                     85:                fpu_exit();
                     86:                fpu_curpcb = 0;
                     87:        }
                     88:
                     89:        bcopy(fpregs, p->p_addr->u_pcb.pcb_fpregs, 32 * 8);
                     90:
                     91:        return (0);
                     92: }
                     93:
                     94: int
                     95: process_sstep(p, sstep)
                     96:        struct proc *p;
                     97:        int sstep;
                     98: {
                     99:        if (sstep)
                    100:                return (EINVAL);
                    101:
                    102:        return (0);
                    103: }
                    104:
                    105: int
                    106: process_set_pc(p, addr)
                    107:        struct proc *p;
                    108:        caddr_t addr;
                    109: {
                    110:        p->p_md.md_regs->tf_iioq[1] = 4 +
                    111:            (p->p_md.md_regs->tf_iioq[0] = (register_t)addr | 3);
                    112:
                    113:        return (0);
                    114: }
                    115:
                    116: #endif /* PTRACE */