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 <ucontext.h>
21 #include <sys/uio.h>
22 #include <_itoa.h>
23
24 /* We will print the register dump in this format:
25
26 V0: XXXXXXXXXXXXXXXX T0: XXXXXXXXXXXXXXXX T1: XXXXXXXXXXXXXXXX
27 T2: XXXXXXXXXXXXXXXX T3: XXXXXXXXXXXXXXXX T4: XXXXXXXXXXXXXXXX
28 T5: XXXXXXXXXXXXXXXX T6: XXXXXXXXXXXXXXXX T7: XXXXXXXXXXXXXXXX
29 S0: XXXXXXXXXXXXXXXX S1: XXXXXXXXXXXXXXXX S2: XXXXXXXXXXXXXXXX
30 S3: XXXXXXXXXXXXXXXX S4: XXXXXXXXXXXXXXXX S5: XXXXXXXXXXXXXXXX
31 S6: XXXXXXXXXXXXXXXX A0: XXXXXXXXXXXXXXXX A1: XXXXXXXXXXXXXXXX
32 A2: XXXXXXXXXXXXXXXX A3: XXXXXXXXXXXXXXXX A4: XXXXXXXXXXXXXXXX
33 A5: XXXXXXXXXXXXXXXX T8: XXXXXXXXXXXXXXXX T9: XXXXXXXXXXXXXXXX
34 T10: XXXXXXXXXXXXXXXX T11: XXXXXXXXXXXXXXXX RA: XXXXXXXXXXXXXXXX
35 T12: XXXXXXXXXXXXXXXX AT: XXXXXXXXXXXXXXXX GP: XXXXXXXXXXXXXXXX
36 SP: XXXXXXXXXXXXXXXX PC: XXXXXXXXXXXXXXXX
37
38 FP0: XXXXXXXXXXXXXXXX FP1: XXXXXXXXXXXXXXXX FP2: XXXXXXXXXXXXXXXX
39 FP3: XXXXXXXXXXXXXXXX FP4: XXXXXXXXXXXXXXXX FP5: XXXXXXXXXXXXXXXX
40 FP6: XXXXXXXXXXXXXXXX FP7: XXXXXXXXXXXXXXXX FP8: XXXXXXXXXXXXXXXX
41 FP9: XXXXXXXXXXXXXXXX FP10: XXXXXXXXXXXXXXXX FP11: XXXXXXXXXXXXXXXX
42 FP12: XXXXXXXXXXXXXXXX FP13: XXXXXXXXXXXXXXXX FP14: XXXXXXXXXXXXXXXX
43 FP15: XXXXXXXXXXXXXXXX FP16: XXXXXXXXXXXXXXXX FP17: XXXXXXXXXXXXXXXX
44 FP18: XXXXXXXXXXXXXXXX FP19: XXXXXXXXXXXXXXXX FP20: XXXXXXXXXXXXXXXX
45 FP21: XXXXXXXXXXXXXXXX FP22: XXXXXXXXXXXXXXXX FP23: XXXXXXXXXXXXXXXX
46 FP24: XXXXXXXXXXXXXXXX FP25: XXXXXXXXXXXXXXXX FP26: XXXXXXXXXXXXXXXX
47 FP27: XXXXXXXXXXXXXXXX FP28: XXXXXXXXXXXXXXXX FP29: XXXXXXXXXXXXXXXX
48 FP30: XXXXXXXXXXXXXXXX FPCR: XXXXXXXXXXXXXXXX
49
50 TA0: XXXXXXXXXXXXXXXX TA1: XXXXXXXXXXXXXXXX TA2: XXXXXXXXXXXXXXXX
51 */
52
53 static void
hexvalue(unsigned long int value,char * buf,size_t len)54 hexvalue (unsigned long int value, char *buf, size_t len)
55 {
56 char *cp = _itoa_word (value, buf + len, 16, 0);
57 while (cp > buf)
58 *--cp = '0';
59 }
60
61 static void
register_dump(int fd,struct ucontext_t * ctx)62 register_dump (int fd, struct ucontext_t *ctx)
63 {
64 struct iovec iov[31 * 2 + 2 /* REGS + PC. */
65 + 31 * 2 + 2 /* FREGS + FPCR. */
66 + (3 * 2) /* TA0, TA1, TA3. */
67 + 1 /* '\n'. */];
68 size_t nr = 0;
69
70 #define ADD_STRING(str) \
71 iov[nr].iov_base = (char *) str; \
72 iov[nr].iov_len = strlen (str); \
73 ++nr
74 #define ADD_MEM(str, len) \
75 iov[nr].iov_base = str; \
76 iov[nr].iov_len = len; \
77 ++nr
78
79 char regs[31][16];
80 char pc[16];
81 for (int i = 0; i < 31; i++)
82 hexvalue (ctx->uc_mcontext.sc_regs[i], regs[i], 16);
83 hexvalue (ctx->uc_mcontext.sc_pc, pc, 16);
84
85 /* Generate the output. */
86 ADD_STRING ("Register dump:\n\n V0: ");
87 ADD_MEM (regs[0], 16);
88 ADD_STRING (" T0: ");
89 ADD_MEM (regs[1], 16);
90 ADD_STRING (" T1: ");
91 ADD_MEM (regs[2], 16);
92 ADD_STRING ("\n T2: ");
93 ADD_MEM (regs[3], 16);
94 ADD_STRING (" T3: ");
95 ADD_MEM (regs[4], 16);
96 ADD_STRING (" T4: ");
97 ADD_MEM (regs[5], 16);
98 ADD_STRING ("\n T5: ");
99 ADD_MEM (regs[6], 16);
100 ADD_STRING (" T6: ");
101 ADD_MEM (regs[7], 16);
102 ADD_STRING (" T7: ");
103 ADD_MEM (regs[8], 16);
104 ADD_STRING ("\n S0: ");
105 ADD_MEM (regs[9], 16);
106 ADD_STRING (" S1: ");
107 ADD_MEM (regs[10], 16);
108 ADD_STRING (" S2: ");
109 ADD_MEM (regs[11], 16);
110 ADD_STRING ("\n S3: ");
111 ADD_MEM (regs[12], 16);
112 ADD_STRING (" S4: ");
113 ADD_MEM (regs[13], 16);
114 ADD_STRING (" S5: ");
115 ADD_MEM (regs[14], 16);
116 ADD_STRING ("\n S6: ");
117 ADD_MEM (regs[15], 16);
118 ADD_STRING (" A0: ");
119 ADD_MEM (regs[16], 16);
120 ADD_STRING (" A1: ");
121 ADD_MEM (regs[17], 16);
122 ADD_STRING ("\n A2: ");
123 ADD_MEM (regs[18], 16);
124 ADD_STRING (" A3: ");
125 ADD_MEM (regs[19], 16);
126 ADD_STRING (" A4: ");
127 ADD_MEM (regs[20], 16);
128 ADD_STRING ("\n A5: ");
129 ADD_MEM (regs[21], 16);
130 ADD_STRING (" T8: ");
131 ADD_MEM (regs[22], 16);
132 ADD_STRING (" T9: ");
133 ADD_MEM (regs[23], 16);
134 ADD_STRING ("\n T10: ");
135 ADD_MEM (regs[24], 16);
136 ADD_STRING (" T11: ");
137 ADD_MEM (regs[25], 16);
138 ADD_STRING (" RA: ");
139 ADD_MEM (regs[26], 16);
140 ADD_STRING ("\n T12: ");
141 ADD_MEM (regs[27], 16);
142 ADD_STRING (" AT: ");
143 ADD_MEM (regs[28], 16);
144 ADD_STRING (" GP: ");
145 ADD_MEM (regs[29], 16);
146 ADD_STRING ("\n SP: ");
147 ADD_MEM (regs[30], 16);
148 ADD_STRING (" PC: ");
149 ADD_MEM (pc, 16);
150
151 char fpregs[31][16];
152 char fpcr[16];
153 for (int i = 0; i < 31; i++)
154 hexvalue (ctx->uc_mcontext.sc_fpregs[i], fpregs[i], 16);
155 hexvalue (ctx->uc_mcontext.sc_fpcr, fpcr, 16);
156
157 ADD_STRING ("\n\n FP0: ");
158 ADD_MEM (fpregs[0], 16);
159 ADD_STRING (" FP1: ");
160 ADD_MEM (fpregs[1], 16);
161 ADD_STRING (" FP2: ");
162 ADD_MEM (fpregs[2], 16);
163 ADD_STRING ("\n FP3: ");
164 ADD_MEM (fpregs[3], 16);
165 ADD_STRING (" FP4: ");
166 ADD_MEM (fpregs[4], 16);
167 ADD_STRING (" FP5: ");
168 ADD_MEM (fpregs[5], 16);
169 ADD_STRING ("\n FP6: ");
170 ADD_MEM (fpregs[6], 16);
171 ADD_STRING (" FP7: ");
172 ADD_MEM (fpregs[7], 16);
173 ADD_STRING (" FP8: ");
174 ADD_MEM (fpregs[8], 16);
175 ADD_STRING ("\n FP9: ");
176 ADD_MEM (fpregs[9], 16);
177 ADD_STRING (" FP10: ");
178 ADD_MEM (fpregs[10], 16);
179 ADD_STRING (" FP11: ");
180 ADD_MEM (fpregs[11], 16);
181 ADD_STRING ("\n FP12: ");
182 ADD_MEM (fpregs[12], 16);
183 ADD_STRING (" FP13: ");
184 ADD_MEM (fpregs[13], 16);
185 ADD_STRING (" FP14: ");
186 ADD_MEM (fpregs[14], 16);
187 ADD_STRING ("\n FP15: ");
188 ADD_MEM (fpregs[15], 16);
189 ADD_STRING (" FP16: ");
190 ADD_MEM (fpregs[16], 16);
191 ADD_STRING (" FP17: ");
192 ADD_MEM (fpregs[17], 16);
193 ADD_STRING ("\n FP18: ");
194 ADD_MEM (fpregs[18], 16);
195 ADD_STRING (" FP19: ");
196 ADD_MEM (fpregs[19], 16);
197 ADD_STRING (" FP20: ");
198 ADD_MEM (fpregs[20], 16);
199 ADD_STRING ("\n FP21: ");
200 ADD_MEM (fpregs[21], 16);
201 ADD_STRING (" FP22: ");
202 ADD_MEM (fpregs[22], 16);
203 ADD_STRING (" FP23: ");
204 ADD_MEM (fpregs[23], 16);
205 ADD_STRING ("\n FP24: ");
206 ADD_MEM (fpregs[24], 16);
207 ADD_STRING (" FP25: ");
208 ADD_MEM (fpregs[25], 16);
209 ADD_STRING (" FP26: ");
210 ADD_MEM (fpregs[26], 16);
211 ADD_STRING ("\n FP27: ");
212 ADD_MEM (fpregs[27], 16);
213 ADD_STRING (" FP28: ");
214 ADD_MEM (fpregs[28], 16);
215 ADD_STRING (" FP29: ");
216 ADD_MEM (fpregs[29], 16);
217 ADD_STRING ("\n FP30: ");
218 ADD_MEM (fpregs[30], 16);
219 ADD_STRING (" FPCR: ");
220 ADD_MEM (fpcr, 16);
221
222 char traparg[3][16];
223 hexvalue (ctx->uc_mcontext.sc_traparg_a0, traparg[0], 16);
224 hexvalue (ctx->uc_mcontext.sc_traparg_a1, traparg[1], 16);
225 hexvalue (ctx->uc_mcontext.sc_traparg_a2, traparg[2], 16);
226 ADD_STRING ("\n\n TA0: ");
227 ADD_MEM (traparg[0], 16);
228 ADD_STRING (" TA1: ");
229 ADD_MEM (traparg[1], 16);
230 ADD_STRING (" TA2: ");
231 ADD_MEM (traparg[2], 16);
232
233 ADD_STRING ("\n");
234
235 /* Write the stuff out. */
236 writev (fd, iov, nr);
237 }
238
239 #define REGISTER_DUMP register_dump (fd, ctx)
240