1 /* Dump registers.
2    Copyright (C) 2004-2021 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4 
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Lesser General Public
7    License as published by the Free Software Foundation; either
8    version 2.1 of the License, or (at your option) any later version.
9 
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Lesser General Public License for more details.
14 
15    You should have received a copy of the GNU Lesser General Public
16    License along with the GNU C Library; if not, see
17    <https://www.gnu.org/licenses/>.  */
18 
19 #include <string.h>
20 #include <sys/uio.h>
21 #include <_itoa.h>
22 
23 /* We will print the register dump in this format:
24 
25  GP:   XXXXXXXXXXXXXXXX R2:   XXXXXXXXXXXXXXXX R3:   XXXXXXXXXXXXXXXX
26  R8:   XXXXXXXXXXXXXXXX R9:   XXXXXXXXXXXXXXXX R10:  XXXXXXXXXXXXXXXX
27  R11:  XXXXXXXXXXXXXXXX SP:   XXXXXXXXXXXXXXXX TP:   XXXXXXXXXXXXXXXX
28  R14:  XXXXXXXXXXXXXXXX R15:  XXXXXXXXXXXXXXXX R16:  XXXXXXXXXXXXXXXX
29  R17:  XXXXXXXXXXXXXXXX R18:  XXXXXXXXXXXXXXXX R19:  XXXXXXXXXXXXXXXX
30  R20:  XXXXXXXXXXXXXXXX R21:  XXXXXXXXXXXXXXXX R22:  XXXXXXXXXXXXXXXX
31  R23:  XXXXXXXXXXXXXXXX R24:  XXXXXXXXXXXXXXXX R25:  XXXXXXXXXXXXXXXX
32  R26:  XXXXXXXXXXXXXXXX R27:  XXXXXXXXXXXXXXXX R28:  XXXXXXXXXXXXXXXX
33  R29:  XXXXXXXXXXXXXXXX R30:  XXXXXXXXXXXXXXXX R31:  XXXXXXXXXXXXXXXX
34 
35  RP:   XXXXXXXXXXXXXXXX B6:   XXXXXXXXXXXXXXXX B7:   XXXXXXXXXXXXXXXX
36 
37  IP:   XXXXXXXXXXXXXXXX RSC:  XXXXXXXXXXXXXXXX PR:   XXXXXXXXXXXXXXXX
38  PFS:  XXXXXXXXXXXXXXXX UNAT: XXXXXXXXXXXXXXXX CFM:  XXXXXXXXXXXXXXXX
39  CCV:  XXXXXXXXXXXXXXXX FPSR: XXXXXXXXXXXXXXXX
40 
41  F32:  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX F33:  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
42  F34:  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX F35:  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
43 ...
44  F124: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX F125: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
45  F126: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX F127: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
46  */
47 
48 static void
hexvalue(unsigned long int value,char * buf,size_t len)49 hexvalue (unsigned long int value, char *buf, size_t len)
50 {
51   char *cp = _itoa_word (value, buf + len, 16, 0);
52   while (cp > buf)
53     *--cp = '0';
54 }
55 
56 static void
regvalue(unsigned long int * value,char letter,int regno,char * buf)57 regvalue (unsigned long int *value, char letter, int regno, char *buf)
58 {
59   int n = regno >= 100 ? 3 : regno >= 10 ? 2 : 1;
60   buf[0] = ' ';
61   buf[1] = letter;
62   _itoa_word (regno, buf + 2 + n, 10, 0);
63   buf[2 + n] = ':';
64   for (++n; n <= 4; ++n)
65     buf[2 + n] = ' ';
66   hexvalue (value[0], buf + 7, 16);
67   if (letter == 'F')
68     {
69       hexvalue (value[1], buf + 7 + 16, 16);
70       buf[7 + 32] = '\n';
71     }
72   else
73     buf[7 + 16] = '\n';
74 }
75 
76 static void
register_dump(int fd,struct sigcontext * ctx)77 register_dump (int fd, struct sigcontext *ctx)
78 {
79   char gpregs[32 - 5][8 + 16];
80   char fpregs[128 - 32][8 + 32];
81   char bpregs[3][8 + 16];
82   char spregs[8][16];
83   struct iovec iov[146];
84   size_t nr = 0;
85   int i;
86 
87 #define ADD_STRING(str) \
88   do									      \
89     {									      \
90       iov[nr].iov_base = (char *) str;					      \
91       iov[nr].iov_len = strlen (str);					      \
92       ++nr;								      \
93     }									      \
94   while (0)
95 #define ADD_MEM(str, len) \
96   do									      \
97     {									      \
98       iov[nr].iov_base = str;						      \
99       iov[nr].iov_len = len;						      \
100       ++nr;								      \
101     }									      \
102   while (0)
103 
104   /* Generate strings of register contents.  */
105   for (i = 1; i < 4; ++i)
106     {
107       regvalue (&ctx->sc_gr[i], 'R', i, gpregs[i - 1]);
108       if (ctx->sc_nat & (1L << i))
109         memcpy (gpregs[i - 1] + 7, "NaT             ", 16);
110     }
111   for (i = 8; i < 32; ++i)
112     {
113       regvalue (&ctx->sc_gr[i], 'R', i, gpregs[i - 5]);
114       if (ctx->sc_nat & (1L << i))
115         memcpy (gpregs[i - 1] + 7, "NaT             ", 16);
116     }
117   memcpy (gpregs[0] + 1, "GP:", 3);
118   memcpy (gpregs[7] + 1, "SP: ", 4);
119   memcpy (gpregs[8] + 1, "TP: ", 4);
120 
121   regvalue (&ctx->sc_br[0], 'B', 0, bpregs[0]);
122   regvalue (&ctx->sc_br[6], 'B', 6, bpregs[1]);
123   regvalue (&ctx->sc_br[7], 'B', 7, bpregs[2]);
124   memcpy (bpregs[0] + 1, "RP:", 3);
125 
126   if (ctx->sc_flags & IA64_SC_FLAG_FPH_VALID)
127     for (i = 32; i < 128; ++i)
128       regvalue (&ctx->sc_fr[i].u.bits[0], 'F', i, fpregs[i - 32]);
129 
130   hexvalue (ctx->sc_ip, spregs[0], sizeof (spregs[0]));
131   hexvalue (ctx->sc_ar_rsc, spregs[1], sizeof (spregs[1]));
132   hexvalue (ctx->sc_pr, spregs[2], sizeof (spregs[2]));
133   hexvalue (ctx->sc_ar_pfs, spregs[3], sizeof (spregs[3]));
134   hexvalue (ctx->sc_ar_unat, spregs[4], sizeof (spregs[4]));
135   hexvalue (ctx->sc_cfm, spregs[5], sizeof (spregs[5]));
136   hexvalue (ctx->sc_ar_ccv, spregs[6], sizeof (spregs[6]));
137   hexvalue (ctx->sc_ar_fpsr, spregs[7], sizeof (spregs[7]));
138 
139   /* Generate the output.  */
140   ADD_STRING ("Register dump:\n\n");
141 
142   for (i = 0; i < 32 - 5; ++i)
143     ADD_MEM (gpregs[i], sizeof (gpregs[0]) - 1 + ((i % 3) == 2));
144   ADD_STRING ("\n");
145 
146   for (i = 0; i < 3; ++i)
147     ADD_MEM (bpregs[i], sizeof (bpregs[0]) - 1);
148 
149   ADD_STRING ("\n\n IP:   ");
150   ADD_MEM (spregs[0], sizeof (spregs[0]));
151   ADD_STRING (" RSC:  ");
152   ADD_MEM (spregs[1], sizeof (spregs[0]));
153   ADD_STRING (" PR:   ");
154   ADD_MEM (spregs[2], sizeof (spregs[0]));
155   ADD_STRING ("\n PFS:  ");
156   ADD_MEM (spregs[3], sizeof (spregs[0]));
157   ADD_STRING (" UNAT: ");
158   ADD_MEM (spregs[4], sizeof (spregs[0]));
159   ADD_STRING (" CFM:  ");
160   ADD_MEM (spregs[5], sizeof (spregs[0]));
161   ADD_STRING ("\n CCV:  ");
162   ADD_MEM (spregs[6], sizeof (spregs[0]));
163   ADD_STRING (" FPSR: ");
164   ADD_MEM (spregs[7], sizeof (spregs[0]));
165   ADD_STRING ("\n");
166 
167   if (ctx->sc_flags & IA64_SC_FLAG_FPH_VALID)
168     {
169       ADD_STRING ("\n");
170 
171       for (i = 0; i < 128 - 32; ++i)
172         ADD_MEM (fpregs[i], sizeof (fpregs[0]) - 1 + (i & 1));
173     }
174 
175   /* Write the stuff out.  */
176   writev (fd, iov, nr);
177 }
178 
179 
180 #define REGISTER_DUMP register_dump (fd, ctx)
181