gdb/vx-share/xdr_regs.c

   1 /* xdr_regs.c - xdr routines for 68k registers */
   2
   3 /* Copyright 1984,1985,1986,1987,1988,1989 Wind River Systems, Inc. */
   4
   5 /*
   6 DESCRIPTION
   7 This module contains the eXternal Data Representation (XDR) routines
   8 for the GDB interface for VxWorks.
   9 */
  10
  11 #include "vxWorks.h"
  12 #include <rpc/rpc.h>
  13 #include "reg.h"
  14 #include "xdr_regs.h"
  15
  16
  17 #ifdef I80960
  18 /*******************************************************************************
  19 *
  20 * xdr_regs - xdr routine for i960 registers
  21 */
  22
  23 bool_t xdr_regs (xdrs, objp)
  24     XDR *xdrs;
  25     struct regs *objp;
  26
  27     {
  28     if (! xdr_opaque(xdrs, (char *) objp->r_lreg, 16 * sizeof(int)))
  29         return(FALSE);
  30     if (! xdr_opaque(xdrs, (char *) objp->r_greg, 16 * sizeof(int)))
  31         return(FALSE);
  32     if (! xdr_opaque(xdrs, (char *) &objp->r_pcw, sizeof(int)))
  33         return(FALSE);
  34     if (! xdr_opaque(xdrs, (char *) &objp->r_acw, sizeof(int)))
  35         return(FALSE);
  36     if (! xdr_opaque(xdrs, (char *) &objp->r_tcw, sizeof(int)))
  37         return(FALSE);
  38
  39     return(TRUE);
  40     }
  41
  42 /*******************************************************************************
  43 *
  44 * xdr_fp_status - xdr routine for i960 floating point registers
  45 */
  46
  47 bool_t xdr_fp_status (xdrs, objp)
  48     XDR *xdrs;
  49     struct fp_status *objp;
  50
  51     {
  52     unsigned int size = 4 * FP_REG_SIZE;
  53
  54     /* We use xdr_bytes to indicate how many bytes of FP regs there are! */
  55     if (! xdr_bytes (xdrs, (char *) objp->fps_regs, &size, 4 * FP_REG_SIZE))
  56         return (FALSE);
  57     return (TRUE);
  58     }
  59
  60 /*******************************************************************************
  61 *
  62 * xdr_ext_fp - xdr for a single fp register
  63 */
  64
  65 bool_t xdr_ext_fp (xdrs, objp)
  66     XDR *xdrs;
  67     char *objp;
  68
  69     {
  70     unsigned int size = FP_REG_SIZE;
  71
  72     if (! xdr_bytes (xdrs, objp, &size, FP_REG_SIZE))
  73         return(FALSE);
  74
  75     return(TRUE);
  76     }
  77 #else   /* Must be 68K if it isn't i960 -- for now.  FIXME!  */
  78
  79 /*******************************************************************************
  80 *
  81 * xdr_regs - xdr routine for 68k registers
  82 */
  83
  84 bool_t xdr_regs (xdrs, objp)
  85     XDR *xdrs;
  86     struct regs *objp;
  87
  88     {
  89     if (! xdr_opaque(xdrs, (char *) objp->r_dreg, 8 * sizeof(int)))
  90         return(FALSE);
  91     if (! xdr_opaque(xdrs, (char *) objp->r_areg, 8 * sizeof(int)))
  92         return(FALSE);
  93     if (! xdr_opaque(xdrs, (char *) &objp->r_sr, sizeof(int)))
  94         return(FALSE);
  95     if (! xdr_opaque(xdrs, (char *) &objp->r_pc, sizeof(int)))
  96         return(FALSE);
  97
  98     return(TRUE);
  99     }
 100
 101 /*******************************************************************************
 102 *
 103 * xdr_ext_fp - xdr for a single fp register
 104 */
 105
 106 bool_t xdr_ext_fp (xdrs, objp)
 107     XDR *xdrs;
 108     ext_fp *objp;
 109
 110     {
 111     if (! xdr_vector(xdrs, (char *) objp->fp, 3, sizeof(int), xdr_int))
 112         return(FALSE);
 113
 114     return(TRUE);
 115     }
 116 /*******************************************************************************
 117 *
 118 * xdr_fp_status - xdr routine for floating point registers
 119 */
 120
 121 bool_t xdr_fp_status (xdrs, objp)
 122     XDR *xdrs;
 123     struct fp_status *objp;
 124
 125     {
 126     if (! xdr_vector (xdrs, (char *) objp->fps_regs, 8,
 127                 sizeof(ext_fp), xdr_ext_fp))
 128         return (FALSE);
 129     if (! xdr_int (xdrs, &objp->fps_control))
 130         return (FALSE);
 131     if (! xdr_int (xdrs, &objp->fps_status))
 132         return (FALSE);
 133     if (! xdr_int (xdrs, &objp->fps_iaddr))
 134         return (FALSE);
 135     if (! xdr_int (xdrs, &objp->fps_code))
 136         return (FALSE);
 137     if (! xdr_int (xdrs, &objp->fps_flags))
 138         return (FALSE);
 139
 140     return (TRUE);
 141     }
 142 /*******************************************************************************
 143 *
 144 * xdr_fpa_status - xdr for fpa status
 145 */
 146
 147 bool_t xdr_fpa_status (xdrs, objp)
 148     XDR *xdrs;
 149     struct fpa_status *objp;
 150
 151     {
 152     if (! xdr_u_int (xdrs, &objp->fpas_state))
 153         return (FALSE);
 154     if (! xdr_u_int (xdrs, &objp->fpas_imask))
 155         return (FALSE);
 156     if (! xdr_u_int (xdrs, &objp->fpas_load_ptr))
 157         return (FALSE);
 158     if (! xdr_u_int (xdrs, &objp->fpas_ierr))
 159         return (FALSE);
 160     if (! xdr_u_int (xdrs, &objp->fpas_act_instr))
 161         return (FALSE);
 162     if (! xdr_u_int (xdrs, &objp->fpas_nxt_instr))
 163         return (FALSE);
 164     if (! xdr_u_int (xdrs, &objp->fpas_act_d1half))
 165         return (FALSE);
 166     if (! xdr_u_int (xdrs, &objp->fpas_act_d2half))
 167         return (FALSE);
 168     if (! xdr_u_int (xdrs, &objp->fpas_nxt_d1half))
 169         return (FALSE);
 170     if (! xdr_u_int (xdrs, &objp->fpas_nxt_d2half))
 171         return (FALSE);
 172     if (! xdr_u_int (xdrs, &objp->fpas_mode3_0))
 173         return (FALSE);
 174     if (! xdr_u_int (xdrs, &objp->fpas_wstatus))
 175         return (FALSE);
 176
 177     return (TRUE);
 178     }
 179 /*******************************************************************************
 180 *
 181 * xdr_fpa_long - xdr for fpa data register
 182 */
 183
 184 bool_t xdr_fpa_long (xdrs,objp)
 185     XDR *xdrs;
 186     fpa_long *objp;
 187
 188     {
 189     if (! xdr_vector (xdrs, (char *) objp->fpl_data, 2, sizeof(int), xdr_int))
 190         return (FALSE);
 191
 192     return (TRUE);
 193     }
 194 /*******************************************************************************
 195 *
 196 * xdr_fpa_regs - xdr for fpa_regs
 197 */
 198
 199 bool_t xdr_fpa_regs (xdrs, objp)
 200     XDR *xdrs;
 201     struct fpa_regs *objp;
 202
 203     {
 204     if (! xdr_u_int (xdrs, &objp->fpar_flags))
 205         return (FALSE);
 206     if (! xdr_fpa_status (xdrs, &objp->fpar_status))
 207         return (FALSE);
 208     if (! xdr_vector (xdrs, (char *) objp->fpar_data,
 209                     FPA_NDATA_REGS, sizeof(fpa_long), xdr_fpa_long))
 210         return (FALSE);
 211
 212     return (TRUE);
 213     }
 214
 215 #endif /* I80960 */
 216