sysdeps/unix/sysv/linux/sparc/sparc64/register-dump.h

   1 /* Dump registers.
   2    Copyright (C) 1999 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Jakub Jelinek <jj@ultra.linux.cz>, 1999.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, write to the Free
  18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.  */
  20
  21 #include <sys/uio.h>
  22 #include <stdio-common/_itoa.h>
  23
  24 /* We will print the register dump in this format:
  25
  26  TSTATE: XXXXXXXXXXXXXXXX TPC: XXXXXXXXXXXXXXXX TNPC: XXXXXXXXXXXXXXXX
  27  Y: XXXXXXXX
  28  g0: 0000000000000000  g1: XXXXXXXXXXXXXXXX  g2: XXXXXXXXXXXXXXXX
  29  g3: XXXXXXXXXXXXXXXX  g4: XXXXXXXXXXXXXXXX  g5: XXXXXXXXXXXXXXXX
  30  g6: XXXXXXXXXXXXXXXX  g7: XXXXXXXXXXXXXXXX
  31  o0: XXXXXXXXXXXXXXXX  o1: XXXXXXXXXXXXXXXX  o2: XXXXXXXXXXXXXXXX
  32  o3: XXXXXXXXXXXXXXXX  o4: XXXXXXXXXXXXXXXX  o5: XXXXXXXXXXXXXXXX
  33  sp: XXXXXXXXXXXXXXXX  o7: XXXXXXXXXXXXXXXX
  34  l0: XXXXXXXXXXXXXXXX  l1: XXXXXXXXXXXXXXXX  l2: XXXXXXXXXXXXXXXX
  35  l3: XXXXXXXXXXXXXXXX  l4: XXXXXXXXXXXXXXXX  l5: XXXXXXXXXXXXXXXX
  36  l6: XXXXXXXXXXXXXXXX  l7: XXXXXXXXXXXXXXXX
  37  i0: XXXXXXXXXXXXXXXX  i1: XXXXXXXXXXXXXXXX  i2: XXXXXXXXXXXXXXXX
  38  i3: XXXXXXXXXXXXXXXX  i4: XXXXXXXXXXXXXXXX  i5: XXXXXXXXXXXXXXXX
  39  fp: XXXXXXXXXXXXXXXX  i7: XXXXXXXXXXXXXXXX
  40
  41  Mask: XXXXXXXXXXXXXXXX XFSR: XXXXXXXXXXXXXXXX GSR: XX FPRS: X
  42   f0: XXXXXXXXXXXXXXXX   f2: XXXXXXXXXXXXXXXX   f4: XXXXXXXXXXXXXXXX
  43   f6: XXXXXXXXXXXXXXXX   f8: XXXXXXXXXXXXXXXX  f10: XXXXXXXXXXXXXXXX
  44  f12: XXXXXXXXXXXXXXXX  f14: XXXXXXXXXXXXXXXX  f16: XXXXXXXXXXXXXXXX
  45  f18: XXXXXXXXXXXXXXXX  f20: XXXXXXXXXXXXXXXX  f22: XXXXXXXXXXXXXXXX
  46  f24: XXXXXXXXXXXXXXXX  f26: XXXXXXXXXXXXXXXX  f28: XXXXXXXXXXXXXXXX
  47  f30: XXXXXXXXXXXXXXXX  f32: XXXXXXXXXXXXXXXX  f34: XXXXXXXXXXXXXXXX
  48  f36: XXXXXXXXXXXXXXXX  f38: XXXXXXXXXXXXXXXX  f40: XXXXXXXXXXXXXXXX
  49  f42: XXXXXXXXXXXXXXXX  f44: XXXXXXXXXXXXXXXX  f46: XXXXXXXXXXXXXXXX
  50  f48: XXXXXXXXXXXXXXXX  f50: XXXXXXXXXXXXXXXX  f52: XXXXXXXXXXXXXXXX
  51  f54: XXXXXXXXXXXXXXXX  f56: XXXXXXXXXXXXXXXX  f58: XXXXXXXXXXXXXXXX
  52  f60: XXXXXXXXXXXXXXXX  f62: XXXXXXXXXXXXXXXX
  53
  54  */
  55
  56 static void
  57 hexvalue (unsigned long int value, char *buf, size_t len)
  58 {
  59   char *cp = _itoa_word (value, buf + len, 16, 0);
  60   while (cp > buf)
  61     *--cp = '0';
  62 }
  63
  64 static void
  65 register_dump (int fd, SIGCONTEXT ctx)
  66 {
  67   char regs[36][16];
  68   char fregs[68][8];
  69   struct iovec iov[150];
  70   size_t nr = 0;
  71   int i;
  72   unsigned long *r = (unsigned long *)
  73     (ctx->sigc_regs.u_regs[14] + STACK_BIAS);
  74   __siginfo_fpu_t *f;
  75
  76 #define ADD_STRING(str) \
  77   iov[nr].iov_base = (char *) str;                                            \
  78   iov[nr].iov_len = strlen (str);                                             \
  79   ++nr
  80 #define ADD_MEM(str, len) \
  81   iov[nr].iov_base = str;                                                     \
  82   iov[nr].iov_len = len;                                                      \
  83   ++nr
  84
  85   /* Generate strings of register contents.  */
  86   hexvalue (ctx->sigc_regs.tstate,      regs[0], 16);
  87   hexvalue (ctx->sigc_regs.tpc,         regs[1], 16);
  88   hexvalue (ctx->sigc_regs.tnpc,        regs[2], 16);
  89   hexvalue (ctx->sigc_regs.y,           regs[3], 8);
  90   for (i = 1; i <= 15; i++)
  91     hexvalue (ctx->sigc_regs.u_regs[i], regs[3+i], 16);
  92   for (i = 0; i <= 15; i++)
  93     hexvalue (r[i],                     regs[19+i], 16);
  94   hexvalue (ctx->sigc_mask,             regs[35], 16);
  95
  96   /* Generate the output.  */
  97   ADD_STRING ("Register dump:\n\n TSTATE: ");
  98   ADD_MEM (regs[0], 16);
  99   ADD_STRING (" TPC: ");
 100   ADD_MEM (regs[1], 16);
 101   ADD_STRING (" TNPC: ");
 102   ADD_MEM (regs[2], 16);
 103   ADD_STRING ("\n Y: ");
 104   ADD_MEM (regs[3], 8);
 105   ADD_STRING ("\n  g0: 0000000000000000   g1: ");
 106   ADD_MEM (regs[4], 16);
 107   ADD_STRING ("  g2: ");
 108   ADD_MEM (regs[5], 16);
 109   ADD_STRING ("\n g3: ");
 110   ADD_MEM (regs[6], 16);
 111   ADD_STRING ("  g4: ");
 112   ADD_MEM (regs[7], 16);
 113   ADD_STRING ("  g5: ");
 114   ADD_MEM (regs[8], 16);
 115   ADD_STRING ("\n g6: ");
 116   ADD_MEM (regs[9], 16);
 117   ADD_STRING ("  g7: ");
 118   ADD_MEM (regs[10], 16);
 119   ADD_STRING ("\n o0: ");
 120   ADD_MEM (regs[11], 16);
 121   ADD_STRING ("  o1: ");
 122   ADD_MEM (regs[12], 16);
 123   ADD_STRING ("  o2: ");
 124   ADD_MEM (regs[13], 16);
 125   ADD_STRING ("\n o3: ");
 126   ADD_MEM (regs[14], 16);
 127   ADD_STRING ("  o4: ");
 128   ADD_MEM (regs[15], 16);
 129   ADD_STRING ("  o5: ");
 130   ADD_MEM (regs[16], 16);
 131   ADD_STRING ("\n sp: ");
 132   ADD_MEM (regs[17], 16);
 133   ADD_STRING ("  o7: ");
 134   ADD_MEM (regs[18], 16);
 135   ADD_STRING ("\n l0: ");
 136   ADD_MEM (regs[19], 16);
 137   ADD_STRING ("  l1: ");
 138   ADD_MEM (regs[20], 16);
 139   ADD_STRING ("  l2: ");
 140   ADD_MEM (regs[21], 16);
 141   ADD_STRING ("\n l3: ");
 142   ADD_MEM (regs[22], 16);
 143   ADD_STRING ("  l4: ");
 144   ADD_MEM (regs[23], 16);
 145   ADD_STRING ("  l5: ");
 146   ADD_MEM (regs[24], 16);
 147   ADD_STRING ("\n l6: ");
 148   ADD_MEM (regs[25], 16);
 149   ADD_STRING ("  l7: ");
 150   ADD_MEM (regs[26], 16);
 151   ADD_STRING ("\n i0: ");
 152   ADD_MEM (regs[27], 16);
 153   ADD_STRING ("  i1: ");
 154   ADD_MEM (regs[28], 16);
 155   ADD_STRING ("  i2: ");
 156   ADD_MEM (regs[29], 16);
 157   ADD_STRING ("\n i3: ");
 158   ADD_MEM (regs[30], 16);
 159   ADD_STRING ("  i4: ");
 160   ADD_MEM (regs[31], 16);
 161   ADD_STRING ("  i5: ");
 162   ADD_MEM (regs[32], 16);
 163   ADD_STRING ("\n fp: ");
 164   ADD_MEM (regs[33], 16);
 165   ADD_STRING ("  i7: ");
 166   ADD_MEM (regs[34], 16);
 167   ADD_STRING ("\n\n Mask: ");
 168   ADD_MEM (regs[35], 16);
 169
 170   f = ctx->sigc_fpu_save;
 171   if (f != NULL)
 172     {
 173       for (i = 0; i < 64; i++)
 174         hexvalue (f->si_float_regs[i], fregs[i], 8);
 175       hexvalue (f->si_fsr, fregs[64], 16);
 176       hexvalue (f->si_gsr, fregs[66], 2);
 177       hexvalue (f->si_fprs, fregs[67], 1);
 178       ADD_STRING (" XFSR: ");
 179       ADD_MEM (fregs[64], 16);
 180       ADD_STRING (" GSR: ");
 181       ADD_MEM (fregs[66], 2);
 182       ADD_STRING (" FPRS: ");
 183       ADD_MEM (fregs[67], 1);
 184       ADD_STRING ("\n  f0: ");
 185       ADD_MEM (fregs[0], 16);
 186       ADD_STRING ("   f2: ");
 187       ADD_MEM (fregs[2], 16);
 188       ADD_STRING ("   f4: ");
 189       ADD_MEM (fregs[4], 16);
 190       ADD_STRING ("\n  f6: ");
 191       ADD_MEM (fregs[6], 16);
 192       ADD_STRING ("   f8: ");
 193       ADD_MEM (fregs[8], 16);
 194       ADD_STRING ("  f10: ");
 195       ADD_MEM (fregs[10], 16);
 196       ADD_STRING ("\n f12: ");
 197       ADD_MEM (fregs[12], 16);
 198       ADD_STRING ("  f14: ");
 199       ADD_MEM (fregs[14], 16);
 200       ADD_STRING ("  f16: ");
 201       ADD_MEM (fregs[16], 16);
 202       ADD_STRING ("\n f18: ");
 203       ADD_MEM (fregs[18], 16);
 204       ADD_STRING ("  f20: ");
 205       ADD_MEM (fregs[20], 16);
 206       ADD_STRING ("  f22: ");
 207       ADD_MEM (fregs[22], 16);
 208       ADD_STRING ("\n f24: ");
 209       ADD_MEM (fregs[24], 16);
 210       ADD_STRING ("  f26: ");
 211       ADD_MEM (fregs[26], 16);
 212       ADD_STRING ("  f28: ");
 213       ADD_MEM (fregs[28], 16);
 214       ADD_STRING ("\n f30: ");
 215       ADD_MEM (fregs[30], 16);
 216       ADD_STRING ("  f32: ");
 217       ADD_MEM (fregs[32], 16);
 218       ADD_STRING ("  f34: ");
 219       ADD_MEM (fregs[34], 16);
 220       ADD_STRING ("\n f36: ");
 221       ADD_MEM (fregs[36], 16);
 222       ADD_STRING ("  f38: ");
 223       ADD_MEM (fregs[38], 16);
 224       ADD_STRING ("  f40: ");
 225       ADD_MEM (fregs[40], 16);
 226       ADD_STRING ("\n f42: ");
 227       ADD_MEM (fregs[42], 16);
 228       ADD_STRING ("  f44: ");
 229       ADD_MEM (fregs[44], 16);
 230       ADD_STRING ("  f46: ");
 231       ADD_MEM (fregs[46], 16);
 232       ADD_STRING ("\n f48: ");
 233       ADD_MEM (fregs[48], 16);
 234       ADD_STRING ("  f50: ");
 235       ADD_MEM (fregs[50], 16);
 236       ADD_STRING ("  f52: ");
 237       ADD_MEM (fregs[52], 16);
 238       ADD_STRING ("\n f54: ");
 239       ADD_MEM (fregs[54], 16);
 240       ADD_STRING ("  f56: ");
 241       ADD_MEM (fregs[56], 16);
 242       ADD_STRING ("  f58: ");
 243       ADD_MEM (fregs[58], 16);
 244       ADD_STRING ("\n f60: ");
 245       ADD_MEM (fregs[60], 16);
 246       ADD_STRING ("  f62: ");
 247       ADD_MEM (fregs[62], 16);
 248     }
 249
 250   ADD_STRING ("\n");
 251
 252   /* Write the stuff out.  */
 253   writev (fd, iov, nr);
 254 }
 255
 256
 257 #define REGISTER_DUMP register_dump (fd, ctx)