Print this page
15254 %ymm registers not restored after signal handler
15367 x86 getfpregs() summons corrupting %xmm ghosts
15333 want x86 /proc xregs support (libc_db, libproc, mdb, etc.)
15336 want libc functions for extended ucontext_t
15334 want ps_lwphandle-specific reg routines
15328 FPU_CW_INIT mistreats reserved bit
15335 i86pc fpu_subr.c isn't really platform-specific
15332 setcontext(2) isn't actually noreturn
15331 need <sys/stdalign.h>
Change-Id: I7060aa86042dfb989f77fc3323c065ea2eafa9ad
Conflicts:
usr/src/uts/common/fs/proc/prcontrol.c
usr/src/uts/intel/os/archdep.c
usr/src/uts/intel/sys/ucontext.h
usr/src/uts/intel/syscall/getcontext.c
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/ptools/pflags/pflags.c
+++ new/usr/src/cmd/ptools/pflags/pflags.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
24 24 * Use is subject to license terms.
25 25 */
26 26
27 27 /*
28 28 * Copyright 2015, Joyent, Inc.
29 29 */
30 30
31 31 #include <stdio.h>
32 32 #include <stdio_ext.h>
33 33 #include <stdlib.h>
34 34 #include <unistd.h>
35 35 #include <ctype.h>
36 36 #include <fcntl.h>
37 37 #include <strings.h>
38 38 #include <dirent.h>
39 39 #include <errno.h>
40 40 #include <sys/types.h>
41 41 #include <sys/int_fmtio.h>
42 42 #include <libproc.h>
43 43
44 44 typedef struct look_arg {
45 45 int pflags;
|
↓ open down ↓ |
45 lines elided |
↑ open up ↑ |
46 46 const char *lwps;
47 47 int count;
48 48 } look_arg_t;
49 49
50 50 static int look(char *);
51 51 static int lwplook(look_arg_t *, const lwpstatus_t *, const lwpsinfo_t *);
52 52 static char *prflags(int);
53 53 static char *prwhy(int);
54 54 static char *prwhat(int, int);
55 55 static void dumpregs(const prgregset_t, int);
56 -#if defined(__sparc) && defined(_ILP32)
57 -static void dumpregs_v8p(const prgregset_t, const prxregset_t *, int);
58 -#endif
59 56
60 57 static char *command;
61 58 static struct ps_prochandle *Pr;
62 59
63 60 static int is64; /* Is current process 64-bit? */
64 61 static int rflag; /* Show registers? */
65 62
66 63 #define LWPFLAGS \
67 64 (PR_STOPPED|PR_ISTOP|PR_DSTOP|PR_ASLEEP|PR_PCINVAL|PR_STEP \
68 65 |PR_AGENT|PR_DETACH|PR_DAEMON)
69 66
70 67 #define PROCFLAGS \
71 68 (PR_ISSYS|PR_VFORKP|PR_ORPHAN|PR_NOSIGCHLD|PR_WAITPID \
72 69 |PR_FORK|PR_RLC|PR_KLC|PR_ASYNC|PR_BPTADJ|PR_MSACCT|PR_MSFORK|PR_PTRACE)
73 70
74 71 #define ALLFLAGS (LWPFLAGS|PROCFLAGS)
75 72
76 73 int
77 74 main(int argc, char **argv)
78 75 {
79 76 int rc = 0;
80 77 int errflg = 0;
81 78 int opt;
82 79 struct rlimit rlim;
83 80
84 81 if ((command = strrchr(argv[0], '/')) != NULL)
85 82 command++;
86 83 else
87 84 command = argv[0];
88 85
89 86 /* options */
90 87 while ((opt = getopt(argc, argv, "r")) != EOF) {
91 88 switch (opt) {
92 89 case 'r': /* show registers */
93 90 rflag = 1;
94 91 break;
95 92 default:
96 93 errflg = 1;
97 94 break;
98 95 }
99 96 }
100 97
101 98 argc -= optind;
102 99 argv += optind;
103 100
104 101 if (errflg || argc <= 0) {
105 102 (void) fprintf(stderr,
106 103 "usage:\t%s [-r] { pid | core }[/lwps] ...\n", command);
107 104 (void) fprintf(stderr, " (report process status flags)\n");
108 105 (void) fprintf(stderr, " -r : report registers\n");
109 106 return (2);
110 107 }
111 108
112 109 /*
113 110 * Make sure we'll have enough file descriptors to handle a target
114 111 * that has many many mappings.
115 112 */
116 113 if (getrlimit(RLIMIT_NOFILE, &rlim) == 0) {
117 114 rlim.rlim_cur = rlim.rlim_max;
118 115 (void) setrlimit(RLIMIT_NOFILE, &rlim);
119 116 (void) enable_extended_FILE_stdio(-1, -1);
120 117 }
121 118
122 119 while (argc-- > 0)
123 120 rc += look(*argv++);
124 121
125 122 return (rc);
126 123 }
127 124
128 125 static int
129 126 look(char *arg)
130 127 {
131 128 int gcode;
132 129 int gcode2;
133 130 pstatus_t pstatus;
134 131 psinfo_t psinfo;
135 132 int flags;
136 133 sigset_t sigmask;
137 134 fltset_t fltmask;
138 135 sysset_t entryset;
139 136 sysset_t exitset;
140 137 uint32_t sigtrace, sigtrace1, sigtrace2, fltbits;
141 138 uint32_t sigpend, sigpend1, sigpend2;
142 139 uint32_t *bits;
143 140 char buf[PRSIGBUFSZ];
144 141 look_arg_t lookarg;
145 142
146 143 if ((Pr = proc_arg_xgrab(arg, NULL, PR_ARG_ANY,
147 144 PGRAB_RETAIN | PGRAB_FORCE | PGRAB_RDONLY | PGRAB_NOSTOP, &gcode,
148 145 &lookarg.lwps)) == NULL) {
149 146 if (gcode == G_NOPROC &&
150 147 proc_arg_psinfo(arg, PR_ARG_PIDS, &psinfo, &gcode2) > 0 &&
151 148 psinfo.pr_nlwp == 0) {
152 149 (void) printf("%d:\t<defunct>\n\n", (int)psinfo.pr_pid);
153 150 return (0);
154 151 }
155 152 (void) fprintf(stderr, "%s: cannot examine %s: %s\n",
156 153 command, arg, Pgrab_error(gcode));
157 154 return (1);
158 155 }
159 156
160 157 (void) memcpy(&pstatus, Pstatus(Pr), sizeof (pstatus_t));
161 158 (void) memcpy(&psinfo, Ppsinfo(Pr), sizeof (psinfo_t));
162 159 proc_unctrl_psinfo(&psinfo);
163 160
164 161 if (psinfo.pr_nlwp == 0) {
165 162 (void) printf("%d:\t<defunct>\n\n", (int)psinfo.pr_pid);
166 163 Prelease(Pr, PRELEASE_RETAIN);
167 164 return (0);
168 165 }
169 166
170 167 is64 = (pstatus.pr_dmodel == PR_MODEL_LP64);
171 168
172 169 sigmask = pstatus.pr_sigtrace;
173 170 fltmask = pstatus.pr_flttrace;
174 171 entryset = pstatus.pr_sysentry;
175 172 exitset = pstatus.pr_sysexit;
176 173
177 174 if (Pstate(Pr) == PS_DEAD) {
178 175 (void) printf("core '%s' of %d:\t%.70s\n",
179 176 arg, (int)psinfo.pr_pid, psinfo.pr_psargs);
180 177 } else {
181 178 (void) printf("%d:\t%.70s\n",
182 179 (int)psinfo.pr_pid, psinfo.pr_psargs);
183 180 }
184 181
185 182 (void) printf("\tdata model = %s", is64? "_LP64" : "_ILP32");
186 183 if ((flags = (pstatus.pr_flags & PROCFLAGS)) != 0)
187 184 (void) printf(" flags = %s", prflags(flags));
188 185 (void) printf("\n");
189 186
190 187 fltbits = *((uint32_t *)&fltmask);
191 188 if (fltbits)
192 189 (void) printf("\tflttrace = 0x%.8x\n", fltbits);
193 190
194 191 #if (MAXSIG > 2 * 32) && (MAXSIG <= 3 * 32) /* assumption */
195 192 sigtrace = *((uint32_t *)&sigmask);
196 193 sigtrace1 = *((uint32_t *)&sigmask + 1);
197 194 sigtrace2 = *((uint32_t *)&sigmask + 2);
198 195 #else
199 196 #error "fix me: MAXSIG out of bounds"
200 197 #endif
201 198 if (sigtrace | sigtrace1 | sigtrace2)
202 199 (void) printf("\tsigtrace = 0x%.8x 0x%.8x 0x%.8x\n\t %s\n",
203 200 sigtrace, sigtrace1, sigtrace2,
204 201 proc_sigset2str(&sigmask, "|", 1, buf, sizeof (buf)));
205 202
206 203 bits = ((uint32_t *)&entryset);
207 204 if (bits[0] | bits[1] | bits[2] | bits[3] |
208 205 bits[4] | bits[5] | bits[6] | bits[7])
209 206 (void) printf(
210 207 "\tentryset = "
211 208 "0x%.8x 0x%.8x 0x%.8x 0x%.8x\n"
212 209 "\t "
213 210 "0x%.8x 0x%.8x 0x%.8x 0x%.8x\n",
214 211 bits[0], bits[1], bits[2], bits[3],
215 212 bits[4], bits[5], bits[6], bits[7]);
216 213
217 214 bits = ((uint32_t *)&exitset);
218 215 if (bits[0] | bits[1] | bits[2] | bits[3] |
219 216 bits[4] | bits[5] | bits[6] | bits[7])
220 217 (void) printf(
221 218 "\texitset = "
222 219 "0x%.8x 0x%.8x 0x%.8x 0x%.8x\n"
223 220 "\t "
224 221 "0x%.8x 0x%.8x 0x%.8x 0x%.8x\n",
225 222 bits[0], bits[1], bits[2], bits[3],
226 223 bits[4], bits[5], bits[6], bits[7]);
227 224
228 225 #if (MAXSIG > 2 * 32) && (MAXSIG <= 3 * 32) /* assumption */
229 226 sigpend = *((uint32_t *)&pstatus.pr_sigpend);
230 227 sigpend1 = *((uint32_t *)&pstatus.pr_sigpend + 1);
231 228 sigpend2 = *((uint32_t *)&pstatus.pr_sigpend + 2);
232 229 #else
233 230 #error "fix me: MAXSIG out of bounds"
234 231 #endif
235 232 if (sigpend | sigpend1 | sigpend2)
236 233 (void) printf("\tsigpend = 0x%.8x,0x%.8x,0x%.8x\n",
237 234 sigpend, sigpend1, sigpend2);
238 235
239 236 lookarg.pflags = pstatus.pr_flags;
240 237 lookarg.count = 0;
241 238 (void) Plwp_iter_all(Pr, (proc_lwp_all_f *)lwplook, &lookarg);
242 239
243 240 if (lookarg.count == 0)
244 241 (void) printf("No matching lwps found");
245 242
246 243 (void) printf("\n");
247 244 Prelease(Pr, PRELEASE_RETAIN);
248 245
249 246 return (0);
250 247 }
251 248
252 249 static int
253 250 lwplook_zombie(const lwpsinfo_t *pip)
254 251 {
255 252 (void) printf(" /%d:\t<defunct>\n", (int)pip->pr_lwpid);
256 253 return (0);
257 254 }
258 255
259 256 static int
260 257 lwplook(look_arg_t *arg, const lwpstatus_t *psp, const lwpsinfo_t *pip)
261 258 {
262 259 int flags;
263 260 uint32_t sighold, sighold1, sighold2;
264 261 uint32_t sigpend, sigpend1, sigpend2;
265 262 psinfo_t ps;
266 263 int cursig;
267 264 char buf[32];
268 265
269 266 if (!proc_lwp_in_set(arg->lwps, pip->pr_lwpid))
270 267 return (0);
271 268
272 269 arg->count++;
273 270
274 271 if (psp == NULL)
275 272 return (lwplook_zombie(pip));
276 273
277 274 /*
278 275 * PR_PCINVAL is just noise if the lwp is not stopped.
279 276 * Don't bother reporting it unless the lwp is stopped.
280 277 */
281 278 flags = psp->pr_flags & LWPFLAGS;
282 279 if (!(flags & PR_STOPPED))
283 280 flags &= ~PR_PCINVAL;
284 281
285 282 (void) printf(" /%d:\tflags = %s", (int)psp->pr_lwpid, prflags(flags));
286 283 if ((flags & PR_ASLEEP) || (psp->pr_syscall &&
287 284 !(arg->pflags & PR_ISSYS))) {
288 285 if (flags & PR_ASLEEP) {
289 286 if ((flags & ~PR_ASLEEP) != 0)
290 287 (void) printf("|");
291 288 (void) printf("ASLEEP");
292 289 }
293 290 if (psp->pr_syscall && !(arg->pflags & PR_ISSYS)) {
294 291 uint_t i;
295 292
296 293 (void) printf(" %s(",
297 294 proc_sysname(psp->pr_syscall, buf, sizeof (buf)));
298 295 for (i = 0; i < psp->pr_nsysarg; i++) {
299 296 if (i != 0)
300 297 (void) printf(",");
301 298 (void) printf("0x%lx", psp->pr_sysarg[i]);
302 299 }
303 300 (void) printf(")");
304 301 }
305 302 }
306 303 (void) printf("\n");
307 304
308 305 if (flags & PR_STOPPED) {
309 306 (void) printf("\twhy = %s", prwhy(psp->pr_why));
310 307 if (psp->pr_why != PR_REQUESTED &&
311 308 psp->pr_why != PR_SUSPENDED)
312 309 (void) printf(" what = %s",
313 310 prwhat(psp->pr_why, psp->pr_what));
314 311 (void) printf("\n");
315 312 }
316 313
317 314 #if (MAXSIG > 2 * 32) && (MAXSIG <= 3 * 32) /* assumption */
318 315 sighold = *((uint32_t *)&psp->pr_lwphold);
319 316 sighold1 = *((uint32_t *)&psp->pr_lwphold + 1);
320 317 sighold2 = *((uint32_t *)&psp->pr_lwphold + 2);
321 318 sigpend = *((uint32_t *)&psp->pr_lwppend);
322 319 sigpend1 = *((uint32_t *)&psp->pr_lwppend + 1);
323 320 sigpend2 = *((uint32_t *)&psp->pr_lwppend + 2);
324 321 #else
325 322 #error "fix me: MAXSIG out of bounds"
326 323 #endif
327 324 cursig = psp->pr_cursig;
328 325
329 326 if (sighold | sighold1 | sighold2)
330 327 (void) printf("\tsigmask = 0x%.8x,0x%.8x,0x%.8x\n",
331 328 sighold, sighold1, sighold2);
332 329 if (sigpend | sigpend1 | sigpend2)
333 330 (void) printf("\tlwppend = 0x%.8x,0x%.8x,0x%.8x\n",
334 331 sigpend, sigpend1, sigpend2);
335 332 if (cursig)
336 333 (void) printf("\tcursig = %s\n",
337 334 proc_signame(cursig, buf, sizeof (buf)));
338 335
339 336 if ((flags & PR_AGENT) &&
340 337 Plwp_getspymaster(Pr, pip->pr_lwpid, &ps) == 0) {
341 338 time_t time = ps.pr_time.tv_sec;
|
↓ open down ↓ |
273 lines elided |
↑ open up ↑ |
342 339 char t[64];
343 340
344 341 (void) strftime(t, sizeof (t), "%F:%H.%M.%S", localtime(&time));
345 342
346 343 (void) printf("\tspymaster = pid %d, \"%s\" at %s\n",
347 344 (int)ps.pr_pid, ps.pr_psargs, t);
348 345 }
349 346
350 347 if (rflag) {
351 348 if (Pstate(Pr) == PS_DEAD || (arg->pflags & PR_STOPPED)) {
352 -#if defined(__sparc) && defined(_ILP32)
353 - /*
354 - * If we're SPARC/32-bit, see if we can get extra
355 - * register state for this lwp. If it's a v8plus
356 - * program, print the 64-bit register values.
357 - */
358 - prxregset_t prx;
359 -
360 - if (Plwp_getxregs(Pr, psp->pr_lwpid, &prx) == 0 &&
361 - prx.pr_type == XR_TYPE_V8P)
362 - dumpregs_v8p(psp->pr_reg, &prx, is64);
363 - else
364 -#endif /* __sparc && _ILP32 */
365 - dumpregs(psp->pr_reg, is64);
366 - } else
349 + dumpregs(psp->pr_reg, is64);
350 + } else {
367 351 (void) printf("\tNot stopped, can't show registers\n");
352 + }
368 353 }
369 354
370 355 return (0);
371 356 }
372 357
373 358 static char *
374 359 prflags(int arg)
375 360 {
376 361 static char code_buf[200];
377 362 char *str = code_buf;
378 363
379 364 if (arg == 0)
380 365 return ("0");
381 366
382 367 if (arg & ~ALLFLAGS)
383 368 (void) sprintf(str, "0x%x", arg & ~ALLFLAGS);
384 369 else
385 370 *str = '\0';
386 371
387 372 /*
388 373 * Display the semi-permanent lwp flags first.
389 374 */
390 375 if (arg & PR_DAEMON) /* daemons are always detached so */
391 376 (void) strcat(str, "|DAEMON");
392 377 else if (arg & PR_DETACH) /* report detach only if non-daemon */
393 378 (void) strcat(str, "|DETACH");
394 379
395 380 if (arg & PR_STOPPED)
396 381 (void) strcat(str, "|STOPPED");
397 382 if (arg & PR_ISTOP)
398 383 (void) strcat(str, "|ISTOP");
399 384 if (arg & PR_DSTOP)
400 385 (void) strcat(str, "|DSTOP");
401 386 #if 0 /* displayed elsewhere */
402 387 if (arg & PR_ASLEEP)
403 388 (void) strcat(str, "|ASLEEP");
404 389 #endif
405 390 if (arg & PR_PCINVAL)
406 391 (void) strcat(str, "|PCINVAL");
407 392 if (arg & PR_STEP)
408 393 (void) strcat(str, "|STEP");
409 394 if (arg & PR_AGENT)
410 395 (void) strcat(str, "|AGENT");
411 396 if (arg & PR_ISSYS)
412 397 (void) strcat(str, "|ISSYS");
413 398 if (arg & PR_VFORKP)
414 399 (void) strcat(str, "|VFORKP");
415 400 if (arg & PR_ORPHAN)
416 401 (void) strcat(str, "|ORPHAN");
417 402 if (arg & PR_NOSIGCHLD)
418 403 (void) strcat(str, "|NOSIGCHLD");
419 404 if (arg & PR_WAITPID)
420 405 (void) strcat(str, "|WAITPID");
421 406 if (arg & PR_FORK)
422 407 (void) strcat(str, "|FORK");
423 408 if (arg & PR_RLC)
424 409 (void) strcat(str, "|RLC");
425 410 if (arg & PR_KLC)
426 411 (void) strcat(str, "|KLC");
427 412 if (arg & PR_ASYNC)
428 413 (void) strcat(str, "|ASYNC");
429 414 if (arg & PR_BPTADJ)
430 415 (void) strcat(str, "|BPTADJ");
431 416 if (arg & PR_MSACCT)
432 417 (void) strcat(str, "|MSACCT");
433 418 if (arg & PR_MSFORK)
434 419 (void) strcat(str, "|MSFORK");
435 420 if (arg & PR_PTRACE)
436 421 (void) strcat(str, "|PTRACE");
437 422
438 423 if (*str == '|')
439 424 str++;
440 425
441 426 return (str);
442 427 }
443 428
444 429 static char *
445 430 prwhy(int why)
446 431 {
447 432 static char buf[20];
448 433 char *str;
449 434
450 435 switch (why) {
451 436 case PR_REQUESTED:
452 437 str = "PR_REQUESTED";
453 438 break;
454 439 case PR_SIGNALLED:
455 440 str = "PR_SIGNALLED";
456 441 break;
457 442 case PR_SYSENTRY:
458 443 str = "PR_SYSENTRY";
459 444 break;
460 445 case PR_SYSEXIT:
461 446 str = "PR_SYSEXIT";
462 447 break;
463 448 case PR_JOBCONTROL:
464 449 str = "PR_JOBCONTROL";
465 450 break;
466 451 case PR_FAULTED:
467 452 str = "PR_FAULTED";
468 453 break;
469 454 case PR_SUSPENDED:
470 455 str = "PR_SUSPENDED";
471 456 break;
472 457 case PR_BRAND:
473 458 str = "PR_BRAND";
474 459 break;
475 460 default:
476 461 str = buf;
477 462 (void) sprintf(str, "%d", why);
478 463 break;
479 464 }
480 465
481 466 return (str);
482 467 }
483 468
484 469 static char *
485 470 prwhat(int why, int what)
486 471 {
487 472 static char buf[32];
488 473 char *str;
489 474
490 475 switch (why) {
491 476 case PR_SIGNALLED:
492 477 case PR_JOBCONTROL:
493 478 str = proc_signame(what, buf, sizeof (buf));
494 479 break;
495 480 case PR_SYSENTRY:
496 481 case PR_SYSEXIT:
497 482 str = proc_sysname(what, buf, sizeof (buf));
498 483 break;
499 484 case PR_FAULTED:
|
↓ open down ↓ |
122 lines elided |
↑ open up ↑ |
500 485 str = proc_fltname(what, buf, sizeof (buf));
501 486 break;
502 487 default:
503 488 (void) sprintf(str = buf, "%d", what);
504 489 break;
505 490 }
506 491
507 492 return (str);
508 493 }
509 494
510 -#if defined(__sparc)
511 -static const char * const regname[NPRGREG] = {
512 - " %g0", " %g1", " %g2", " %g3", " %g4", " %g5", " %g6", " %g7",
513 - " %o0", " %o1", " %o2", " %o3", " %o4", " %o5", " %sp", " %o7",
514 - " %l0", " %l1", " %l2", " %l3", " %l4", " %l5", " %l6", " %l7",
515 - " %i0", " %i1", " %i2", " %i3", " %i4", " %i5", " %fp", " %i7",
516 -#ifdef __sparcv9
517 - "%ccr", " %pc", "%npc", " %y", "%asi", "%fprs"
518 -#else
519 - "%psr", " %pc", "%npc", " %y", "%wim", "%tbr"
520 -#endif
521 -};
522 -#endif /* __sparc */
523 -
524 495 #if defined(__amd64)
525 496 static const char * const regname[NPRGREG] = {
526 497 "%r15", "%r14", "%r13", "%r12", "%r11", "%r10", " %r9", " %r8",
527 498 "%rdi", "%rsi", "%rbp", "%rbx", "%rdx", "%rcx", "%rax", "%trapno",
528 499 "%err", "%rip", " %cs", "%rfl", "%rsp", " %ss", " %fs", " %gs",
529 500 " %es", " %ds", "%fsbase", "%gsbase"
530 501 };
531 502
532 503 static const char * const regname32[NPRGREG32] = {
533 504 " %gs", " %fs", " %es", " %ds", "%edi", "%esi", "%ebp", "%esp",
534 505 "%ebx", "%edx", "%ecx", "%eax", "%trapno", "%err", "%eip", " %cs",
535 506 "%efl", "%uesp", " %ss"
536 507 };
537 508
538 509 /* XX64 Do we want to expose this through libproc */
539 510 void
540 511 prgregset_n_to_32(const prgreg_t *src, prgreg32_t *dst)
541 512 {
542 513 bzero(dst, NPRGREG32 * sizeof (prgreg32_t));
543 514 dst[GS] = src[REG_GS];
544 515 dst[FS] = src[REG_FS];
545 516 dst[DS] = src[REG_DS];
546 517 dst[ES] = src[REG_ES];
547 518 dst[EDI] = src[REG_RDI];
548 519 dst[ESI] = src[REG_RSI];
549 520 dst[EBP] = src[REG_RBP];
550 521 dst[EBX] = src[REG_RBX];
551 522 dst[EDX] = src[REG_RDX];
552 523 dst[ECX] = src[REG_RCX];
553 524 dst[EAX] = src[REG_RAX];
554 525 dst[TRAPNO] = src[REG_TRAPNO];
555 526 dst[ERR] = src[REG_ERR];
556 527 dst[EIP] = src[REG_RIP];
557 528 dst[CS] = src[REG_CS];
558 529 dst[EFL] = src[REG_RFL];
559 530 dst[UESP] = src[REG_RSP];
560 531 dst[SS] = src[REG_SS];
561 532 }
562 533
563 534 #elif defined(__i386)
564 535 static const char * const regname[NPRGREG] = {
565 536 " %gs", " %fs", " %es", " %ds", "%edi", "%esi", "%ebp", "%esp",
566 537 "%ebx", "%edx", "%ecx", "%eax", "%trapno", "%err", "%eip", " %cs",
567 538 "%efl", "%uesp", " %ss"
568 539 };
569 540 #endif /* __i386 */
570 541
571 542 #if defined(__amd64) && defined(_LP64)
572 543 static void
573 544 dumpregs32(const prgregset_t reg)
574 545 {
575 546 prgregset32_t reg32;
576 547 int i;
577 548
578 549 prgregset_n_to_32(reg, reg32);
579 550
580 551 for (i = 0; i < NPRGREG32; i++) {
581 552 (void) printf(" %s = 0x%.8X",
582 553 regname32[i], reg32[i]);
583 554 if ((i+1) % 4 == 0)
584 555 (void) putchar('\n');
585 556 }
586 557 if (i % 4 != 0)
587 558 (void) putchar('\n');
588 559 }
589 560 #endif
590 561
591 562 static void
592 563 dumpregs(const prgregset_t reg, int is64)
593 564 {
594 565 int width = is64? 16 : 8;
595 566 int cols = is64? 2 : 4;
596 567 int i;
597 568
598 569 #if defined(__amd64) && defined(_LP64)
599 570 if (!is64) {
600 571 dumpregs32(reg);
601 572 return;
602 573 }
603 574 #endif
|
↓ open down ↓ |
70 lines elided |
↑ open up ↑ |
604 575
605 576 for (i = 0; i < NPRGREG; i++) {
606 577 (void) printf(" %s = 0x%.*lX",
607 578 regname[i], width, (long)reg[i]);
608 579 if ((i+1) % cols == 0)
609 580 (void) putchar('\n');
610 581 }
611 582 if (i % cols != 0)
612 583 (void) putchar('\n');
613 584 }
614 -
615 -#if defined(__sparc) && defined(_ILP32)
616 -static void
617 -dumpregs_v8p(const prgregset_t reg, const prxregset_t *xreg, int is64)
618 -{
619 - static const uint32_t zero[8] = { 0 };
620 - int gr, xr, cols = 2;
621 - uint64_t xval;
622 -
623 - if (memcmp(xreg->pr_un.pr_v8p.pr_xg, zero, sizeof (zero)) == 0 &&
624 - memcmp(xreg->pr_un.pr_v8p.pr_xo, zero, sizeof (zero)) == 0) {
625 - dumpregs(reg, is64);
626 - return;
627 - }
628 -
629 - for (gr = R_G0, xr = XR_G0; gr <= R_G7; gr++, xr++) {
630 - xval = (uint64_t)xreg->pr_un.pr_v8p.pr_xg[xr] << 32 |
631 - (uint64_t)(uint32_t)reg[gr];
632 - (void) printf(" %s = 0x%.16" PRIX64, regname[gr], xval);
633 - if ((gr + 1) % cols == 0)
634 - (void) putchar('\n');
635 - }
636 -
637 - for (gr = R_O0, xr = XR_O0; gr <= R_O7; gr++, xr++) {
638 - xval = (uint64_t)xreg->pr_un.pr_v8p.pr_xo[xr] << 32 |
639 - (uint64_t)(uint32_t)reg[gr];
640 - (void) printf(" %s = 0x%.16" PRIX64, regname[gr], xval);
641 - if ((gr + 1) % cols == 0)
642 - (void) putchar('\n');
643 - }
644 -
645 - for (gr = R_L0; gr < NPRGREG; gr++) {
646 - (void) printf(" %s = 0x%.8lX",
647 - regname[gr], (long)reg[gr]);
648 - if ((gr + 1) % cols == 0)
649 - (void) putchar('\n');
650 - }
651 -
652 - if (gr % cols != 0)
653 - (void) putchar('\n');
654 -}
655 -#endif /* __sparc && _ILP32 */
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX