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

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