diff options
| author | Adhemerval Zanella <adhemerval.zanella@linaro.org> | 2021-12-20 08:41:55 -0300 |
|---|---|---|
| committer | Adhemerval Zanella <adhemerval.zanella@linaro.org> | 2022-01-06 07:59:49 -0300 |
| commit | 65ccd641bacea33be23d51da737c2de7543d0f5e (patch) | |
| tree | a3dbd16426b4a51dcb8450ede9d47c5a90e58a66 /sysdeps | |
| parent | c1fc366ec9e78e17ad3e2ecdb4c4cc662decc32b (diff) | |
| download | glibc-65ccd641bacea33be23d51da737c2de7543d0f5e.tar.gz glibc-65ccd641bacea33be23d51da737c2de7543d0f5e.tar.xz glibc-65ccd641bacea33be23d51da737c2de7543d0f5e.zip | |
debug: Remove catchsegv and libSegfault (BZ #14913)
Trapping SIGSEGV within the process is error-prone, adds security issues, and modern analysis design tends to happen out of the process (either by attaching a debugger or by post-mortem analysis). The libSegfault also has some design problems, it uses non async-signal-safe function (backtrace) on signal handler. There are multiple alternatives if users do want to use similar functionality, such as sigsegv gnulib module or libsegfault.
Diffstat (limited to 'sysdeps')
18 files changed, 0 insertions, 3100 deletions
diff --git a/sysdeps/generic/register-dump.h b/sysdeps/generic/register-dump.h deleted file mode 100644 index 9d6b2a3b0b..0000000000 --- a/sysdeps/generic/register-dump.h +++ /dev/null @@ -1,19 +0,0 @@ -/* Dump registers. - Copyright (C) 1998-2022 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; if not, see - <https://www.gnu.org/licenses/>. */ - -/* In general we cannot do anything. */ diff --git a/sysdeps/powerpc/powerpc32/register-dump.h b/sysdeps/powerpc/powerpc32/register-dump.h deleted file mode 100644 index ea1335fd02..0000000000 --- a/sysdeps/powerpc/powerpc32/register-dump.h +++ /dev/null @@ -1,120 +0,0 @@ -/* Dump registers. - Copyright (C) 1998-2022 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; if not, see - <https://www.gnu.org/licenses/>. */ - -#include <sys/uio.h> -#include <_itoa.h> - -/* This prints out the information in the following form: */ -static const char dumpform[] = "\ -Register dump:\n\ -fp0-3: 0000030%0000031% 0000032%0000033% 0000034%0000035% 0000036%0000037%\n\ -fp4-7: 0000038%0000039% 000003a%000003b% 000003c%000003d% 000003e%000003f%\n\ -fp8-11: 0000040%0000041% 0000042%0000043% 0000044%0000045% 0000046%0000047%\n\ -fp12-15: 0000048%0000049% 000004a%000004b% 000004c%000004d% 000004e%000004f%\n\ -fp16-19: 0000050%0000051% 0000052%0000053% 0000054%0000055% 0000056%0000057%\n\ -fp20-23: 0000058%0000059% 000005a%000005b% 000005c%000005d% 000005e%000005f%\n\ -fp24-27: 0000060%0000061% 0000062%0000063% 0000064%0000065% 0000066%0000067%\n\ -fp28-31: 0000068%0000069% 000006a%000006b% 000006c%000006d% 000006e%000006f%\n\ -r0 =0000000% sp =0000001% r2 =0000002% r3 =0000003% trap=0000028%\n\ -r4 =0000004% r5 =0000005% r6 =0000006% r7 =0000007% sr0=0000020% sr1=0000021%\n\ -r8 =0000008% r9 =0000009% r10=000000a% r11=000000b% dar=0000029% dsi=000002a%\n\ -r12=000000c% r13=000000d% r14=000000e% r15=000000f% r3*=0000022%\n\ -r16=0000010% r17=0000011% r18=0000012% r19=0000013%\n\ -r20=0000014% r21=0000015% r22=0000016% r23=0000017% lr=0000024% xer=0000025%\n\ -r24=0000018% r25=0000019% r26=000001a% r27=000001b% mq=0000027% ctr=0000023%\n\ -r28=000001c% r29=000001d% r30=000001e% r31=000001f% fscr=0000071% ccr=0000026%\n\ -"; - -/* Most of the fields are self-explanatory. 'sr0' is the next - instruction to execute, from SRR0, which may have some relationship - with the instruction that caused the exception. 'r3*' is the value - that will be returned in register 3 when the current system call - returns. 'sr1' is SRR1, bits 16-31 of which are copied from the MSR: - - 16 - External interrupt enable - 17 - Privilege level (1=user, 0=supervisor) - 18 - FP available - 19 - Machine check enable (if clear, processor locks up on machine check) - 20 - FP exception mode bit 0 (FP exceptions recoverable) - 21 - Single-step trace enable - 22 - Branch trace enable - 23 - FP exception mode bit 1 - 25 - exception prefix (if set, exceptions are taken from 0xFFFnnnnn, - otherwise from 0x000nnnnn). - 26 - Instruction address translation enabled. - 27 - Data address translation enabled. - 30 - Exception is recoverable (otherwise, don't try to return). - 31 - Little-endian mode enable. - - 'Trap' is the address of the exception: - - 00200 - Machine check exception (memory parity error, for instance) - 00300 - Data access exception (memory not mapped, see dsisr for why) - 00400 - Instruction access exception (memory not mapped) - 00500 - External interrupt - 00600 - Alignment exception (see dsisr for more information) - 00700 - Program exception (illegal/trap instruction, FP exception) - 00800 - FP unavailable (should not be seen by user code) - 00900 - Decrementer exception (for instance, SIGALRM) - 00A00 - I/O controller interface exception - 00C00 - System call exception (for instance, kill(3)). - 00E00 - FP assist exception (optional FP instructions, etc.) - - 'dar' is the memory location, for traps 00300, 00400, 00600, 00A00. - 'dsisr' has the following bits under trap 00300: - 0 - direct-store error exception - 1 - no page table entry for page - 4 - memory access not permitted - 5 - trying to access I/O controller space or using lwarx/stwcx on - non-write-cached memory - 6 - access was store - 9 - data access breakpoint hit - 10 - segment table search failed to find translation (64-bit ppcs only) - 11 - I/O controller instruction not permitted - For trap 00400, the same bits are set in SRR1 instead. - For trap 00600, bits 12-31 of the DSISR set to allow emulation of - the instruction without actually having to read it from memory. -*/ - -#define xtoi(x) (x >= 'a' ? x + 10 - 'a' : x - '0') - -static void -register_dump (int fd, struct sigcontext *ctx) -{ - char buffer[sizeof (dumpform)]; - char *bufferpos; - unsigned regno; - unsigned *regs = (unsigned *)(ctx->regs); - - memcpy(buffer, dumpform, sizeof (dumpform)); - - /* Generate the output. */ - while ((bufferpos = memchr (buffer, '%', sizeof (dumpform)))) - { - regno = xtoi (bufferpos[-1]) | xtoi (bufferpos[-2]) << 4; - memset (bufferpos-2, '0', 3); - _itoa_word (regs[regno], bufferpos+1, 16, 0); - } - - /* Write the output. */ - write (fd, buffer, sizeof (buffer) - 1); -} - - -#define REGISTER_DUMP \ - register_dump (fd, ctx) diff --git a/sysdeps/powerpc/powerpc64/register-dump.h b/sysdeps/powerpc/powerpc64/register-dump.h deleted file mode 100644 index 73454e5d34..0000000000 --- a/sysdeps/powerpc/powerpc64/register-dump.h +++ /dev/null @@ -1,124 +0,0 @@ -/* Dump registers. - Copyright (C) 1998-2022 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; if not, see - <https://www.gnu.org/licenses/>. */ - -#include <sys/uio.h> -#include <_itoa.h> - -/* This prints out the information in the following form: */ -static const char dumpform[] = "\ -Register dump:\n\ -sr0=000000000000020% sr1=000000000000021% dar=000000000000029% dsi=000002a%\n\ -lr=000000000000024% ctr=000000000000023% gr3*=000000000000022% trap=0000028%\n\ -ccr=0000026% xer=0000025%\n\ -gr0-3: 000000000000000% 000000000000001% 000000000000002% 000000000000003%\n\ -gr4-7: 000000000000004% 000000000000005% 000000000000006% 000000000000007%\n\ -gr8-11: 000000000000008% 000000000000009% 00000000000000a% 00000000000000b%\n\ -gr12-15: 00000000000000c% 00000000000000d% 00000000000000e% 00000000000000f%\n\ -gr16-19: 000000000000010% 000000000000011% 000000000000012% 000000000000013%\n\ -gr20-23: 000000000000014% 000000000000015% 000000000000016% 000000000000017%\n\ -gr24-27: 000000000000018% 000000000000019% 00000000000001a% 00000000000001b%\n\ -gr28-31: 00000000000001c% 00000000000001d% 00000000000001e% 00000000000001f%\n\ -fscr=000000000000050%\n\ -fp0-3: 000000000000030% 000000000000031% 000000000000032% 000000000000033%\n\ -fp4-7: 000000000000034% 000000000000035% 000000000000036% 000000000000037%\n\ -fp8-11: 000000000000038% 000000000000038% 00000000000003a% 00000000000003b%\n\ -fp12-15: 00000000000003c% 00000000000003d% 00000000000003e% 00000000000003f%\n\ -fp16-19: 000000000000040% 000000000000041% 000000000000042% 000000000000043%\n\ -fp20-23: 000000000000044% 000000000000045% 000000000000046% 000000000000047%\n\ -fp24-27: 000000000000048% 000000000000049% 00000000000004a% 00000000000004b%\n\ -fp28-31: 00000000000004c% 00000000000004d% 00000000000004e% 00000000000004f%\n\ -"; - -/* Most of the fields are self-explanatory. 'sr0' is the next - instruction to execute, from SRR0, which may have some relationship - with the instruction that caused the exception. 'r3*' is the value - that will be returned in register 3 when the current system call - returns. 'sr1' is SRR1, bits 16-31 of which are copied from the MSR: - - 16 - External interrupt enable - 17 - Privilege level (1=user, 0=supervisor) - 18 - FP available - 19 - Machine check enable (if clear, processor locks up on machine check) - 20 - FP exception mode bit 0 (FP exceptions recoverable) - 21 - Single-step trace enable - 22 - Branch trace enable - 23 - FP exception mode bit 1 - 25 - exception prefix (if set, exceptions are taken from 0xFFFnnnnn, - otherwise from 0x000nnnnn). - 26 - Instruction address translation enabled. - 27 - Data address translation enabled. - 30 - Exception is recoverable (otherwise, don't try to return). - 31 - Little-endian mode enable. - - 'Trap' is the address of the exception: - - 00200 - Machine check exception (memory parity error, for instance) - 00300 - Data access exception (memory not mapped, see dsisr for why) - 00400 - Instruction access exception (memory not mapped) - 00500 - External interrupt - 00600 - Alignment exception (see dsisr for more information) - 00700 - Program exception (illegal/trap instruction, FP exception) - 00800 - FP unavailable (should not be seen by user code) - 00900 - Decrementer exception (for instance, SIGALRM) - 00A00 - I/O controller interface exception - 00C00 - System call exception (for instance, kill(3)). - 00E00 - FP assist exception (optional FP instructions, etc.) - - 'dar' is the memory location, for traps 00300, 00400, 00600, 00A00. - 'dsisr' has the following bits under trap 00300: - 0 - direct-store error exception - 1 - no page table entry for page - 4 - memory access not permitted - 5 - trying to access I/O controller space or using lwarx/stwcx on - non-write-cached memory - 6 - access was store - 9 - data access breakpoint hit - 10 - segment table search failed to find translation (64-bit ppcs only) - 11 - I/O controller instruction not permitted - For trap 00400, the same bits are set in SRR1 instead. - For trap 00600, bits 12-31 of the DSISR set to allow emulation of - the instruction without actually having to read it from memory. -*/ - -#define xtoi(x) (x >= 'a' ? x + 10 - 'a' : x - '0') - -static void -register_dump (int fd, struct sigcontext *ctx) -{ - char buffer[sizeof (dumpform)]; - char *bufferpos; - unsigned regno; - unsigned long *regs = (unsigned long *)(ctx->regs); - - memcpy(buffer, dumpform, sizeof (dumpform)); - - /* Generate the output. */ - while ((bufferpos = memchr (buffer, '%', sizeof (dumpform)))) - { - regno = xtoi (bufferpos[-1]) | xtoi (bufferpos[-2]) << 4; - memset (bufferpos-2, '0', 3); - _itoa_word (regs[regno], bufferpos+1, 16, 0); - } - - /* Write the output. */ - write (fd, buffer, sizeof (buffer) - 1); -} - - -#define REGISTER_DUMP \ - register_dump (fd, ctx) diff --git a/sysdeps/unix/sysv/linux/alpha/register-dump.h b/sysdeps/unix/sysv/linux/alpha/register-dump.h deleted file mode 100644 index 5ecdd0c2ac..0000000000 --- a/sysdeps/unix/sysv/linux/alpha/register-dump.h +++ /dev/null @@ -1,239 +0,0 @@ -/* Dump registers. - Copyright (C) 2004-2022 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library. If not, see - <https://www.gnu.org/licenses/>. */ - -#include <string.h> -#include <ucontext.h> -#include <sys/uio.h> -#include <_itoa.h> - -/* We will print the register dump in this format: - - V0: XXXXXXXXXXXXXXXX T0: XXXXXXXXXXXXXXXX T1: XXXXXXXXXXXXXXXX - T2: XXXXXXXXXXXXXXXX T3: XXXXXXXXXXXXXXXX T4: XXXXXXXXXXXXXXXX - T5: XXXXXXXXXXXXXXXX T6: XXXXXXXXXXXXXXXX T7: XXXXXXXXXXXXXXXX - S0: XXXXXXXXXXXXXXXX S1: XXXXXXXXXXXXXXXX S2: XXXXXXXXXXXXXXXX - S3: XXXXXXXXXXXXXXXX S4: XXXXXXXXXXXXXXXX S5: XXXXXXXXXXXXXXXX - S6: XXXXXXXXXXXXXXXX A0: XXXXXXXXXXXXXXXX A1: XXXXXXXXXXXXXXXX - A2: XXXXXXXXXXXXXXXX A3: XXXXXXXXXXXXXXXX A4: XXXXXXXXXXXXXXXX - A5: XXXXXXXXXXXXXXXX T8: XXXXXXXXXXXXXXXX T9: XXXXXXXXXXXXXXXX - T10: XXXXXXXXXXXXXXXX T11: XXXXXXXXXXXXXXXX RA: XXXXXXXXXXXXXXXX - T12: XXXXXXXXXXXXXXXX AT: XXXXXXXXXXXXXXXX GP: XXXXXXXXXXXXXXXX - SP: XXXXXXXXXXXXXXXX PC: XXXXXXXXXXXXXXXX - - FP0: XXXXXXXXXXXXXXXX FP1: XXXXXXXXXXXXXXXX FP2: XXXXXXXXXXXXXXXX - FP3: XXXXXXXXXXXXXXXX FP4: XXXXXXXXXXXXXXXX FP5: XXXXXXXXXXXXXXXX - FP6: XXXXXXXXXXXXXXXX FP7: XXXXXXXXXXXXXXXX FP8: XXXXXXXXXXXXXXXX - FP9: XXXXXXXXXXXXXXXX FP10: XXXXXXXXXXXXXXXX FP11: XXXXXXXXXXXXXXXX - FP12: XXXXXXXXXXXXXXXX FP13: XXXXXXXXXXXXXXXX FP14: XXXXXXXXXXXXXXXX - FP15: XXXXXXXXXXXXXXXX FP16: XXXXXXXXXXXXXXXX FP17: XXXXXXXXXXXXXXXX - FP18: XXXXXXXXXXXXXXXX FP19: XXXXXXXXXXXXXXXX FP20: XXXXXXXXXXXXXXXX - FP21: XXXXXXXXXXXXXXXX FP22: XXXXXXXXXXXXXXXX FP23: XXXXXXXXXXXXXXXX - FP24: XXXXXXXXXXXXXXXX FP25: XXXXXXXXXXXXXXXX FP26: XXXXXXXXXXXXXXXX - FP27: XXXXXXXXXXXXXXXX FP28: XXXXXXXXXXXXXXXX FP29: XXXXXXXXXXXXXXXX - FP30: XXXXXXXXXXXXXXXX FPCR: XXXXXXXXXXXXXXXX - - TA0: XXXXXXXXXXXXXXXX TA1: XXXXXXXXXXXXXXXX TA2: XXXXXXXXXXXXXXXX -*/ - -static void -hexvalue (unsigned long int value, char *buf, size_t len) -{ - char *cp = _itoa_word (value, buf + len, 16, 0); - while (cp > buf) - *--cp = '0'; -} - -static void -register_dump (int fd, struct ucontext_t *ctx) -{ - struct iovec iov[31 * 2 + 2 /* REGS + PC. */ - + 31 * 2 + 2 /* FREGS + FPCR. */ - + (3 * 2) /* TA0, TA1, TA3. */ - + 1 /* '\n'. */]; - size_t nr = 0; - -#define ADD_STRING(str) \ - iov[nr].iov_base = (char *) str; \ - iov[nr].iov_len = strlen (str); \ - ++nr -#define ADD_MEM(str, len) \ - iov[nr].iov_base = str; \ - iov[nr].iov_len = len; \ - ++nr - - char regs[31][16]; - char pc[16]; - for (int i = 0; i < 31; i++) - hexvalue (ctx->uc_mcontext.sc_regs[i], regs[i], 16); - hexvalue (ctx->uc_mcontext.sc_pc, pc, 16); - - /* Generate the output. */ - ADD_STRING ("Register dump:\n\n V0: "); - ADD_MEM (regs[0], 16); - ADD_STRING (" T0: "); - ADD_MEM (regs[1], 16); - ADD_STRING (" T1: "); - ADD_MEM (regs[2], 16); - ADD_STRING ("\n T2: "); - ADD_MEM (regs[3], 16); - ADD_STRING (" T3: "); - ADD_MEM (regs[4], 16); - ADD_STRING (" T4: "); - ADD_MEM (regs[5], 16); - ADD_STRING ("\n T5: "); - ADD_MEM (regs[6], 16); - ADD_STRING (" T6: "); - ADD_MEM (regs[7], 16); - ADD_STRING (" T7: "); - ADD_MEM (regs[8], 16); - ADD_STRING ("\n S0: "); - ADD_MEM (regs[9], 16); - ADD_STRING (" S1: "); - ADD_MEM (regs[10], 16); - ADD_STRING (" S2: "); - ADD_MEM (regs[11], 16); - ADD_STRING ("\n S3: "); - ADD_MEM (regs[12], 16); - ADD_STRING (" S4: "); - ADD_MEM (regs[13], 16); - ADD_STRING (" S5: "); - ADD_MEM (regs[14], 16); - ADD_STRING ("\n S6: "); - ADD_MEM (regs[15], 16); - ADD_STRING (" A0: "); - ADD_MEM (regs[16], 16); - ADD_STRING (" A1: "); - ADD_MEM (regs[17], 16); - ADD_STRING ("\n A2: "); - ADD_MEM (regs[18], 16); - ADD_STRING (" A3: "); - ADD_MEM (regs[19], 16); - ADD_STRING (" A4: "); - ADD_MEM (regs[20], 16); - ADD_STRING ("\n A5: "); - ADD_MEM (regs[21], 16); - ADD_STRING (" T8: "); - ADD_MEM (regs[22], 16); - ADD_STRING (" T9: "); - ADD_MEM (regs[23], 16); - ADD_STRING ("\n T10: "); - ADD_MEM (regs[24], 16); - ADD_STRING (" T11: "); - ADD_MEM (regs[25], 16); - ADD_STRING (" RA: "); - ADD_MEM (regs[26], 16); - ADD_STRING ("\n T12: "); - ADD_MEM (regs[27], 16); - ADD_STRING (" AT: "); - ADD_MEM (regs[28], 16); - ADD_STRING (" GP: "); - ADD_MEM (regs[29], 16); - ADD_STRING ("\n SP: "); - ADD_MEM (regs[30], 16); - ADD_STRING (" PC: "); - ADD_MEM (pc, 16); - - char fpregs[31][16]; - char fpcr[16]; - for (int i = 0; i < 31; i++) - hexvalue (ctx->uc_mcontext.sc_fpregs[i], fpregs[i], 16); - hexvalue (ctx->uc_mcontext.sc_fpcr, fpcr, 16); - - ADD_STRING ("\n\n FP0: "); - ADD_MEM (fpregs[0], 16); - ADD_STRING (" FP1: "); - ADD_MEM (fpregs[1], 16); - ADD_STRING (" FP2: "); - ADD_MEM (fpregs[2], 16); - ADD_STRING ("\n FP3: "); - ADD_MEM (fpregs[3], 16); - ADD_STRING (" FP4: "); - ADD_MEM (fpregs[4], 16); - ADD_STRING (" FP5: "); - ADD_MEM (fpregs[5], 16); - ADD_STRING ("\n FP6: "); - ADD_MEM (fpregs[6], 16); - ADD_STRING (" FP7: "); - ADD_MEM (fpregs[7], 16); - ADD_STRING (" FP8: "); - ADD_MEM (fpregs[8], 16); - ADD_STRING ("\n FP9: "); - ADD_MEM (fpregs[9], 16); - ADD_STRING (" FP10: "); - ADD_MEM (fpregs[10], 16); - ADD_STRING (" FP11: "); - ADD_MEM (fpregs[11], 16); - ADD_STRING ("\n FP12: "); - ADD_MEM (fpregs[12], 16); - ADD_STRING (" FP13: "); - ADD_MEM (fpregs[13], 16); - ADD_STRING (" FP14: "); - ADD_MEM (fpregs[14], 16); - ADD_STRING ("\n FP15: "); - ADD_MEM (fpregs[15], 16); - ADD_STRING (" FP16: "); - ADD_MEM (fpregs[16], 16); - ADD_STRING (" FP17: "); - ADD_MEM (fpregs[17], 16); - ADD_STRING ("\n FP18: "); - ADD_MEM (fpregs[18], 16); - ADD_STRING (" FP19: "); - ADD_MEM (fpregs[19], 16); - ADD_STRING (" FP20: "); - ADD_MEM (fpregs[20], 16); - ADD_STRING ("\n FP21: "); - ADD_MEM (fpregs[21], 16); - ADD_STRING (" FP22: "); - ADD_MEM (fpregs[22], 16); - ADD_STRING (" FP23: "); - ADD_MEM (fpregs[23], 16); - ADD_STRING ("\n FP24: "); - ADD_MEM (fpregs[24], 16); - ADD_STRING (" FP25: "); - ADD_MEM (fpregs[25], 16); - ADD_STRING (" FP26: "); - ADD_MEM (fpregs[26], 16); - ADD_STRING ("\n FP27: "); - ADD_MEM (fpregs[27], 16); - ADD_STRING (" FP28: "); - ADD_MEM (fpregs[28], 16); - ADD_STRING (" FP29: "); - ADD_MEM (fpregs[29], 16); - ADD_STRING ("\n FP30: "); - ADD_MEM (fpregs[30], 16); - ADD_STRING (" FPCR: "); - ADD_MEM (fpcr, 16); - - char traparg[3][16]; - hexvalue (ctx->uc_mcontext.sc_traparg_a0, traparg[0], 16); - hexvalue (ctx->uc_mcontext.sc_traparg_a1, traparg[1], 16); - hexvalue (ctx->uc_mcontext.sc_traparg_a2, traparg[2], 16); - ADD_STRING ("\n\n TA0: "); - ADD_MEM (traparg[0], 16); - ADD_STRING (" TA1: "); - ADD_MEM (traparg[1], 16); - ADD_STRING (" TA2: "); - ADD_MEM (traparg[2], 16); - - ADD_STRING ("\n"); - - /* Write the stuff out. */ - writev (fd, iov, nr); -} - -#define REGISTER_DUMP register_dump (fd, ctx) diff --git a/sysdeps/unix/sysv/linux/arm/register-dump.h b/sysdeps/unix/sysv/linux/arm/register-dump.h deleted file mode 100644 index 1cbdbe38e1..0000000000 --- a/sysdeps/unix/sysv/linux/arm/register-dump.h +++ /dev/null @@ -1,135 +0,0 @@ -/* Dump registers. - Copyright (C) 1998-2022 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library. If not, see - <https://www.gnu.org/licenses/>. */ - -#include <sys/uio.h> -#include <_itoa.h> -#include <sys/ucontext.h> - -/* We will print the register dump in this format: - - R0: XXXXXXXX R1: XXXXXXXX R2: XXXXXXXX R3: XXXXXXXX - R4: XXXXXXXX R5: XXXXXXXX R6: XXXXXXXX R7: XXXXXXXX - R8: XXXXXXXX R9: XXXXXXXX SL: XXXXXXXX FP: XXXXXXXX - IP: XXXXXXXX SP: XXXXXXXX LR: XXXXXXXX PC: XXXXXXXX - - CPSR: XXXXXXXX - - Trap: XXXXXXXX Error: XXXXXXXX OldMask: XXXXXXXX - Addr: XXXXXXXX - - */ - -static void -hexvalue (unsigned long int value, char *buf, size_t len) -{ - char *cp = _itoa_word (value, buf + len, 16, 0); - while (cp > buf) - *--cp = '0'; -} - -static void -register_dump (int fd, const ucontext_t *ctx) -{ - char regs[21][8]; - struct iovec iov[97]; - size_t nr = 0; - -#define ADD_STRING(str) \ - iov[nr].iov_base = (char *) str; \ - iov[nr].iov_len = strlen (str); \ - ++nr -#define ADD_MEM(str, len) \ - iov[nr].iov_base = str; \ - iov[nr].iov_len = len; \ - ++nr - - /* Generate strings of register contents. */ - hexvalue (ctx->uc_mcontext.arm_r0, regs[0], 8); - hexvalue (ctx->uc_mcontext.arm_r1, regs[1], 8); - hexvalue (ctx->uc_mcontext.arm_r2, regs[2], 8); - hexvalue (ctx->uc_mcontext.arm_r3, regs[3], 8); - hexvalue (ctx->uc_mcontext.arm_r4, regs[4], 8); - hexvalue (ctx->uc_mcontext.arm_r5, regs[5], 8); - hexvalue (ctx->uc_mcontext.arm_r6, regs[6], 8); - hexvalue (ctx->uc_mcontext.arm_r7, regs[7], 8); - hexvalue (ctx->uc_mcontext.arm_r8, regs[8], 8); - hexvalue (ctx->uc_mcontext.arm_r9, regs[9], 8); - hexvalue (ctx->uc_mcontext.arm_r10, regs[10], 8); - hexvalue (ctx->uc_mcontext.arm_fp, regs[11], 8); - hexvalue (ctx->uc_mcontext.arm_ip, regs[12], 8); - hexvalue (ctx->uc_mcontext.arm_sp, regs[13], 8); - hexvalue (ctx->uc_mcontext.arm_lr, regs[14], 8); - hexvalue (ctx->uc_mcontext.arm_pc, regs[15], 8); - hexvalue (ctx->uc_mcontext.arm_cpsr, regs[16], 8); - hexvalue (ctx->uc_mcontext.trap_no, regs[17], 8); - hexvalue (ctx->uc_mcontext.error_code, regs[18], 8); - hexvalue (ctx->uc_mcontext.oldmask, regs[19], 8); - hexvalue (ctx->uc_mcontext.fault_address, regs[20], 8); - - /* Generate the output. */ - ADD_STRING ("Register dump:\n\n R0: "); - ADD_MEM (regs[0], 8); - ADD_STRING (" R1: "); - ADD_MEM (regs[1], 8); - ADD_STRING (" R2: "); - ADD_MEM (regs[2], 8); - ADD_STRING (" R3: "); - ADD_MEM (regs[3], 8); - ADD_STRING ("\n R4: "); - ADD_MEM (regs[4], 8); - ADD_STRING (" R5: "); - ADD_MEM (regs[5], 8); - ADD_STRING (" R6: "); - ADD_MEM (regs[6], 8); - ADD_STRING (" R7: "); - ADD_MEM (regs[7], 8); - ADD_STRING ("\n R8: "); - ADD_MEM (regs[8], 8); - ADD_STRING (" R9: "); - ADD_MEM (regs[9], 8); - ADD_STRING (" SL: "); - ADD_MEM (regs[10], 8); - ADD_STRING (" FP: "); - ADD_MEM (regs[11], 8); - ADD_STRING ("\n IP: "); - ADD_MEM (regs[12], 8); - ADD_STRING (" SP: "); - ADD_MEM (regs[13], 8); - ADD_STRING (" LR: "); - ADD_MEM (regs[14], 8); - ADD_STRING (" PC: "); - ADD_MEM (regs[15], 8); - ADD_STRING ("\n\n CPSR: "); - ADD_MEM (regs[16], 8); - ADD_STRING ("\n\n Trap: "); - ADD_MEM (regs[17], 8); - ADD_STRING (" Error: "); - ADD_MEM (regs[18], 8); - ADD_STRING (" OldMask: "); - ADD_MEM (regs[19], 8); - ADD_STRING ("\n Addr: "); - ADD_MEM (regs[20], 8); - - ADD_STRING ("\n"); - - /* Write the stuff out. */ - writev (fd, iov, nr); -} - - -#define REGISTER_DUMP register_dump (fd, ctx) diff --git a/sysdeps/unix/sysv/linux/csky/register-dump.h b/sysdeps/unix/sysv/linux/csky/register-dump.h deleted file mode 100644 index f313a6979a..0000000000 --- a/sysdeps/unix/sysv/linux/csky/register-dump.h +++ /dev/null @@ -1,190 +0,0 @@ -/* Dump registers. - Copyright (C) 2018-2022 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library. If not, see - <https://www.gnu.org/licenses/>. */ - -#include <sys/uio.h> -#include <_itoa.h> -#include <bits/sigcontext.h> -#include <sys/ucontext.h> - -/* abiv1 register dump in this format: - - PSR: XXXXXXXX PC: XXXXXXXX SP: XXXXXXXX LR: XXXXXXXX - MASK: XXXXXXXX - - A0: XXXXXXXX A1: XXXXXXXX A2: XXXXXXXX A3: XXXXXXXX - R6: XXXXXXXX R7: XXXXXXXX R8: XXXXXXXX R9: XXXXXXXX - R10: XXXXXXXX R11: XXXXXXXX R12: XXXXXXXX R13: XXXXXXXX - R14: XXXXXXXX R1: XXXXXXXX - - abiv2 register dump in this format: - - PSR: XXXXXXXX PC: XXXXXXXX SP: XXXXXXXX LR: XXXXXXXX - MASK: XXXXXXXX - - A0: XXXXXXXX A1: XXXXXXXX A2: XXXXXXXX A3: XXXXXXXX - R4: XXXXXXXX R5: XXXXXXXX R6: XXXXXXXX R7: XXXXXXXX - R8: XXXXXXXX R9: XXXXXXXX R10: XXXXXXXX R11: XXXXXXXX - R12: XXXXXXXX R13: XXXXXXXX R14: XXXXXXXX R15: XXXXXXXX - R16: XXXXXXXX R17: XXXXXXXX R18: XXXXXXXX R19: XXXXXXXX - R20: XXXXXXXX R21: XXXXXXXX R22: XXXXXXXX R23: XXXXXXXX - R24: XXXXXXXX R25: XXXXXXXX R26: XXXXXXXX R27: XXXXXXXX - R28: XXXXXXXX R29: XXXXXXXX R30: XXXXXXXX R31: XXXXXXXX - - */ - -static void -hexvalue (unsigned long int value, char *buf, size_t len) -{ - char *cp = _itoa_word (value, buf + len, 16, 0); - while (cp > buf) - *--cp = '0'; -} - -static void -register_dump (int fd, const struct ucontext_t *ctx) -{ - char regs[35][8]; - struct iovec iov[97]; - size_t nr = 0; - -#define ADD_STRING(str) \ - iov[nr].iov_base = (char *) str; \ - iov[nr].iov_len = strlen (str); \ - ++nr -#define ADD_MEM(str, len) \ - iov[nr].iov_base = str; \ - iov[nr].iov_len = len; \ - ++nr - - /* Generate strings of register contents. */ - hexvalue (ctx->uc_mcontext.__gregs.__sr, regs[0], 8); - hexvalue (ctx->uc_mcontext.__gregs.__pc, regs[1], 8); - hexvalue (ctx->uc_mcontext.__gregs.__usp, regs[2], 8); - hexvalue (ctx->uc_mcontext.__gregs.__lr, regs[3], 8); - hexvalue (ctx->uc_mcontext.__gregs.__a0, regs[4], 8); - hexvalue (ctx->uc_mcontext.__gregs.__a1, regs[5], 8); - hexvalue (ctx->uc_mcontext.__gregs.__a2, regs[6], 8); - hexvalue (ctx->uc_mcontext.__gregs.__a3, regs[7], 8); - hexvalue (ctx->uc_mcontext.__gregs.__regs[0], regs[8], 8); - hexvalue (ctx->uc_mcontext.__gregs.__regs[1], regs[9], 8); - hexvalue (ctx->uc_mcontext.__gregs.__regs[2], regs[10], 8); - hexvalue (ctx->uc_mcontext.__gregs.__regs[3], regs[11], 8); - hexvalue (ctx->uc_mcontext.__gregs.__regs[4], regs[12], 8); - hexvalue (ctx->uc_mcontext.__gregs.__regs[5], regs[13], 8); - hexvalue (ctx->uc_mcontext.__gregs.__regs[6], regs[14], 8); - hexvalue (ctx->uc_mcontext.__gregs.__regs[7], regs[15], 8); - hexvalue (ctx->uc_mcontext.__gregs.__regs[8], regs[16], 8); - hexvalue (ctx->uc_mcontext.__gregs.__regs[9], regs[17], 8); - hexvalue (ctx->uc_mcontext.__gregs.__exregs[0], regs[18], 8); - hexvalue (ctx->uc_mcontext.__gregs.__exregs[1], regs[19], 8); - hexvalue (ctx->uc_mcontext.__gregs.__exregs[2], regs[20], 8); - hexvalue (ctx->uc_mcontext.__gregs.__exregs[3], regs[21], 8); - hexvalue (ctx->uc_mcontext.__gregs.__exregs[4], regs[22], 8); - hexvalue (ctx->uc_mcontext.__gregs.__exregs[5], regs[23], 8); - hexvalue (ctx->uc_mcontext.__gregs.__exregs[6], regs[24], 8); - hexvalue (ctx->uc_mcontext.__gregs.__exregs[7], regs[25], 8); - hexvalue (ctx->uc_mcontext.__gregs.__exregs[8], regs[26], 8); - hexvalue (ctx->uc_mcontext.__gregs.__exregs[9], regs[27], 8); - hexvalue (ctx->uc_mcontext.__gregs.__exregs[10], regs[28], 8); - hexvalue (ctx->uc_mcontext.__gregs.__exregs[11], regs[29], 8); - hexvalue (ctx->uc_mcontext.__gregs.__exregs[12], regs[30], 8); - hexvalue (ctx->uc_mcontext.__gregs.__exregs[13], regs[31], 8); - hexvalue (ctx->uc_mcontext.__gregs.__exregs[14], regs[32], 8); - hexvalue (ctx->uc_mcontext.__gregs.__tls, regs[33], 8); - - /* Generate the output. */ - ADD_STRING ("Register dump:\n\n PSR: "); - ADD_MEM (regs[0], 8); - ADD_STRING (" PC: "); - ADD_MEM (regs[1], 8); - ADD_STRING (" SP: "); - ADD_MEM (regs[2], 8); - ADD_STRING (" LR: "); - ADD_MEM (regs[3], 8); - ADD_STRING ("\n\n A0: "); - ADD_MEM (regs[4], 8); - ADD_STRING (" A1: "); - ADD_MEM (regs[5], 8); - ADD_STRING (" A2: "); - ADD_MEM (regs[6], 8); - ADD_STRING (" A3: "); - ADD_MEM (regs[7], 8); - ADD_STRING ("\n R4: "); - ADD_MEM (regs[8], 8); - ADD_STRING (" R5: "); - ADD_MEM (regs[9], 8); - ADD_STRING (" R6: "); - ADD_MEM (regs[10], 8); - ADD_STRING (" R7: "); - ADD_MEM (regs[11], 8); - ADD_STRING ("\n R8: "); - ADD_MEM (regs[12], 8); - ADD_STRING (" R9: "); - ADD_MEM (regs[13], 8); - ADD_STRING (" R10: "); - ADD_MEM (regs[14], 8); - ADD_STRING (" R11: "); - ADD_MEM (regs[15], 8); - ADD_STRING ("\n R12: "); - ADD_MEM (regs[16], 8); - ADD_STRING (" R13: "); - ADD_MEM (regs[17], 8); - ADD_STRING (" R14: "); - ADD_MEM (regs[2], 8); - ADD_STRING (" R15: "); - ADD_MEM (regs[3], 8); - ADD_STRING ("\n R16: "); - ADD_MEM (regs[18], 8); - ADD_STRING (" R17: "); - ADD_MEM (regs[19], 8); - ADD_STRING (" R18: "); - ADD_MEM (regs[20], 8); - ADD_STRING (" R19: "); - ADD_MEM (regs[21], 8); - ADD_STRING ("\n R20: "); - ADD_MEM (regs[22], 8); - ADD_STRING (" R21: "); - ADD_MEM (regs[23], 8); - ADD_STRING (" R22: "); - ADD_MEM (regs[24], 8); - ADD_STRING (" R23: "); - ADD_MEM (regs[25], 8); - ADD_STRING ("\n R24: "); - ADD_MEM (regs[26], 8); - ADD_STRING (" R25: "); - ADD_MEM (regs[27], 8); - ADD_STRING (" R26: "); - ADD_MEM (regs[28], 8); - ADD_STRING (" R27: "); - ADD_MEM (regs[29], 8); - ADD_STRING ("\n R28: "); - ADD_MEM (regs[30], 8); - ADD_STRING (" R29: "); - ADD_MEM (regs[31], 8); - ADD_STRING (" R30: "); - ADD_MEM (regs[32], 8); - ADD_STRING (" R31: "); - ADD_MEM (regs[33], 8); - - ADD_STRING ("\n"); - - /* Write the stuff out. */ - writev (fd, iov, nr); -} - -#define REGISTER_DUMP register_dump (fd, ctx) diff --git a/sysdeps/unix/sysv/linux/i386/register-dump.h b/sysdeps/unix/sysv/linux/i386/register-dump.h deleted file mode 100644 index 612424b2c5..0000000000 --- a/sysdeps/unix/sysv/linux/i386/register-dump.h +++ /dev/null @@ -1,250 +0,0 @@ -/* Dump registers. - Copyright (C) 1998-2022 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; if not, see - <https://www.gnu.org/licenses/>. */ - -#include <sys/uio.h> -#include <_itoa.h> - -/* We will print the register dump in this format: - - EAX: XXXXXXXX EBX: XXXXXXXX ECX: XXXXXXXX EDX: XXXXXXXX - ESI: XXXXXXXX EDI: XXXXXXXX EBP: XXXXXXXX ESP: XXXXXXXX - - EIP: XXXXXXXX EFLAGS: XXXXXXXX - - CS: XXXX DS: XXXX ES: XXXX FS: XXXX GS: XXXX SS: XXXX - - Trap: XXXXXXXX Error: XXXXXXXX OldMask: XXXXXXXX - ESP/SIGNAL: XXXXXXXX CR2: XXXXXXXX - - FPUCW: XXXXXXXX FPUSW: XXXXXXXX TAG: XXXXXXXX - IPOFF: XXXXXXXX CSSEL: XXXX DATAOFF: XXXXXXXX DATASEL: XXXX - - ST(0) XXXX XXXXXXXXXXXXXXXX ST(1) XXXX XXXXXXXXXXXXXXXX - ST(2) XXXX XXXXXXXXXXXXXXXX ST(3) XXXX XXXXXXXXXXXXXXXX - ST(4) XXXX XXXXXXXXXXXXXXXX ST(5) XXXX XXXXXXXXXXXXXXXX - ST(6) XXXX XXXXXXXXXXXXXXXX ST(7) XXXX XXXXXXXXXXXXXXXX - - */ - -static void -hexvalue (unsigned long int value, char *buf, size_t len) -{ - char *cp = _itoa_word (value, buf + len, 16, 0); - while (cp > buf) - *--cp = '0'; -} - -static void -register_dump (int fd, struct ucontext_t *ctx) -{ - char regs[21][8]; - char fpregs[31][8]; - struct iovec iov[97]; - size_t nr = 0; - -#define ADD_STRING(str) \ - iov[nr].iov_base = (char *) str; \ - iov[nr].iov_len = strlen (str); \ - ++nr -#define ADD_MEM(str, len) \ - iov[nr].iov_base = str; \ - iov[nr].iov_len = len; \ - ++nr - - /* Generate strings of register contents. */ - hexvalue (ctx->uc_mcontext.gregs[REG_EAX], regs[0], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_EBX], regs[1], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_ECX], regs[2], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_EDX], regs[3], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_ESI], regs[4], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_EDI], regs[5], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_EBP], regs[6], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_ESP], regs[7], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_EIP], regs[8], 8); - hexvalue (ctx->uc_flags, regs[9], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_CS], regs[10], 4); - hexvalue (ctx->uc_mcontext.gregs[REG_DS], regs[11], 4); - hexvalue (ctx->uc_mcontext.gregs[REG_ES], regs[12], 4); - hexvalue (ctx->uc_mcontext.gregs[REG_FS], regs[13], 4); - hexvalue (ctx->uc_mcontext.gregs[REG_GS], regs[14], 4); - hexvalue (ctx->uc_mcontext.gregs[REG_SS], regs[15], 4); - hexvalue (ctx->uc_mcontext.gregs[REG_TRAPNO], regs[16], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_ERR], regs[17], 8); - hexvalue (ctx->uc_mcontext.oldmask, regs[18], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_UESP], regs[19], 8); - hexvalue (ctx->uc_mcontext.cr2, regs[20], 8); - - /* Generate the output. */ - ADD_STRING ("Register dump:\n\n EAX: "); - ADD_MEM (regs[0], 8); - ADD_STRING (" EBX: "); - ADD_MEM (regs[1], 8); - ADD_STRING (" ECX: "); - ADD_MEM (regs[2], 8); - ADD_STRING (" EDX: "); - ADD_MEM (regs[3], 8); - ADD_STRING ("\n ESI: "); - ADD_MEM (regs[4], 8); - ADD_STRING (" EDI: "); - ADD_MEM (regs[5], 8); - ADD_STRING (" EBP: "); - ADD_MEM (regs[6], 8); - ADD_STRING (" ESP: "); - ADD_MEM (regs[7], 8); - ADD_STRING ("\n\n EIP: "); - ADD_MEM (regs[8], 8); - ADD_STRING (" EFLAGS: "); - ADD_MEM (regs[9], 8); - ADD_STRING ("\n\n CS: "); - ADD_MEM (regs[10], 4); - ADD_STRING (" DS: "); - ADD_MEM (regs[11], 4); - ADD_STRING (" ES: "); - ADD_MEM (regs[12], 4); - ADD_STRING (" FS: "); - ADD_MEM (regs[13], 4); - ADD_STRING (" GS: "); - ADD_MEM (regs[14], 4); - ADD_STRING (" SS: "); - ADD_MEM (regs[15], 4); - ADD_STRING ("\n\n Trap: "); - ADD_MEM (regs[16], 8); - ADD_STRING (" Error: "); - ADD_MEM (regs[17], 8); - ADD_STRING (" OldMask: "); - ADD_MEM (regs[18], 8); - ADD_STRING ("\n ESP/signal: "); - ADD_MEM (regs[19], 8); - ADD_STRING (" CR2: "); - ADD_MEM (regs[20], 8); - - /* Generate output for the FPU control/status registers. */ - hexvalue (ctx->__fpregs_mem.cw, fpregs[0], 8); - hexvalue (ctx->__fpregs_mem.sw, fpregs[1], 8); - hexvalue (ctx->__fpregs_mem.tag, fpregs[2], 8); - hexvalue (ctx->__fpregs_mem.ipoff, fpregs[3], 8); - hexvalue (ctx->__fpregs_mem.cssel, fpregs[4], 4); - hexvalue (ctx->__fpregs_mem.dataoff, fpregs[5], 8); - hexvalue (ctx->__fpregs_mem.datasel, fpregs[6], 4); - - ADD_STRING ("\n\n FPUCW: "); - ADD_MEM (fpregs[0], 8); - ADD_STRING (" FPUSW: "); - ADD_MEM (fpregs[1], 8); - ADD_STRING (" TAG: "); - ADD_MEM (fpregs[2], 8); - ADD_STRING ("\n IPOFF: "); - ADD_MEM (fpregs[3], 8); - ADD_STRING (" CSSEL: "); - ADD_MEM (fpregs[4], 4); - ADD_STRING (" DATAOFF: "); - ADD_MEM (fpregs[5], 8); - ADD_STRING (" DATASEL: "); - ADD_MEM (fpregs[6], 4); - - /* Now the real FPU registers. */ - hexvalue (ctx->__fpregs_mem._st[0].exponent, fpregs[7], 8); - hexvalue (ctx->__fpregs_mem._st[0].significand[3] << 16 - | ctx->__fpregs_mem._st[0].significand[2], fpregs[8], 8); - hexvalue (ctx->__fpregs_mem._st[0].significand[1] << 16 - | ctx->__fpregs_mem._st[0].significand[0], fpregs[9], 8); - hexvalue (ctx->__fpregs_mem._st[1].exponent, fpregs[10], 8); - hexvalue (ctx->__fpregs_mem._st[1].significand[3] << 16 - | ctx->__fpregs_mem._st[1].significand[2], fpregs[11], 8); - hexvalue (ctx->__fpregs_mem._st[1].significand[1] << 16 - | ctx->__fpregs_mem._st[1].significand[0], fpregs[12], 8); - hexvalue (ctx->__fpregs_mem._st[2].exponent, fpregs[13], 8); - hexvalue (ctx->__fpregs_mem._st[2].significand[3] << 16 - | ctx->__fpregs_mem._st[2].significand[2], fpregs[14], 8); - hexvalue (ctx->__fpregs_mem._st[2].significand[1] << 16 - | ctx->__fpregs_mem._st[2].significand[0], fpregs[15], 8); - hexvalue (ctx->__fpregs_mem._st[3].exponent, fpregs[16], 8); - hexvalue (ctx->__fpregs_mem._st[3].significand[3] << 16 - | ctx->__fpregs_mem._st[3].significand[2], fpregs[17], 8); - hexvalue (ctx->__fpregs_mem._st[3].significand[1] << 16 - | ctx->__fpregs_mem._st[3].significand[0], fpregs[18], 8); - hexvalue (ctx->__fpregs_mem._st[4].exponent, fpregs[19], 8); - hexvalue (ctx->__fpregs_mem._st[4].significand[3] << 16 - | ctx->__fpregs_mem._st[4].significand[2], fpregs[20], 8); - hexvalue (ctx->__fpregs_mem._st[4].significand[1] << 16 - | ctx->__fpregs_mem._st[4].significand[0], fpregs[21], 8); - hexvalue (ctx->__fpregs_mem._st[5].exponent, fpregs[22], 8); - hexvalue (ctx->__fpregs_mem._st[5].significand[3] << 16 - | ctx->__fpregs_mem._st[5].significand[2], fpregs[23], 8); - hexvalue (ctx->__fpregs_mem._st[5].significand[1] << 16 - | ctx->__fpregs_mem._st[5].significand[0], fpregs[24], 8); - hexvalue (ctx->__fpregs_mem._st[6].exponent, fpregs[25], 8); - hexvalue (ctx->__fpregs_mem._st[6].significand[3] << 16 - | ctx->__fpregs_mem._st[6].significand[2], fpregs[26], 8); - hexvalue (ctx->__fpregs_mem._st[6].significand[1] << 16 - | ctx->__fpregs_mem._st[6].significand[0], fpregs[27], 8); - hexvalue (ctx->__fpregs_mem._st[7].exponent, fpregs[28], 8); - hexvalue (ctx->__fpregs_mem._st[7].significand[3] << 16 - | ctx->__fpregs_mem._st[7].significand[2], fpregs[29], 8); - hexvalue (ctx->__fpregs_mem._st[7].significand[1] << 16 - | ctx->__fpregs_mem._st[7].significand[0], fpregs[30], 8); - - ADD_STRING ("\n\n ST(0) "); - ADD_MEM (fpregs[7], 4); - ADD_STRING (" "); - ADD_MEM (fpregs[8], 8); - ADD_MEM (fpregs[9], 8); - ADD_STRING (" ST(1) "); - ADD_MEM (fpregs[10], 4); - ADD_STRING (" "); - ADD_MEM (fpregs[11], 8); - ADD_MEM (fpregs[12], 8); - ADD_STRING ("\n ST(2) "); - ADD_MEM (fpregs[13], 4); - ADD_STRING (" "); - ADD_MEM (fpregs[14], 8); - ADD_MEM (fpregs[15], 8); - ADD_STRING (" ST(3) "); - ADD_MEM (fpregs[16], 4); - ADD_STRING (" "); - ADD_MEM (fpregs[17], 8); - ADD_MEM (fpregs[18], 8); - ADD_STRING ("\n ST(4) "); - ADD_MEM (fpregs[19], 4); - ADD_STRING (" "); - ADD_MEM (fpregs[20], 8); - ADD_MEM (fpregs[21], 8); - ADD_STRING (" ST(5) "); - ADD_MEM (fpregs[22], 4); - ADD_STRING (" "); - ADD_MEM (fpregs[23], 8); - ADD_MEM (fpregs[24], 8); - ADD_STRING ("\n ST(6) "); - ADD_MEM (fpregs[25], 4); - ADD_STRING (" "); - ADD_MEM (fpregs[26], 8); - ADD_MEM (fpregs[27], 8); - ADD_STRING (" ST(7) "); - ADD_MEM (fpregs[28], 4); - ADD_STRING (" "); - ADD_MEM (fpregs[29], 8); - ADD_MEM (fpregs[30], 8); - - ADD_STRING ("\n"); - - /* Write the stuff out. */ - writev (fd, iov, nr); -} - - -#define REGISTER_DUMP register_dump (fd, ctx) diff --git a/sysdeps/unix/sysv/linux/ia64/register-dump.h b/sysdeps/unix/sysv/linux/ia64/register-dump.h deleted file mode 100644 index 4c7c4002cb..0000000000 --- a/sysdeps/unix/sysv/linux/ia64/register-dump.h +++ /dev/null @@ -1,180 +0,0 @@ -/* Dump registers. - Copyright (C) 2004-2022 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; if not, see - <https://www.gnu.org/licenses/>. */ - -#include <string.h> -#include <sys/uio.h> -#include <_itoa.h> - -/* We will print the register dump in this format: - - GP: XXXXXXXXXXXXXXXX R2: XXXXXXXXXXXXXXXX R3: XXXXXXXXXXXXXXXX - R8: XXXXXXXXXXXXXXXX R9: XXXXXXXXXXXXXXXX R10: XXXXXXXXXXXXXXXX - R11: XXXXXXXXXXXXXXXX SP: XXXXXXXXXXXXXXXX TP: XXXXXXXXXXXXXXXX - R14: XXXXXXXXXXXXXXXX R15: XXXXXXXXXXXXXXXX R16: XXXXXXXXXXXXXXXX - R17: XXXXXXXXXXXXXXXX R18: XXXXXXXXXXXXXXXX R19: XXXXXXXXXXXXXXXX - R20: XXXXXXXXXXXXXXXX R21: XXXXXXXXXXXXXXXX R22: XXXXXXXXXXXXXXXX - R23: XXXXXXXXXXXXXXXX R24: XXXXXXXXXXXXXXXX R25: XXXXXXXXXXXXXXXX - R26: XXXXXXXXXXXXXXXX R27: XXXXXXXXXXXXXXXX R28: XXXXXXXXXXXXXXXX - R29: XXXXXXXXXXXXXXXX R30: XXXXXXXXXXXXXXXX R31: XXXXXXXXXXXXXXXX - - RP: XXXXXXXXXXXXXXXX B6: XXXXXXXXXXXXXXXX B7: XXXXXXXXXXXXXXXX - - IP: XXXXXXXXXXXXXXXX RSC: XXXXXXXXXXXXXXXX PR: XXXXXXXXXXXXXXXX - PFS: XXXXXXXXXXXXXXXX UNAT: XXXXXXXXXXXXXXXX CFM: XXXXXXXXXXXXXXXX - CCV: XXXXXXXXXXXXXXXX FPSR: XXXXXXXXXXXXXXXX - - F32: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX F33: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX - F34: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX F35: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -... - F124: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX F125: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX - F126: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX F127: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX - */ - -static void -hexvalue (unsigned long int value, char *buf, size_t len) -{ - char *cp = _itoa_word (value, buf + len, 16, 0); - while (cp > buf) - *--cp = '0'; -} - -static void -regvalue (unsigned long int *value, char letter, int regno, char *buf) -{ - int n = regno >= 100 ? 3 : regno >= 10 ? 2 : 1; - buf[0] = ' '; - buf[1] = letter; - _itoa_word (regno, buf + 2 + n, 10, 0); - buf[2 + n] = ':'; - for (++n; n <= 4; ++n) - buf[2 + n] = ' '; - hexvalue (value[0], buf + 7, 16); - if (letter == 'F') - { - hexvalue (value[1], buf + 7 + 16, 16); - buf[7 + 32] = '\n'; - } - else - buf[7 + 16] = '\n'; -} - -static void -register_dump (int fd, struct sigcontext *ctx) -{ - char gpregs[32 - 5][8 + 16]; - char fpregs[128 - 32][8 + 32]; - char bpregs[3][8 + 16]; - char spregs[8][16]; - struct iovec iov[146]; - size_t nr = 0; - int i; - -#define ADD_STRING(str) \ - do \ - { \ - iov[nr].iov_base = (char *) str; \ - iov[nr].iov_len = strlen (str); \ - ++nr; \ - } \ - while (0) -#define ADD_MEM(str, len) \ - do \ - { \ - iov[nr].iov_base = str; \ - iov[nr].iov_len = len; \ - ++nr; \ - } \ - while (0) - - /* Generate strings of register contents. */ - for (i = 1; i < 4; ++i) - { - regvalue (&ctx->sc_gr[i], 'R', i, gpregs[i - 1]); - if (ctx->sc_nat & (1L << i)) - memcpy (gpregs[i - 1] + 7, "NaT ", 16); - } - for (i = 8; i < 32; ++i) - { - regvalue (&ctx->sc_gr[i], 'R', i, gpregs[i - 5]); - if (ctx->sc_nat & (1L << i)) - memcpy (gpregs[i - 1] + 7, "NaT ", 16); - } - memcpy (gpregs[0] + 1, "GP:", 3); - memcpy (gpregs[7] + 1, "SP: ", 4); - memcpy (gpregs[8] + 1, "TP: ", 4); - - regvalue (&ctx->sc_br[0], 'B', 0, bpregs[0]); - regvalue (&ctx->sc_br[6], 'B', 6, bpregs[1]); - regvalue (&ctx->sc_br[7], 'B', 7, bpregs[2]); - memcpy (bpregs[0] + 1, "RP:", 3); - - if (ctx->sc_flags & IA64_SC_FLAG_FPH_VALID) - for (i = 32; i < 128; ++i) - regvalue (&ctx->sc_fr[i].u.bits[0], 'F', i, fpregs[i - 32]); - - hexvalue (ctx->sc_ip, spregs[0], sizeof (spregs[0])); - hexvalue (ctx->sc_ar_rsc, spregs[1], sizeof (spregs[1])); - hexvalue (ctx->sc_pr, spregs[2], sizeof (spregs[2])); - hexvalue (ctx->sc_ar_pfs, spregs[3], sizeof (spregs[3])); - hexvalue (ctx->sc_ar_unat, spregs[4], sizeof (spregs[4])); - hexvalue (ctx->sc_cfm, spregs[5], sizeof (spregs[5])); - hexvalue (ctx->sc_ar_ccv, spregs[6], sizeof (spregs[6])); - hexvalue (ctx->sc_ar_fpsr, spregs[7], sizeof (spregs[7])); - - /* Generate the output. */ - ADD_STRING ("Register dump:\n\n"); - - for (i = 0; i < 32 - 5; ++i) - ADD_MEM (gpregs[i], sizeof (gpregs[0]) - 1 + ((i % 3) == 2)); - ADD_STRING ("\n"); - - for (i = 0; i < 3; ++i) - ADD_MEM (bpregs[i], sizeof (bpregs[0]) - 1); - - ADD_STRING ("\n\n IP: "); - ADD_MEM (spregs[0], sizeof (spregs[0])); - ADD_STRING (" RSC: "); - ADD_MEM (spregs[1], sizeof (spregs[0])); - ADD_STRING (" PR: "); - ADD_MEM (spregs[2], sizeof (spregs[0])); - ADD_STRING ("\n PFS: "); - ADD_MEM (spregs[3], sizeof (spregs[0])); - ADD_STRING (" UNAT: "); - ADD_MEM (spregs[4], sizeof (spregs[0])); - ADD_STRING (" CFM: "); - ADD_MEM (spregs[5], sizeof (spregs[0])); - ADD_STRING ("\n CCV: "); - ADD_MEM (spregs[6], sizeof (spregs[0])); - ADD_STRING (" FPSR: "); - ADD_MEM (spregs[7], sizeof (spregs[0])); - ADD_STRING ("\n"); - - if (ctx->sc_flags & IA64_SC_FLAG_FPH_VALID) - { - ADD_STRING ("\n"); - - for (i = 0; i < 128 - 32; ++i) - ADD_MEM (fpregs[i], sizeof (fpregs[0]) - 1 + (i & 1)); - } - - /* Write the stuff out. */ - writev (fd, iov, nr); -} - - -#define REGISTER_DUMP register_dump (fd, ctx) diff --git a/sysdeps/unix/sysv/linux/m68k/register-dump.h b/sysdeps/unix/sysv/linux/m68k/register-dump.h deleted file mode 100644 index 38cc401145..0000000000 --- a/sysdeps/unix/sysv/linux/m68k/register-dump.h +++ /dev/null @@ -1,176 +0,0 @@ -/* Dump registers. - Copyright (C) 1998-2022 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library. If not, see - <https://www.gnu.org/licenses/>. */ - -#include <stddef.h> -#include <sys/uio.h> -#include <_itoa.h> - -/* We will print the register dump in this format: - - D0: XXXXXXXX D1: XXXXXXXX D2: XXXXXXXX D3: XXXXXXXX - D4: XXXXXXXX D5: XXXXXXXX D6: XXXXXXXX D7: XXXXXXXX - A0: XXXXXXXX A1: XXXXXXXX A2: XXXXXXXX A3: XXXXXXXX - A4: XXXXXXXX A5: XXXXXXXX A6: XXXXXXXX A7: XXXXXXXX - PC: XXXXXXXX SR: XXXX - - OldMask: XXXXXXXX Vector: XXXX - - FP0: XXXXXXXXXXXXXXXXXXXXXXXX FP1: XXXXXXXXXXXXXXXXXXXXXXXX - FP2: XXXXXXXXXXXXXXXXXXXXXXXX FP3: XXXXXXXXXXXXXXXXXXXXXXXX - FP4: XXXXXXXXXXXXXXXXXXXXXXXX FP5: XXXXXXXXXXXXXXXXXXXXXXXX - FP6: XXXXXXXXXXXXXXXXXXXXXXXX FP7: XXXXXXXXXXXXXXXXXXXXXXXX - FPCR: XXXXXXXX FPSR: XXXXXXXX FPIAR: XXXXXXXX - -*/ - -#define FPCONTEXT_SIZE 216 -#define uc_formatvec __glibc_reserved1[FPCONTEXT_SIZE/4] -#define uc_oldmask uc_sigmask.__val[0] - -static void -hexvalue (unsigned long int value, char *buf, size_t len) -{ - char *cp = _itoa_word (value, buf + len, 16, 0); - while (cp > buf) - *--cp = '0'; -} - -static void -register_dump (int fd, struct ucontext_t *ctx) -{ - char regs[20][8]; - char fpregs[11][24]; - struct iovec iov[63], *next_iov = iov; - int i, j, fpreg_size; - -#define ADD_STRING(str) \ - next_iov->iov_base = (char *) (str); \ - next_iov->iov_len = strlen (str); \ - ++next_iov -#define ADD_MEM(str, len) \ - next_iov->iov_base = (str); \ - next_iov->iov_len = (len); \ - ++next_iov - -#ifdef __mcoldfire__ - fpreg_size = 16; -#else - fpreg_size = 24; -#endif - - /* Generate strings of register contents. */ - hexvalue (ctx->uc_mcontext.gregs[R_D0], regs[0], 8); - hexvalue (ctx->uc_mcontext.gregs[R_D1], regs[1], 8); - hexvalue (ctx->uc_mcontext.gregs[R_D2], regs[2], 8); - hexvalue (ctx->uc_mcontext.gregs[R_D3], regs[3], 8); - hexvalue (ctx->uc_mcontext.gregs[R_D4], regs[4], 8); - hexvalue (ctx->uc_mcontext.gregs[R_D5], regs[5], 8); - hexvalue (ctx->uc_mcontext.gregs[R_D6], regs[6], 8); - hexvalue (ctx->uc_mcontext.gregs[R_D7], regs[7], 8); - hexvalue (ctx->uc_mcontext.gregs[R_A0], regs[8], 8); - hexvalue (ctx->uc_mcontext.gregs[R_A1], regs[9], 8); - hexvalue (ctx->uc_mcontext.gregs[R_A2], regs[10], 8); - hexvalue (ctx->uc_mcontext.gregs[R_A3], regs[11], 8); - hexvalue (ctx->uc_mcontext.gregs[R_A4], regs[12], 8); - hexvalue (ctx->uc_mcontext.gregs[R_A5], regs[13], 8); - hexvalue (ctx->uc_mcontext.gregs[R_A6], regs[14], 8); - hexvalue (ctx->uc_mcontext.gregs[R_SP], regs[15], 8); - hexvalue (ctx->uc_mcontext.gregs[R_PC], regs[16], 8); - hexvalue (ctx->uc_mcontext.gregs[R_PS], regs[17], 4); - hexvalue (ctx->uc_oldmask, regs[18], 8); - hexvalue (ctx->uc_formatvec & 0xfff, regs[19], 4); - - for (i = 0; i < 8; i++) - for (j = 0; j < fpreg_size; j += 8) - hexvalue (ctx->uc_mcontext.fpregs.f_fpregs[i][j/8], fpregs[i] + j, 8); - hexvalue (ctx->uc_mcontext.fpregs.f_pcr, fpregs[8], 8); - hexvalue (ctx->uc_mcontext.fpregs.f_psr, fpregs[9], 8); - hexvalue (ctx->uc_mcontext.fpregs.f_fpiaddr, fpregs[10], 8); - - /* Generate the output. */ - ADD_STRING ("Register dump:\n\n D0: "); - ADD_MEM (regs[0], 8); - ADD_STRING (" D1: "); - ADD_MEM (regs[1], 8); - ADD_STRING (" D2: "); - ADD_MEM (regs[2], 8); - ADD_STRING (" D3: "); - ADD_MEM (regs[3], 8); - ADD_STRING ("\n D4: "); - ADD_MEM (regs[4], 8); - ADD_STRING (" D5: "); - ADD_MEM (regs[5], 8); - ADD_STRING (" D6: "); - ADD_MEM (regs[6], 8); - ADD_STRING (" D7: "); - ADD_MEM (regs[7], 8); - ADD_STRING ("\n A0: "); - ADD_MEM (regs[8], 8); - ADD_STRING (" A1: "); - ADD_MEM (regs[9], 8); - ADD_STRING (" A2: "); - ADD_MEM (regs[10], 8); - ADD_STRING (" A3: "); - ADD_MEM (regs[11], 8); - ADD_STRING ("\n A4: "); - ADD_MEM (regs[12], 8); - ADD_STRING (" A5: "); - ADD_MEM (regs[13], 8); - ADD_STRING (" A6: "); - ADD_MEM (regs[14], 8); - ADD_STRING (" A7: "); - ADD_MEM (regs[15], 8); - ADD_STRING ("\n PC: "); - ADD_MEM (regs[16], 8); - ADD_STRING (" SR: "); - ADD_MEM (regs[17], 4); - - ADD_STRING ("\n\n OldMask: "); - ADD_MEM (regs[18], 8); - ADD_STRING (" Vector: "); - ADD_MEM (regs[19], 4); - - ADD_STRING ("\n\n FP0: "); - ADD_MEM (fpregs[0], fpreg_size); - ADD_STRING (" FP1: "); - ADD_MEM (fpregs[1], fpreg_size); - ADD_STRING ("\n FP2: "); - ADD_MEM (fpregs[2], fpreg_size); - ADD_STRING (" FP3: "); - ADD_MEM (fpregs[3], fpreg_size); - ADD_STRING ("\n FP4: "); - ADD_MEM (fpregs[4], fpreg_size); - ADD_STRING (" FP5: "); - ADD_MEM (fpregs[5], fpreg_size); - ADD_STRING ("\n FP6: "); - ADD_MEM (fpregs[6], fpreg_size); - ADD_STRING (" FP7: "); - ADD_MEM (fpregs[7], fpreg_size); - ADD_STRING ("\n FPCR: "); - ADD_MEM (fpregs[8], 8); - ADD_STRING (" FPSR: "); - ADD_MEM (fpregs[9], 8); - ADD_STRING (" FPIAR: "); - ADD_MEM (fpregs[10], 8); - ADD_STRING ("\n"); - - /* Write the stuff out. */ - writev (fd, iov, next_iov - iov); -} - -#define REGISTER_DUMP register_dump (fd, ctx) diff --git a/sysdeps/unix/sysv/linux/mips/register-dump.h b/sysdeps/unix/sysv/linux/mips/register-dump.h deleted file mode 100644 index b3ada7b7bf..0000000000 --- a/sysdeps/unix/sysv/linux/mips/register-dump.h +++ /dev/null @@ -1,120 +0,0 @@ -/* Dump registers. - Copyright (C) 2000-2022 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library. If not, see - <https://www.gnu.org/licenses/>. */ - -#include <sgidefs.h> -#include <sys/uio.h> -#include <_itoa.h> - -#if _MIPS_SIM == _ABIO32 -# define CTX_TYPE struct sigcontext * -# define CTX_REG(ctx, i) ((ctx)->sc_regs[(i)]) -# define CTX_PC(ctx) ((ctx)->sc_pc) -# define CTX_MDHI(ctx) ((ctx)->sc_mdhi) -# define CTX_MDLO(ctx) ((ctx)->sc_mdlo) -# define REG_HEX_SIZE 8 -#else -# define CTX_TYPE ucontext_t * -# define CTX_REG(ctx, i) ((ctx)->uc_mcontext.gregs[(i)]) -# define CTX_PC(ctx) ((ctx)->uc_mcontext.pc) -# define CTX_MDHI(ctx) ((ctx)->uc_mcontext.mdhi) -# define CTX_MDLO(ctx) ((ctx)->uc_mcontext.mdhi) -# define REG_HEX_SIZE 16 -#endif - -/* We will print the register dump in this format: - - R0 XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX - R8 XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX - R16 XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX - R24 XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX - pc lo hi - XXXXXXXX XXXXXXXX XXXXXXXX - The FPU registers will not be printed. -*/ - -static void -hexvalue (_ITOA_WORD_TYPE value, char *buf, size_t len) -{ - char *cp = _itoa_word (value, buf + len, 16, 0); - while (cp > buf) - *--cp = '0'; -} - -static void -register_dump (int fd, CTX_TYPE ctx) -{ - char regs[38][REG_HEX_SIZE]; - struct iovec iov[38 * 2 + 10]; - size_t nr = 0; - int i; - -#define ADD_STRING(str) \ - iov[nr].iov_base = (char *) str; \ - iov[nr].iov_len = strlen (str); \ - ++nr -#define ADD_MEM(str, len) \ - iov[nr].iov_base = str; \ - iov[nr].iov_len = len; \ - ++nr - - /* Generate strings of register contents. */ - for (i = 0; i < 32; i++) - hexvalue (CTX_REG (ctx, i), regs[i], REG_HEX_SIZE); - hexvalue (CTX_PC (ctx), regs[32], REG_HEX_SIZE); - hexvalue (CTX_MDHI (ctx), regs[33], REG_HEX_SIZE); - hexvalue (CTX_MDLO (ctx), regs[34], REG_HEX_SIZE); - - /* Generate the output. */ - ADD_STRING ("Register dump:\n\n R0 "); - for (i = 0; i < 8; i++) - { - ADD_MEM (regs[i], REG_HEX_SIZE); - ADD_STRING (" "); - } - ADD_STRING ("\n R8 "); - for (i = 8; i < 16; i++) - { - ADD_MEM (regs[i], REG_HEX_SIZE); - ADD_STRING (" "); - } - ADD_STRING ("\n R16 "); - for (i = 16; i < 24; i++) - { - ADD_MEM (regs[i], REG_HEX_SIZE); - ADD_STRING (" "); - } - ADD_STRING ("\n R24 "); - for (i = 24; i < 32; i++) - { - ADD_MEM (regs[i], REG_HEX_SIZE); - ADD_STRING (" "); - } - ADD_STRING ("\n pc lo hi\n "); - for (i = 32; i < 35; i++) - { - ADD_MEM (regs[i], REG_HEX_SIZE); - ADD_STRING (" "); - } - ADD_STRING ("\n"); - - /* Write the stuff out. */ - writev (fd, iov, nr); -} - - -#define REGISTER_DUMP register_dump (fd, ctx) diff --git a/sysdeps/unix/sysv/linux/riscv/register-dump.h b/sysdeps/unix/sysv/linux/riscv/register-dump.h deleted file mode 100644 index 177636f18f..0000000000 --- a/sysdeps/unix/sysv/linux/riscv/register-dump.h +++ /dev/null @@ -1,63 +0,0 @@ -/* Dump registers. - Copyright (C) 2000-2022 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library. If not, see - <https://www.gnu.org/licenses/>. */ - -#include <unistd.h> -#include <string.h> -#include <_itoa.h> - -static void -hexvalue (unsigned long int value, char *buf, size_t len) -{ - char *cp = _itoa_word (value, buf + len, 16, 0); - while (cp > buf) - *--cp = '0'; -} - -#define REGDUMP_NREGS 32 -#define REGDUMP_PER_LINE (80 / (__WORDSIZE / 4 + 4)) - -static void -register_dump (int fd, ucontext_t *ctx) -{ - int i; - char regvalue[__WORDSIZE / 4 + 1]; - char str[82 * ((REGDUMP_NREGS + REGDUMP_PER_LINE - 1) / REGDUMP_PER_LINE)]; - - static const char names[REGDUMP_NREGS][4] = { - "pc", "ra", "sp", "gp", "tp", "t0", "t1", "t2", - "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", - "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", - "s8", "s9", "sA", "sB", "t3", "t4", "t5", "t6" - }; - - str[0] = 0; - for (i = 0; i < REGDUMP_NREGS; i++) - { - strcat (str, names[i]); - strcat (str, " "); - hexvalue (ctx->uc_mcontext.__gregs[i], regvalue, __WORDSIZE / 4); - strcat (str, regvalue); - - if ((i + 1) % REGDUMP_PER_LINE == 0) - strcat (str, "\n"); - } - - write (fd, str, strlen (str)); -} - -#define REGISTER_DUMP register_dump (fd, ctx) diff --git a/sysdeps/unix/sysv/linux/s390/s390-32/register-dump.h b/sysdeps/unix/sysv/linux/s390/s390-32/register-dump.h deleted file mode 100644 index 51aa1e4cc0..0000000000 --- a/sysdeps/unix/sysv/linux/s390/s390-32/register-dump.h +++ /dev/null @@ -1,128 +0,0 @@ -/* Dump registers. - Copyright (C) 2000-2022 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; if not, see - <https://www.gnu.org/licenses/>. */ - -#include <sys/uio.h> -#include <_itoa.h> - -/* We will print the register dump in this format: - - GPR0: XXXXXXXX GPR1: XXXXXXXX GPR2: XXXXXXXX GPR3: XXXXXXXX - GPR4: XXXXXXXX GPR5: XXXXXXXX GPR6: XXXXXXXX GPR7: XXXXXXXX - GPR8: XXXXXXXX GPR9: XXXXXXXX GPRA: XXXXXXXX GPRB: XXXXXXXX - GPRC: XXXXXXXX GPRD: XXXXXXXX GPRE: XXXXXXXX GPRF: XXXXXXXX - - PSW.MASK: XXXXXXXX PSW.ADDR: XXXXXXXX - - ST(0) XXXX XXXXXXXXXXXXXXXX ST(1) XXXX XXXXXXXXXXXXXXXX - ST(2) XXXX XXXXXXXXXXXXXXXX ST(3) XXXX XXXXXXXXXXXXXXXX - ST(4) XXXX XXXXXXXXXXXXXXXX ST(5) XXXX XXXXXXXXXXXXXXXX - ST(6) XXXX XXXXXXXXXXXXXXXX ST(7) XXXX XXXXXXXXXXXXXXXX - - */ - -static void -hexvalue (unsigned long int value, char *buf, size_t len) -{ - char *cp = _itoa_word (value, buf + len, 16, 0); - while (cp > buf) - *--cp = '0'; -} - -static void -register_dump (int fd, struct ucontext_t *ctx) -{ - char regs[19][8]; - struct iovec iov[40]; - size_t nr = 0; - -#define ADD_STRING(str) \ - iov[nr].iov_base = (char *) str; \ - iov[nr].iov_len = strlen (str); \ - ++nr -#define ADD_MEM(str, len) \ - iov[nr].iov_base = str; \ - iov[nr].iov_len = len; \ - ++nr - - /* Generate strings of register contents. */ - hexvalue (ctx->uc_mcontext.gregs[0], regs[0], 8); - hexvalue (ctx->uc_mcontext.gregs[1], regs[1], 8); - hexvalue (ctx->uc_mcontext.gregs[2], regs[2], 8); - hexvalue (ctx->uc_mcontext.gregs[3], regs[3], 8); - hexvalue (ctx->uc_mcontext.gregs[4], regs[4], 8); - hexvalue (ctx->uc_mcontext.gregs[5], regs[5], 8); - hexvalue (ctx->uc_mcontext.gregs[6], regs[6], 8); - hexvalue (ctx->uc_mcontext.gregs[7], regs[7], 8); - hexvalue (ctx->uc_mcontext.gregs[8], regs[8], 8); - hexvalue (ctx->uc_mcontext.gregs[9], regs[9], 8); - hexvalue (ctx->uc_mcontext.gregs[10], regs[10], 8); - hexvalue (ctx->uc_mcontext.gregs[11], regs[11], 8); - hexvalue (ctx->uc_mcontext.gregs[12], regs[12], 8); - hexvalue (ctx->uc_mcontext.gregs[13], regs[13], 8); - hexvalue (ctx->uc_mcontext.gregs[14], regs[14], 8); - hexvalue (ctx->uc_mcontext.gregs[15], regs[15], 8); - hexvalue (ctx->uc_mcontext.psw.mask, regs[16], 8); - hexvalue (ctx->uc_mcontext.psw.addr, regs[17], 8); - - /* Generate the output. */ - ADD_STRING ("Register dump:\n\n GPR0: "); - ADD_MEM (regs[0], 8); - ADD_STRING (" GPR1: "); - ADD_MEM (regs[1], 8); - ADD_STRING (" GPR2: "); - ADD_MEM (regs[2], 8); - ADD_STRING (" GPR3: "); - ADD_MEM (regs[3], 8); - ADD_STRING ("\n GPR4: "); - ADD_MEM (regs[4], 8); - ADD_STRING (" GPR5: "); - ADD_MEM (regs[5], 8); - ADD_STRING (" GPR6: "); - ADD_MEM (regs[6], 8); - ADD_STRING (" GPR7: "); - ADD_MEM (regs[7], 8); - ADD_STRING ("\n GPR8: "); - ADD_MEM (regs[8], 8); - ADD_STRING (" GPR9: "); - ADD_MEM (regs[9], 8); - ADD_STRING (" GPRA: "); - ADD_MEM (regs[10], 8); - ADD_STRING (" GPRB: "); - ADD_MEM (regs[11], 8); - ADD_STRING ("\n GPRC: "); - ADD_MEM (regs[12], 8); - ADD_STRING (" GPRD: "); - ADD_MEM (regs[13], 8); - ADD_STRING (" GPRE: "); - ADD_MEM (regs[14], 8); - ADD_STRING (" GPRF: "); - ADD_MEM (regs[15], 8); - ADD_STRING ("\n\n PSW.MASK: "); - ADD_MEM (regs[16], 8); - ADD_STRING (" PSW.ADDR: "); - ADD_MEM (regs[17], 8); - ADD_STRING (" TRAP: "); - ADD_MEM (regs[18], 4); - ADD_STRING ("\n"); - - /* Write the stuff out. */ - writev (fd, iov, nr); -} - - -#define REGISTER_DUMP register_dump (fd, ctx) diff --git a/sysdeps/unix/sysv/linux/s390/s390-64/register-dump.h b/sysdeps/unix/sysv/linux/s390/s390-64/register-dump.h deleted file mode 100644 index 3fcbfd1f96..0000000000 --- a/sysdeps/unix/sysv/linux/s390/s390-64/register-dump.h +++ /dev/null @@ -1,131 +0,0 @@ -/* Dump registers. 64 bit S/390 version. - Copyright (C) 2001-2022 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; if not, see - <https://www.gnu.org/licenses/>. */ - -#include <sys/uio.h> -#include <_itoa.h> - -/* We will print the register dump in this format: - - GPR0: XXXXXXXXXXXXXXXX GPR1: XXXXXXXXXXXXXXXX - GPR2: XXXXXXXXXXXXXXXX GPR3: XXXXXXXXXXXXXXXX - GPR4: XXXXXXXXXXXXXXXX GPR5: XXXXXXXXXXXXXXXX - GPR6: XXXXXXXXXXXXXXXX GPR7: XXXXXXXXXXXXXXXX - GPR8: XXXXXXXXXXXXXXXX GPR9: XXXXXXXXXXXXXXXX - GPRA: XXXXXXXXXXXXXXXX GPRB: XXXXXXXXXXXXXXXX - GPRC: XXXXXXXXXXXXXXXX GPRD: XXXXXXXXXXXXXXXX - GPRE: XXXXXXXXXXXXXXXX GPRF: XXXXXXXXXXXXXXXX - - PSW.MASK: XXXXXXXXXXXXXXXX PSW.ADDR: XXXXXXXXXXXXXXXX - - ST(0) XXXX XXXXXXXXXXXXXXXX ST(1) XXXX XXXXXXXXXXXXXXXX - ST(2) XXXX XXXXXXXXXXXXXXXX ST(3) XXXX XXXXXXXXXXXXXXXX - ST(4) XXXX XXXXXXXXXXXXXXXX ST(5) XXXX XXXXXXXXXXXXXXXX - ST(6) XXXX XXXXXXXXXXXXXXXX ST(7) XXXX XXXXXXXXXXXXXXXX - */ - -static void -hexvalue (unsigned long int value, char *buf, size_t len) -{ - char *cp = _itoa_word (value, buf + len, 16, 0); - while (cp > buf) - *--cp = '0'; -} - -static void -register_dump (int fd, struct ucontext_t *ctx) -{ - char regs[19][16]; - struct iovec iov[40]; - size_t nr = 0; - -#define ADD_STRING(str) \ - iov[nr].iov_base = (char *) str; \ - iov[nr].iov_len = strlen (str); \ - ++nr -#define ADD_MEM(str, len) \ - iov[nr].iov_base = str; \ - iov[nr].iov_len = len; \ - ++nr - - /* Generate strings of register contents. */ - hexvalue (ctx->uc_mcontext.gregs[0], regs[0], 16); - hexvalue (ctx->uc_mcontext.gregs[1], regs[1], 16); - hexvalue (ctx->uc_mcontext.gregs[2], regs[2], 16); - hexvalue (ctx->uc_mcontext.gregs[3], regs[3], 16); - hexvalue (ctx->uc_mcontext.gregs[4], regs[4], 16); - hexvalue (ctx->uc_mcontext.gregs[5], regs[5], 16); - hexvalue (ctx->uc_mcontext.gregs[6], regs[6], 16); - hexvalue (ctx->uc_mcontext.gregs[7], regs[7], 16); - hexvalue (ctx->uc_mcontext.gregs[8], regs[8], 16); - hexvalue (ctx->uc_mcontext.gregs[9], regs[9], 16); - hexvalue (ctx->uc_mcontext.gregs[10], regs[10], 16); - hexvalue (ctx->uc_mcontext.gregs[11], regs[11], 16); - hexvalue (ctx->uc_mcontext.gregs[12], regs[12], 16); - hexvalue (ctx->uc_mcontext.gregs[13], regs[13], 16); - hexvalue (ctx->uc_mcontext.gregs[14], regs[14], 16); - hexvalue (ctx->uc_mcontext.gregs[15], regs[15], 16); - hexvalue (ctx->uc_mcontext.psw.mask, regs[16], 16); - hexvalue (ctx->uc_mcontext.psw.addr, regs[17], 16); - - /* Generate the output. */ - ADD_STRING ("Register dump:\n\n GPR0: "); - ADD_MEM (regs[0], 16); - ADD_STRING (" GPR1: "); - ADD_MEM (regs[1], 16); - ADD_STRING (" GPR2: "); - ADD_MEM (regs[2], 16); - ADD_STRING (" GPR3: "); - ADD_MEM (regs[3], 16); - ADD_STRING ("\n GPR4: "); - ADD_MEM (regs[4], 16); - ADD_STRING (" GPR5: "); - ADD_MEM (regs[5], 16); - ADD_STRING (" GPR6: "); - ADD_MEM (regs[6], 16); - ADD_STRING (" GPR7: "); - ADD_MEM (regs[7], 16); - ADD_STRING ("\n GPR8: "); - ADD_MEM (regs[8], 16); - ADD_STRING (" GPR9: "); - ADD_MEM (regs[9], 16); - ADD_STRING (" GPRA: "); - ADD_MEM (regs[10], 16); - ADD_STRING (" GPRB: "); - ADD_MEM (regs[11], 16); - ADD_STRING ("\n GPRC: "); - ADD_MEM (regs[12], 16); - ADD_STRING (" GPRD: "); - ADD_MEM (regs[13], 16); - ADD_STRING (" GPRE: "); - ADD_MEM (regs[14], 16); - ADD_STRING (" GPRF: "); - ADD_MEM (regs[15], 16); - ADD_STRING ("\n\n PSW.MASK: "); - ADD_MEM (regs[16], 16); - ADD_STRING (" PSW.ADDR: "); - ADD_MEM (regs[17], 16); - ADD_STRING (" TRAP: "); - ADD_MEM (regs[18], 4); - ADD_STRING ("\n"); - - /* Write the stuff out. */ - writev (fd, iov, nr); -} - - -#define REGISTER_DUMP register_dump (fd, ctx) diff --git a/sysdeps/unix/sysv/linux/segfault.c b/sysdeps/unix/sysv/linux/segfault.c deleted file mode 100644 index a417df9c41..0000000000 --- a/sysdeps/unix/sysv/linux/segfault.c +++ /dev/null @@ -1,2 +0,0 @@ -#define HAVE_PROC_SELF 1 -#include <debug/segfault.c> diff --git a/sysdeps/unix/sysv/linux/sh/register-dump.h b/sysdeps/unix/sysv/linux/sh/register-dump.h deleted file mode 100644 index b37faa707d..0000000000 --- a/sysdeps/unix/sysv/linux/sh/register-dump.h +++ /dev/null @@ -1,263 +0,0 @@ -/* Dump registers. - Copyright (C) 1999-2022 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; if not, see - <https://www.gnu.org/licenses/>. */ - -#include <sys/uio.h> -#include <_itoa.h> - -/* We will print the register dump in this format: - - R0: XXXXXXXX R1: XXXXXXXX R2: XXXXXXXX R3: XXXXXXXX - R4: XXXXXXXX R5: XXXXXXXX R6: XXXXXXXX R7: XXXXXXXX - R8: XXXXXXXX R9: XXXXXXXX R10: XXXXXXXX R11: XXXXXXXX - R12: XXXXXXXX R13: XXXXXXXX R14: XXXXXXXX R15: XXXXXXXX - -MACL: XXXXXXXX MACH: XXXXXXXX - - PC: XXXXXXXX PR: XXXXXXXX GBR: XXXXXXXX SR: XXXXXXXX - - FR0: XXXXXXXX FR1: XXXXXXXX FR2: XXXXXXXX FR3: XXXXXXXX - FR4: XXXXXXXX FR5: XXXXXXXX FR6: XXXXXXXX FR7: XXXXXXXX - FR8: XXXXXXXX FR9: XXXXXXXX FR10: XXXXXXXX FR11: XXXXXXXX -FR12: XXXXXXXX FR13: XXXXXXXX FR14: XXXXXXXX FR15: XXXXXXXX - - XR0: XXXXXXXX XR1: XXXXXXXX XR2: XXXXXXXX XR3: XXXXXXXX - XR4: XXXXXXXX XR5: XXXXXXXX XR6: XXXXXXXX XR7: XXXXXXXX - XR8: XXXXXXXX XR9: XXXXXXXX XR10: XXXXXXXX XR11: XXXXXXXX -XR12: XXXXXXXX XR13: XXXXXXXX XR14: XXXXXXXX XR15: XXXXXXXX - -FPSCR: XXXXXXXX FPUL: XXXXXXXX - - */ - -static void -hexvalue (unsigned long int value, char *buf, size_t len) -{ - char *cp = _itoa_word (value, buf + len, 16, 0); - while (cp > buf) - *--cp = '0'; -} - -static void -register_dump (int fd, struct ucontext_t *ctx) -{ - char regs[22][8]; - struct iovec iov[22 * 2 + 34 * 2 + 2]; - size_t nr = 0; - -#define ADD_STRING(str) \ - iov[nr].iov_base = (char *) str; \ - iov[nr].iov_len = strlen (str); \ - ++nr -#define ADD_MEM(str, len) \ - iov[nr].iov_base = str; \ - iov[nr].iov_len = len; \ - ++nr - - /* Generate strings of register contents. */ - hexvalue (ctx->uc_mcontext.gregs[REG_R0], regs[0], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_R1], regs[1], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_R2], regs[2], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_R3], regs[3], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_R4], regs[4], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_R5], regs[5], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_R6], regs[6], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_R7], regs[7], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_R8], regs[8], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_R9], regs[9], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_R10], regs[10], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_R11], regs[11], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_R12], regs[12], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_R13], regs[13], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_R14], regs[14], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_R15], regs[15], 8); - hexvalue (ctx->uc_mcontext.macl, regs[16], 8); - hexvalue (ctx->uc_mcontext.mach, regs[17], 8); - hexvalue (ctx->uc_mcontext.pc, regs[18], 8); - hexvalue (ctx->uc_mcontext.pr, regs[19], 8); - hexvalue (ctx->uc_mcontext.gbr, regs[20], 8); - hexvalue (ctx->uc_mcontext.sr, regs[21], 8); - - /* Generate the output. */ - ADD_STRING ("Register dump:\n\n R0: "); - ADD_MEM (regs[0], 8); - ADD_STRING (" R1: "); - ADD_MEM (regs[1], 8); - ADD_STRING (" R2: "); - ADD_MEM (regs[2], 8); - ADD_STRING (" R3: "); - ADD_MEM (regs[3], 8); - ADD_STRING ("\n R4: "); - ADD_MEM (regs[4], 8); - ADD_STRING (" R5: "); - ADD_MEM (regs[5], 8); - ADD_STRING (" R6: "); - ADD_MEM (regs[6], 8); - ADD_STRING (" R7: "); - ADD_MEM (regs[7], 8); - ADD_STRING ("\n R8: "); - ADD_MEM (regs[8], 8); - ADD_STRING (" R9: "); - ADD_MEM (regs[9], 8); - ADD_STRING (" R10: "); - ADD_MEM (regs[10], 8); - ADD_STRING (" R11: "); - ADD_MEM (regs[11], 8); - ADD_STRING ("\n R12: "); - ADD_MEM (regs[12], 8); - ADD_STRING (" R13: "); - ADD_MEM (regs[13], 8); - ADD_STRING (" R14: "); - ADD_MEM (regs[14], 8); - ADD_STRING (" R15: "); - ADD_MEM (regs[15], 8); - - ADD_STRING ("\n\nMACL: "); - ADD_MEM (regs[16], 8); - ADD_STRING (" MACH: "); - ADD_MEM (regs[17], 8); - - ADD_STRING ("\n\n PC: "); - ADD_MEM (regs[18], 8); - ADD_STRING (" PR: "); - ADD_MEM (regs[19], 8); - ADD_STRING (" GBR: "); - ADD_MEM (regs[20], 8); - ADD_STRING (" SR: "); - ADD_MEM (regs[21], 8); - - ADD_STRING ("\n"); - -#ifdef __SH_FPU_ANY__ - char fpregs[34][8]; - if (ctx->uc_mcontext.ownedfp != 0) - { - hexvalue (ctx->uc_mcontext.fpregs[0], fpregs[0], 8); - hexvalue (ctx->uc_mcontext.fpregs[1], fpregs[1], 8); - hexvalue (ctx->uc_mcontext.fpregs[2], fpregs[2], 8); - hexvalue (ctx->uc_mcontext.fpregs[3], fpregs[3], 8); - hexvalue (ctx->uc_mcontext.fpregs[4], fpregs[4], 8); - hexvalue (ctx->uc_mcontext.fpregs[5], fpregs[5], 8); - hexvalue (ctx->uc_mcontext.fpregs[6], fpregs[6], 8); - hexvalue (ctx->uc_mcontext.fpregs[7], fpregs[7], 8); - hexvalue (ctx->uc_mcontext.fpregs[8], fpregs[8], 8); - hexvalue (ctx->uc_mcontext.fpregs[9], fpregs[9], 8); - hexvalue (ctx->uc_mcontext.fpregs[10], fpregs[10], 8); - hexvalue (ctx->uc_mcontext.fpregs[11], fpregs[11], 8); - hexvalue (ctx->uc_mcontext.fpregs[12], fpregs[12], 8); - hexvalue (ctx->uc_mcontext.fpregs[13], fpregs[13], 8); - hexvalue (ctx->uc_mcontext.fpregs[14], fpregs[14], 8); - hexvalue (ctx->uc_mcontext.fpregs[15], fpregs[15], 8); - hexvalue (ctx->uc_mcontext.xfpregs[0], fpregs[16], 8); - hexvalue (ctx->uc_mcontext.xfpregs[1], fpregs[17], 8); - hexvalue (ctx->uc_mcontext.xfpregs[2], fpregs[18], 8); - hexvalue (ctx->uc_mcontext.xfpregs[3], fpregs[19], 8); - hexvalue (ctx->uc_mcontext.xfpregs[4], fpregs[20], 8); - hexvalue (ctx->uc_mcontext.xfpregs[5], fpregs[21], 8); - hexvalue (ctx->uc_mcontext.xfpregs[6], fpregs[22], 8); - hexvalue (ctx->uc_mcontext.xfpregs[7], fpregs[23], 8); - hexvalue (ctx->uc_mcontext.xfpregs[8], fpregs[24], 8); - hexvalue (ctx->uc_mcontext.xfpregs[9], fpregs[25], 8); - hexvalue (ctx->uc_mcontext.xfpregs[10], fpregs[26], 8); - hexvalue (ctx->uc_mcontext.xfpregs[11], fpregs[27], 8); - hexvalue (ctx->uc_mcontext.xfpregs[12], fpregs[28], 8); - hexvalue (ctx->uc_mcontext.xfpregs[13], fpregs[29], 8); - hexvalue (ctx->uc_mcontext.xfpregs[14], fpregs[30], 8); - hexvalue (ctx->uc_mcontext.xfpregs[15], fpregs[31], 8); - hexvalue (ctx->uc_mcontext.fpscr, fpregs[32], 8); - hexvalue (ctx->uc_mcontext.fpul, fpregs[33], 8); - - ADD_STRING ("\n\n FR0: "); - ADD_MEM (fpregs[0], 8); - ADD_STRING (" FR1: "); - ADD_MEM (fpregs[1], 8); - ADD_STRING (" FR2: "); - ADD_MEM (fpregs[2], 8); - ADD_STRING (" FR3: "); - ADD_MEM (fpregs[3], 8); - ADD_STRING ("\n FR4: "); - ADD_MEM (fpregs[4], 8); - ADD_STRING (" FR5: "); - ADD_MEM (fpregs[5], 8); - ADD_STRING (" FR6: "); - ADD_MEM (fpregs[6], 8); - ADD_STRING (" FR7: "); - ADD_MEM (fpregs[7], 8); - ADD_STRING ("\n FR8: "); - ADD_MEM (fpregs[8], 8); - ADD_STRING (" FR9: "); - ADD_MEM (fpregs[9], 8); - ADD_STRING (" FR10: "); - ADD_MEM (fpregs[10], 8); - ADD_STRING (" FR11: "); - ADD_MEM (fpregs[11], 8); - ADD_STRING ("\nFR12: "); - ADD_MEM (fpregs[12], 8); - ADD_STRING (" FR13: "); - ADD_MEM (fpregs[13], 8); - ADD_STRING (" FR14: "); - ADD_MEM (fpregs[14], 8); - ADD_STRING (" FR15: "); - ADD_MEM (fpregs[15], 8); - ADD_STRING ("\n\n XR0: "); - ADD_MEM (fpregs[16], 8); - ADD_STRING (" XR1: "); - ADD_MEM (fpregs[17], 8); - ADD_STRING (" XR2: "); - ADD_MEM (fpregs[18], 8); - ADD_STRING (" XR3: "); - ADD_MEM (fpregs[19], 8); - ADD_STRING ("\n XR4: "); - ADD_MEM (fpregs[20], 8); - ADD_STRING (" XR5: "); - ADD_MEM (fpregs[21], 8); - ADD_STRING (" XR6: "); - ADD_MEM (fpregs[22], 8); - ADD_STRING (" XR7: "); - ADD_MEM (fpregs[23], 8); - ADD_STRING ("\n XR8: "); - ADD_MEM (fpregs[24], 8); - ADD_STRING (" XR9: "); - ADD_MEM (fpregs[25], 8); - ADD_STRING (" XR10: "); - ADD_MEM (fpregs[26], 8); - ADD_STRING (" XR11: "); - ADD_MEM (fpregs[27], 8); - ADD_STRING ("\nXR12: "); - ADD_MEM (fpregs[28], 8); - ADD_STRING (" XR13: "); - ADD_MEM (fpregs[29], 8); - ADD_STRING (" XR14: "); - ADD_MEM (fpregs[30], 8); - ADD_STRING (" XR15: "); - ADD_MEM (fpregs[31], 8); - - ADD_STRING ("\n\nFPSCR: "); - ADD_MEM (fpregs[32], 8); - ADD_STRING (" FPUL: "); - ADD_MEM (fpregs[33], 8); - - ADD_STRING ("\n"); - } -#endif /* __SH_FPU_ANY__ */ - - /* Write the stuff out. */ - writev (fd, iov, nr); -} - - -#define REGISTER_DUMP register_dump (fd, ctx) diff --git a/sysdeps/unix/sysv/linux/sparc/sparc32/register-dump.h b/sysdeps/unix/sysv/linux/sparc/sparc32/register-dump.h deleted file mode 100644 index 4c27c1e854..0000000000 --- a/sysdeps/unix/sysv/linux/sparc/sparc32/register-dump.h +++ /dev/null @@ -1,342 +0,0 @@ -/* Dump registers. - Copyright (C) 1999-2022 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; if not, see - <https://www.gnu.org/licenses/>. */ - -#include <sys/uio.h> -#include <_itoa.h> - -/* We will print the register dump in this format: - - PSR: XXXXXXXX PC: XXXXXXXX NPC: XXXXXXXX Y: XXXXXXXX - g0: 00000000 g1: XXXXXXXX g2: XXXXXXXX g3: XXXXXXXX - g4: XXXXXXXX g5: XXXXXXXX g6: XXXXXXXX g7: XXXXXXXX - o0: XXXXXXXX o1: XXXXXXXX o2: XXXXXXXX o3: XXXXXXXX - o4: XXXXXXXX o5: XXXXXXXX sp: XXXXXXXX o7: XXXXXXXX - l0: XXXXXXXX l1: XXXXXXXX l2: XXXXXXXX l3: XXXXXXXX - l4: XXXXXXXX l5: XXXXXXXX l6: XXXXXXXX l7: XXXXXXXX - i0: XXXXXXXX i1: XXXXXXXX i2: XXXXXXXX i3: XXXXXXXX - i4: XXXXXXXX i5: XXXXXXXX fp: XXXXXXXX i7: XXXXXXXX - - followed on sun4, sun4c, sun4d, sun4m by: - - Old mask: XXXXXXXX FSR: XXXXXXXX FPQ: XXXXXXXX - f0: XXXXXXXXXXXXXXXX f2: XXXXXXXXXXXXXXXX f4: XXXXXXXXXXXXXXXX - f6: XXXXXXXXXXXXXXXX f8: XXXXXXXXXXXXXXXX f10: XXXXXXXXXXXXXXXX - f12: XXXXXXXXXXXXXXXX f14: XXXXXXXXXXXXXXXX f16: XXXXXXXXXXXXXXXX - f18: XXXXXXXXXXXXXXXX f20: XXXXXXXXXXXXXXXX f22: XXXXXXXXXXXXXXXX - f24: XXXXXXXXXXXXXXXX f26: XXXXXXXXXXXXXXXX f28: XXXXXXXXXXXXXXXX - f30: XXXXXXXXXXXXXXXX - - and on sun4u by: - - Old mask: XXXXXXXX XFSR: XXXXXXXXXXXXXXXX GSR: XX FPRS: X - f0: XXXXXXXXXXXXXXXX f2: XXXXXXXXXXXXXXXX f4: XXXXXXXXXXXXXXXX - f6: XXXXXXXXXXXXXXXX f8: XXXXXXXXXXXXXXXX f10: XXXXXXXXXXXXXXXX - f12: XXXXXXXXXXXXXXXX f14: XXXXXXXXXXXXXXXX f16: XXXXXXXXXXXXXXXX - f18: XXXXXXXXXXXXXXXX f20: XXXXXXXXXXXXXXXX f22: XXXXXXXXXXXXXXXX - f24: XXXXXXXXXXXXXXXX f26: XXXXXXXXXXXXXXXX f28: XXXXXXXXXXXXXXXX - f30: XXXXXXXXXXXXXXXX f32: XXXXXXXXXXXXXXXX f34: XXXXXXXXXXXXXXXX - f36: XXXXXXXXXXXXXXXX f38: XXXXXXXXXXXXXXXX f40: XXXXXXXXXXXXXXXX - f42: XXXXXXXXXXXXXXXX f44: XXXXXXXXXXXXXXXX f46: XXXXXXXXXXXXXXXX - f48: XXXXXXXXXXXXXXXX f50: XXXXXXXXXXXXXXXX f52: XXXXXXXXXXXXXXXX - f54: XXXXXXXXXXXXXXXX f56: XXXXXXXXXXXXXXXX f58: XXXXXXXXXXXXXXXX - f60: XXXXXXXXXXXXXXXX f62: XXXXXXXXXXXXXXXX - - */ - -static void -hexvalue (unsigned long int value, char *buf, size_t len) -{ - char *cp = _itoa_word (value, buf + len, 16, 0); - while (cp > buf) - *--cp = '0'; -} - -struct __siginfo_sparc32_fpu -{ - unsigned int si_float_regs[32]; - unsigned int si_fsr; - unsigned int si_fpq; -}; -struct __siginfo_sparc64_fpu -{ - unsigned int si_float_regs[64]; - unsigned int si_xfsr; - unsigned int si_fsr; - unsigned int _pad1; - unsigned int si_gsr; - unsigned int _pad2; - unsigned int si_fprs; -}; - -/* Unlike other architectures, sparc32 passes pt_regs32 REGS pointer as - the third argument to a sa_sigaction handler with SA_SIGINFO enabled. */ -static void -register_dump (int fd, void *ctx) -{ - char regs[36][8]; - char fregs[68][8]; - struct iovec iov[150]; - size_t nr = 0; - int i; - struct pt_regs32 *ptregs = (struct pt_regs32 *) ctx; - struct compat_sigset_t - { - unsigned int sig[2]; - }; - struct compat_sigset_t *mask = (struct compat_sigset_t *)(ptregs + 1); - unsigned int *r = (unsigned int *) ptregs->u_regs[14]; - -#define ADD_STRING(str) \ - iov[nr].iov_base = (char *) str; \ - iov[nr].iov_len = strlen (str); \ - ++nr -#define ADD_MEM(str, len) \ - iov[nr].iov_base = str; \ - iov[nr].iov_len = len; \ - ++nr - - /* Generate strings of register contents. */ - hexvalue (ptregs->psr, regs[0], 8); - hexvalue (ptregs->pc, regs[1], 8); - hexvalue (ptregs->npc, regs[2], 8); - hexvalue (ptregs->y, regs[3], 8); - for (i = 1; i <= 15; i++) - hexvalue (ptregs->u_regs[i], regs[3+i], 8); - for (i = 0; i <= 15; i++) - hexvalue (r[i], regs[19+i], 8); - - hexvalue (mask->sig[0], regs[35], 8); - - /* Generate the output. */ - ADD_STRING ("Register dump:\n\n PSR: "); - ADD_MEM (regs[0], 8); - ADD_STRING (" PC: "); - ADD_MEM (regs[1], 8); - ADD_STRING (" NPC: "); - ADD_MEM (regs[2], 8); - ADD_STRING (" Y: "); - ADD_MEM (regs[3], 8); - ADD_STRING ("\n g0: 00000000 g1: "); - ADD_MEM (regs[4], 8); - ADD_STRING (" g2: "); - ADD_MEM (regs[5], 8); - ADD_STRING (" g3: "); - ADD_MEM (regs[6], 8); - ADD_STRING ("\n g4: "); - ADD_MEM (regs[7], 8); - ADD_STRING (" g5: "); - ADD_MEM (regs[8], 8); - ADD_STRING (" g6: "); - ADD_MEM (regs[9], 8); - ADD_STRING (" g7: "); - ADD_MEM (regs[10], 8); - ADD_STRING ("\n o0: "); - ADD_MEM (regs[11], 8); - ADD_STRING (" o1: "); - ADD_MEM (regs[12], 8); - ADD_STRING (" o2: "); - ADD_MEM (regs[13], 8); - ADD_STRING (" o3: "); - ADD_MEM (regs[14], 8); - ADD_STRING ("\n o4: "); - ADD_MEM (regs[15], 8); - ADD_STRING (" o5: "); - ADD_MEM (regs[16], 8); - ADD_STRING (" sp: "); - ADD_MEM (regs[17], 8); - ADD_STRING (" o7: "); - ADD_MEM (regs[18], 8); - ADD_STRING ("\n l0: "); - ADD_MEM (regs[19], 8); - ADD_STRING (" l1: "); - ADD_MEM (regs[20], 8); - ADD_STRING (" l2: "); - ADD_MEM (regs[21], 8); - ADD_STRING (" l3: "); - ADD_MEM (regs[22], 8); - ADD_STRING ("\n l4: "); - ADD_MEM (regs[23], 8); - ADD_STRING (" l5: "); - ADD_MEM (regs[24], 8); - ADD_STRING (" l6: "); - ADD_MEM (regs[25], 8); - ADD_STRING (" l7: "); - ADD_MEM (regs[26], 8); - ADD_STRING ("\n i0: "); - ADD_MEM (regs[27], 8); - ADD_STRING (" i1: "); - ADD_MEM (regs[28], 8); - ADD_STRING (" i2: "); - ADD_MEM (regs[29], 8); - ADD_STRING (" i3: "); - ADD_MEM (regs[30], 8); - ADD_STRING ("\n i4: "); - ADD_MEM (regs[31], 8); - ADD_STRING (" i5: "); - ADD_MEM (regs[32], 8); - ADD_STRING (" fp: "); - ADD_MEM (regs[33], 8); - ADD_STRING (" i7: "); - ADD_MEM (regs[34], 8); - ADD_STRING ("\n\n Old mask: "); - ADD_MEM (regs[35], 8); - - if ((ptregs->psr & 0xff000000) == 0xff000000) - { - struct __siginfo_sparc64_fpu *f = *(struct __siginfo_sparc64_fpu **) - (mask + 1); - - if (f != NULL) - { - for (i = 0; i < 64; i++) - hexvalue (f->si_float_regs[i], fregs[i], 8); - hexvalue (f->si_xfsr, fregs[64], 8); - hexvalue (f->si_fsr, fregs[65], 8); - hexvalue (f->si_gsr, fregs[66], 2); - hexvalue (f->si_fprs, fregs[67], 1); - ADD_STRING (" XFSR: "); - ADD_MEM (fregs[64], 8); - ADD_MEM (fregs[65], 8); - ADD_STRING (" GSR: "); - ADD_MEM (fregs[66], 2); - ADD_STRING (" FPRS: "); - ADD_MEM (fregs[67], 1); - ADD_STRING ("\n f0: "); - ADD_MEM (fregs[0], 16); - ADD_STRING (" f2: "); - ADD_MEM (fregs[2], 16); - ADD_STRING (" f4: "); - ADD_MEM (fregs[4], 16); - ADD_STRING ("\n f6: "); - ADD_MEM (fregs[6], 16); - ADD_STRING (" f8: "); - ADD_MEM (fregs[8], 16); - ADD_STRING (" f10: "); - ADD_MEM (fregs[10], 16); - ADD_STRING ("\n f12: "); - ADD_MEM (fregs[12], 16); - ADD_STRING (" f14: "); - ADD_MEM (fregs[14], 16); - ADD_STRING (" f16: "); - ADD_MEM (fregs[16], 16); - ADD_STRING ("\n f18: "); - ADD_MEM (fregs[18], 16); - ADD_STRING (" f20: "); - ADD_MEM (fregs[20], 16); - ADD_STRING (" f22: "); - ADD_MEM (fregs[22], 16); - ADD_STRING ("\n f24: "); - ADD_MEM (fregs[24], 16); - ADD_STRING (" f26: "); - ADD_MEM (fregs[26], 16); - ADD_STRING (" f28: "); - ADD_MEM (fregs[28], 16); - ADD_STRING ("\n f30: "); - ADD_MEM (fregs[30], 16); - ADD_STRING (" f32: "); - ADD_MEM (fregs[32], 16); - ADD_STRING (" f34: "); - ADD_MEM (fregs[34], 16); - ADD_STRING ("\n f36: "); - ADD_MEM (fregs[36], 16); - ADD_STRING (" f38: "); - ADD_MEM (fregs[38], 16); - ADD_STRING (" f40: "); - ADD_MEM (fregs[40], 16); - ADD_STRING ("\n f42: "); - ADD_MEM (fregs[42], 16); - ADD_STRING (" f44: "); - ADD_MEM (fregs[44], 16); - ADD_STRING (" f46: "); - ADD_MEM (fregs[46], 16); - ADD_STRING ("\n f48: "); - ADD_MEM (fregs[48], 16); - ADD_STRING (" f50: "); - ADD_MEM (fregs[50], 16); - ADD_STRING (" f52: "); - ADD_MEM (fregs[52], 16); - ADD_STRING ("\n f54: "); - ADD_MEM (fregs[54], 16); - ADD_STRING (" f56: "); - ADD_MEM (fregs[56], 16); - ADD_STRING (" f58: "); - ADD_MEM (fregs[58], 16); - ADD_STRING ("\n f60: "); - ADD_MEM (fregs[60], 16); - ADD_STRING (" f62: "); - ADD_MEM (fregs[62], 16); - } - } - else - { - struct __siginfo_sparc32_fpu *f = *(struct __siginfo_sparc32_fpu **) - (mask + 1); - - if (f != NULL) - { - for (i = 0; i < 32; i++) - hexvalue (f->si_float_regs[i], fregs[i], 8); - hexvalue (f->si_fsr, fregs[64], 8); - hexvalue (f->si_fpq, fregs[65], 8); - ADD_STRING (" FSR: "); - ADD_MEM (fregs[64], 8); - ADD_STRING (" FPQ: "); - ADD_MEM (fregs[65], 8); - ADD_STRING ("\n f0: "); - ADD_MEM (fregs[0], 16); - ADD_STRING (" f2: "); - ADD_MEM (fregs[2], 16); - ADD_STRING (" f4: "); - ADD_MEM (fregs[4], 16); - ADD_STRING ("\n f6: "); - ADD_MEM (fregs[6], 16); - ADD_STRING (" f8: "); - ADD_MEM (fregs[8], 16); - ADD_STRING (" f10: "); - ADD_MEM (fregs[10], 16); - ADD_STRING ("\n f12: "); - ADD_MEM (fregs[12], 16); - ADD_STRING (" f14: "); - ADD_MEM (fregs[14], 16); - ADD_STRING (" f16: "); - ADD_MEM (fregs[16], 16); - ADD_STRING ("\n f18: "); - ADD_MEM (fregs[18], 16); - ADD_STRING (" f20: "); - ADD_MEM (fregs[20], 16); - ADD_STRING (" f22: "); - ADD_MEM (fregs[22], 16); - ADD_STRING ("\n f24: "); - ADD_MEM (fregs[24], 16); - ADD_STRING (" f26: "); - ADD_MEM (fregs[26], 16); - ADD_STRING (" f28: "); - ADD_MEM (fregs[28], 16); - ADD_STRING ("\n f30: "); - ADD_MEM (fregs[30], 16); - } - } - - ADD_STRING ("\n"); - - /* Write the stuff out. */ - writev (fd, iov, nr); -} - - -#define REGISTER_DUMP register_dump (fd, ctx) diff --git a/sysdeps/unix/sysv/linux/sparc/sparc64/register-dump.h b/sysdeps/unix/sysv/linux/sparc/sparc64/register-dump.h deleted file mode 100644 index de68ccbd0e..0000000000 --- a/sysdeps/unix/sysv/linux/sparc/sparc64/register-dump.h +++ /dev/null @@ -1,273 +0,0 @@ -/* Dump registers. - Copyright (C) 1999-2022 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; if not, see - <https://www.gnu.org/licenses/>. */ - -#include <sys/uio.h> -#include <_itoa.h> - -/* We will print the register dump in this format: - - TSTATE: XXXXXXXXXXXXXXXX TPC: XXXXXXXXXXXXXXXX TNPC: XXXXXXXXXXXXXXXX - Y: XXXXXXXX - g0: 0000000000000000 g1: XXXXXXXXXXXXXXXX g2: XXXXXXXXXXXXXXXX - g3: XXXXXXXXXXXXXXXX g4: XXXXXXXXXXXXXXXX g5: XXXXXXXXXXXXXXXX - g6: XXXXXXXXXXXXXXXX g7: XXXXXXXXXXXXXXXX - o0: XXXXXXXXXXXXXXXX o1: XXXXXXXXXXXXXXXX o2: XXXXXXXXXXXXXXXX - o3: XXXXXXXXXXXXXXXX o4: XXXXXXXXXXXXXXXX o5: XXXXXXXXXXXXXXXX - sp: XXXXXXXXXXXXXXXX o7: XXXXXXXXXXXXXXXX - l0: XXXXXXXXXXXXXXXX l1: XXXXXXXXXXXXXXXX l2: XXXXXXXXXXXXXXXX - l3: XXXXXXXXXXXXXXXX l4: XXXXXXXXXXXXXXXX l5: XXXXXXXXXXXXXXXX - l6: XXXXXXXXXXXXXXXX l7: XXXXXXXXXXXXXXXX - i0: XXXXXXXXXXXXXXXX i1: XXXXXXXXXXXXXXXX i2: XXXXXXXXXXXXXXXX - i3: XXXXXXXXXXXXXXXX i4: XXXXXXXXXXXXXXXX i5: XXXXXXXXXXXXXXXX - fp: XXXXXXXXXXXXXXXX i7: XXXXXXXXXXXXXXXX - - Mask: XXXXXXXXXXXXXXXX XFSR: XXXXXXXXXXXXXXXX GSR: XX FPRS: X - f0: XXXXXXXXXXXXXXXX f2: XXXXXXXXXXXXXXXX f4: XXXXXXXXXXXXXXXX - f6: XXXXXXXXXXXXXXXX f8: XXXXXXXXXXXXXXXX f10: XXXXXXXXXXXXXXXX - f12: XXXXXXXXXXXXXXXX f14: XXXXXXXXXXXXXXXX f16: XXXXXXXXXXXXXXXX - f18: XXXXXXXXXXXXXXXX f20: XXXXXXXXXXXXXXXX f22: XXXXXXXXXXXXXXXX - f24: XXXXXXXXXXXXXXXX f26: XXXXXXXXXXXXXXXX f28: XXXXXXXXXXXXXXXX - f30: XXXXXXXXXXXXXXXX f32: XXXXXXXXXXXXXXXX f34: XXXXXXXXXXXXXXXX - f36: XXXXXXXXXXXXXXXX f38: XXXXXXXXXXXXXXXX f40: XXXXXXXXXXXXXXXX - f42: XXXXXXXXXXXXXXXX f44: XXXXXXXXXXXXXXXX f46: XXXXXXXXXXXXXXXX - f48: XXXXXXXXXXXXXXXX f50: XXXXXXXXXXXXXXXX f52: XXXXXXXXXXXXXXXX - f54: XXXXXXXXXXXXXXXX f56: XXXXXXXXXXXXXXXX f58: XXXXXXXXXXXXXXXX - f60: XXXXXXXXXXXXXXXX f62: XXXXXXXXXXXXXXXX - - */ - -static void -hexvalue (unsigned long int value, char *buf, size_t len) -{ - char *cp = _itoa_word (value, buf + len, 16, 0); - while (cp > buf) - *--cp = '0'; -} - -/* The sparc64 kernel signal frame for SA_SIGINFO is defined as: - - struct rt_signal_frame - { - struct sparc_stackf ss; - siginfo_t info; - struct pt_regs regs; <- void *ctx - __siginfo_fpu_t *fpu_save; - stack_t stack; - sigset_t mask; - __siginfo_rwin_t *rwin_save; - }; - - Unlike other architectures, sparc32 passes pt_regs32 REGS pointers as - the third argument to a sa_sigaction handler with SA_SIGINFO enabled. */ - -static void -register_dump (int fd, void *ctx) -{ - char regs[36][16]; - char fregs[68][8]; - struct iovec iov[150]; - size_t nr = 0; - int i; - struct pt_regs *ptregs = (struct pt_regs*) ((siginfo_t *)ctx + 1); - unsigned long *r = (unsigned long *) (ptregs->u_regs[14] + STACK_BIAS); - __siginfo_fpu_t *f = (__siginfo_fpu_t *)(ptregs + 1); - struct kernel_sigset_t { - unsigned long sig[1]; - } *mask = (struct kernel_sigset_t *)((stack_t *)(f + 1) + 1); - -#define ADD_STRING(str) \ - iov[nr].iov_base = (char *) str; \ - iov[nr].iov_len = strlen (str); \ - ++nr -#define ADD_MEM(str, len) \ - iov[nr].iov_base = str; \ - iov[nr].iov_len = len; \ - ++nr - - /* Generate strings of register contents. */ - hexvalue (ptregs->tstate, regs[0], 16); - hexvalue (ptregs->tpc, regs[1], 16); - hexvalue (ptregs->tnpc, regs[2], 16); - hexvalue (ptregs->y, regs[3], 8); - for (i = 1; i <= 15; i++) - hexvalue (ptregs->u_regs[i], regs[3+i], 16); - for (i = 0; i <= 15; i++) - hexvalue (r[i], regs[19+i], 16); - hexvalue (mask->sig[0], regs[35], 16); - - /* Generate the output. */ - ADD_STRING ("Register dump:\n\n TSTATE: "); - ADD_MEM (regs[0], 16); - ADD_STRING (" TPC: "); - ADD_MEM (regs[1], 16); - ADD_STRING (" TNPC: "); - ADD_MEM (regs[2], 16); - ADD_STRING ("\n Y: "); - ADD_MEM (regs[3], 8); - ADD_STRING ("\n g0: 0000000000000000 g1: "); - ADD_MEM (regs[4], 16); - ADD_STRING (" g2: "); - ADD_MEM (regs[5], 16); - ADD_STRING ("\n g3: "); - ADD_MEM (regs[6], 16); - ADD_STRING (" g4: "); - ADD_MEM (regs[7], 16); - ADD_STRING (" g5: "); - ADD_MEM (regs[8], 16); - ADD_STRING ("\n g6: "); - ADD_MEM (regs[9], 16); - ADD_STRING (" g7: "); - ADD_MEM (regs[10], 16); - ADD_STRING ("\n o0: "); - ADD_MEM (regs[11], 16); - ADD_STRING (" o1: "); - ADD_MEM (regs[12], 16); - ADD_STRING (" o2: "); - ADD_MEM (regs[13], 16); - ADD_STRING ("\n o3: "); - ADD_MEM (regs[14], 16); - ADD_STRING (" o4: "); - ADD_MEM (regs[15], 16); - ADD_STRING (" o5: "); - ADD_MEM (regs[16], 16); - ADD_STRING ("\n sp: "); - ADD_MEM (regs[17], 16); - ADD_STRING (" o7: "); - ADD_MEM (regs[18], 16); - ADD_STRING ("\n l0: "); - ADD_MEM (regs[19], 16); - ADD_STRING (" l1: "); - ADD_MEM (regs[20], 16); - ADD_STRING (" l2: "); - ADD_MEM (regs[21], 16); - ADD_STRING ("\n l3: "); - ADD_MEM (regs[22], 16); - ADD_STRING (" l4: "); - ADD_MEM (regs[23], 16); - ADD_STRING (" l5: "); - ADD_MEM (regs[24], 16); - ADD_STRING ("\n l6: "); - ADD_MEM (regs[25], 16); - ADD_STRING (" l7: "); - ADD_MEM (regs[26], 16); - ADD_STRING ("\n i0: "); - ADD_MEM (regs[27], 16); - ADD_STRING (" i1: "); - ADD_MEM (regs[28], 16); - ADD_STRING (" i2: "); - ADD_MEM (regs[29], 16); - ADD_STRING ("\n i3: "); - ADD_MEM (regs[30], 16); - ADD_STRING (" i4: "); - ADD_MEM (regs[31], 16); - ADD_STRING (" i5: "); - ADD_MEM (regs[32], 16); - ADD_STRING ("\n fp: "); - ADD_MEM (regs[33], 16); - ADD_STRING (" i7: "); - ADD_MEM (regs[34], 16); - ADD_STRING ("\n\n Mask: "); - ADD_MEM (regs[35], 16); - - if (f != NULL) - { - for (i = 0; i < 64; i++) - hexvalue (f->si_float_regs[i], fregs[i], 8); - hexvalue (f->si_fsr, fregs[64], 16); - hexvalue (f->si_gsr, fregs[66], 2); - hexvalue (f->si_fprs, fregs[67], 1); - ADD_STRING (" XFSR: "); - ADD_MEM (fregs[64], 16); - ADD_STRING (" GSR: "); - ADD_MEM (fregs[66], 2); - ADD_STRING (" FPRS: "); - ADD_MEM (fregs[67], 1); - ADD_STRING ("\n f0: "); - ADD_MEM (fregs[0], 16); - ADD_STRING (" f2: "); - ADD_MEM (fregs[2], 16); - ADD_STRING (" f4: "); - ADD_MEM (fregs[4], 16); - ADD_STRING ("\n f6: "); - ADD_MEM (fregs[6], 16); - ADD_STRING (" f8: "); - ADD_MEM (fregs[8], 16); - ADD_STRING (" f10: "); - ADD_MEM (fregs[10], 16); - ADD_STRING ("\n f12: "); - ADD_MEM (fregs[12], 16); - ADD_STRING (" f14: "); - ADD_MEM (fregs[14], 16); - ADD_STRING (" f16: "); - ADD_MEM (fregs[16], 16); - ADD_STRING ("\n f18: "); - ADD_MEM (fregs[18], 16); - ADD_STRING (" f20: "); - ADD_MEM (fregs[20], 16); - ADD_STRING (" f22: "); - ADD_MEM (fregs[22], 16); - ADD_STRING ("\n f24: "); - ADD_MEM (fregs[24], 16); - ADD_STRING (" f26: "); - ADD_MEM (fregs[26], 16); - ADD_STRING (" f28: "); - ADD_MEM (fregs[28], 16); - ADD_STRING ("\n f30: "); - ADD_MEM (fregs[30], 16); - ADD_STRING (" f32: "); - ADD_MEM (fregs[32], 16); - ADD_STRING (" f34: "); - ADD_MEM (fregs[34], 16); - ADD_STRING ("\n f36: "); - ADD_MEM (fregs[36], 16); - ADD_STRING (" f38: "); - ADD_MEM (fregs[38], 16); - ADD_STRING (" f40: "); - ADD_MEM (fregs[40], 16); - ADD_STRING ("\n f42: "); - ADD_MEM (fregs[42], 16); - ADD_STRING (" f44: "); - ADD_MEM (fregs[44], 16); - ADD_STRING (" f46: "); - ADD_MEM (fregs[46], 16); - ADD_STRING ("\n f48: "); - ADD_MEM (fregs[48], 16); - ADD_STRING (" f50: "); - ADD_MEM (fregs[50], 16); - ADD_STRING (" f52: "); - ADD_MEM (fregs[52], 16); - ADD_STRING ("\n f54: "); - ADD_MEM (fregs[54], 16); - ADD_STRING (" f56: "); - ADD_MEM (fregs[56], 16); - ADD_STRING (" f58: "); - ADD_MEM (fregs[58], 16); - ADD_STRING ("\n f60: "); - ADD_MEM (fregs[60], 16); - ADD_STRING (" f62: "); - ADD_MEM (fregs[62], 16); - } - - ADD_STRING ("\n"); - - /* Write the stuff out. */ - writev (fd, iov, nr); -} - - -#define REGISTER_DUMP register_dump (fd, ctx) diff --git a/sysdeps/unix/sysv/linux/x86_64/register-dump.h b/sysdeps/unix/sysv/linux/x86_64/register-dump.h deleted file mode 100644 index 04871124fd..0000000000 --- a/sysdeps/unix/sysv/linux/x86_64/register-dump.h +++ /dev/null @@ -1,345 +0,0 @@ -/* Dump registers. - Copyright (C) 2001-2022 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; if not, see - <https://www.gnu.org/licenses/>. */ - -#include <sys/uio.h> -#include <_itoa.h> - -/* We will print the register dump in this format: - - RAX: XXXXXXXXXXXXXXXX RBX: XXXXXXXXXXXXXXXX RCX: XXXXXXXXXXXXXXXX - RDX: XXXXXXXXXXXXXXXX RSI: XXXXXXXXXXXXXXXX RDI: XXXXXXXXXXXXXXXX - RBP: XXXXXXXXXXXXXXXX R8 : XXXXXXXXXXXXXXXX R9 : XXXXXXXXXXXXXXXX - R10: XXXXXXXXXXXXXXXX R11: XXXXXXXXXXXXXXXX R12: XXXXXXXXXXXXXXXX - R13: XXXXXXXXXXXXXXXX R14: XXXXXXXXXXXXXXXX R15: XXXXXXXXXXXXXXXX - RSP: XXXXXXXXXXXXXXXX - - RIP: XXXXXXXXXXXXXXXX EFLAGS: XXXXXXXX - - CS: XXXX DS: XXXX ES: XXXX FS: XXXX GS: XXXX - - Trap: XXXXXXXX Error: XXXXXXXX OldMask: XXXXXXXX - RSP/SIGNAL: XXXXXXXXXXXXXXXX CR2: XXXXXXXX - - FPUCW: XXXXXXXX FPUSW: XXXXXXXX TAG: XXXXXXXX - IPOFF: XXXXXXXX CSSEL: XXXX DATAOFF: XXXXXXXX DATASEL: XXXX - - ST(0) XXXX XXXXXXXXXXXXXXXX ST(1) XXXX XXXXXXXXXXXXXXXX - ST(2) XXXX XXXXXXXXXXXXXXXX ST(3) XXXX XXXXXXXXXXXXXXXX - ST(4) XXXX XXXXXXXXXXXXXXXX ST(5) XXXX XXXXXXXXXXXXXXXX - ST(6) XXXX XXXXXXXXXXXXXXXX ST(7) XXXX XXXXXXXXXXXXXXXX - - mxcsr: XXXX - XMM0 : XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XMM1 : XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX - XMM2 : XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XMM3 : XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX - XMM4 : XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XMM5 : XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX - XMM6 : XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XMM7 : XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX - XMM8 : XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XMM9 : XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX - XMM10: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XMM11: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX - XMM12: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XMM13: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX - XMM14: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XMM15: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX - - */ - -static void -hexvalue (unsigned long int value, char *buf, size_t len) -{ - char *cp = _itoa_word (value, buf + len, 16, 0); - while (cp > buf) - *--cp = '0'; -} - -static void -register_dump (int fd, ucontext_t *ctx) -{ - char regs[25][16]; - char fpregs[30][8]; - char xmmregs[16][32]; - struct iovec iov[147]; - size_t nr = 0; - int i; - -#define ADD_STRING(str) \ - iov[nr].iov_base = (char *) str; \ - iov[nr].iov_len = strlen (str); \ - ++nr -#define ADD_MEM(str, len) \ - iov[nr].iov_base = str; \ - iov[nr].iov_len = len; \ - ++nr - - /* Generate strings of register contents. */ - hexvalue (ctx->uc_mcontext.gregs[REG_RAX], regs[0], 16); - hexvalue (ctx->uc_mcontext.gregs[REG_RBX], regs[1], 16); - hexvalue (ctx->uc_mcontext.gregs[REG_RCX], regs[2], 16); - hexvalue (ctx->uc_mcontext.gregs[REG_RDX], regs[3], 16); - hexvalue (ctx->uc_mcontext.gregs[REG_RSI], regs[4], 16); - hexvalue (ctx->uc_mcontext.gregs[REG_RDI], regs[5], 16); - hexvalue (ctx->uc_mcontext.gregs[REG_RBP], regs[6], 16); - hexvalue (ctx->uc_mcontext.gregs[REG_R8], regs[7], 16); - hexvalue (ctx->uc_mcontext.gregs[REG_R9], regs[8], 16); - hexvalue (ctx->uc_mcontext.gregs[REG_R10], regs[9], 16); - hexvalue (ctx->uc_mcontext.gregs[REG_R11], regs[10], 16); - hexvalue (ctx->uc_mcontext.gregs[REG_R12], regs[11], 16); - hexvalue (ctx->uc_mcontext.gregs[REG_R13], regs[12], 16); - hexvalue (ctx->uc_mcontext.gregs[REG_R14], regs[13], 16); - hexvalue (ctx->uc_mcontext.gregs[REG_R15], regs[14], 16); - hexvalue (ctx->uc_mcontext.gregs[REG_RSP], regs[15], 16); - hexvalue (ctx->uc_mcontext.gregs[REG_RIP], regs[16], 16); - - hexvalue (ctx->uc_mcontext.gregs[REG_EFL], regs[17], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_CSGSFS] & 0xffff, regs[18], 4); - hexvalue ((ctx->uc_mcontext.gregs[REG_CSGSFS] >> 16) & 0xffff, regs[19], 4); - hexvalue ((ctx->uc_mcontext.gregs[REG_CSGSFS] >> 32) & 0xffff, regs[20], 4); - /* hexvalue (ctx->ss, regs[23], 4); */ - hexvalue (ctx->uc_mcontext.gregs[REG_TRAPNO], regs[21], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_ERR], regs[22], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_OLDMASK], regs[23], 8); - hexvalue (ctx->uc_mcontext.gregs[REG_CR2], regs[24], 8); - - /* Generate the output. */ - ADD_STRING ("Register dump:\n\n RAX: "); - ADD_MEM (regs[0], 16); - ADD_STRING (" RBX: "); - ADD_MEM (regs[1], 16); - ADD_STRING (" RCX: "); - ADD_MEM (regs[2], 16); - ADD_STRING ("\n RDX: "); - ADD_MEM (regs[3], 16); - ADD_STRING (" RSI: "); - ADD_MEM (regs[4], 16); - ADD_STRING (" RDI: "); - ADD_MEM (regs[5], 16); - ADD_STRING ("\n RBP: "); - ADD_MEM (regs[6], 16); - ADD_STRING (" R8 : "); - ADD_MEM (regs[7], 16); - ADD_STRING (" R9 : "); - ADD_MEM (regs[8], 16); - ADD_STRING ("\n R10: "); - ADD_MEM (regs[9], 16); - ADD_STRING (" R11: "); - ADD_MEM (regs[10], 16); - ADD_STRING (" R12: "); - ADD_MEM (regs[11], 16); - ADD_STRING ("\n R13: "); - ADD_MEM (regs[12], 16); - ADD_STRING (" R14: "); - ADD_MEM (regs[13], 16); - ADD_STRING (" R15: "); - ADD_MEM (regs[14], 16); - ADD_STRING ("\n RSP: "); - ADD_MEM (regs[15], 16); - ADD_STRING ("\n\n RIP: "); - ADD_MEM (regs[16], 16); - ADD_STRING (" EFLAGS: "); - ADD_MEM (regs[17], 8); - ADD_STRING ("\n\n CS: "); - ADD_MEM (regs[18], 4); - ADD_STRING (" FS: "); - ADD_MEM (regs[19], 4); - ADD_STRING (" GS: "); - ADD_MEM (regs[20], 4); - /* - ADD_STRING (" SS: "); - ADD_MEM (regs[23], 4); - */ - ADD_STRING ("\n\n Trap: "); - ADD_MEM (regs[21], 8); - ADD_STRING (" Error: "); - ADD_MEM (regs[22], 8); - ADD_STRING (" OldMask: "); - ADD_MEM (regs[23], 8); - ADD_STRING (" CR2: "); - ADD_MEM (regs[24], 8); - - if (ctx->uc_mcontext.fpregs != NULL) - { - - /* Generate output for the FPU control/status registers. */ - hexvalue (ctx->uc_mcontext.fpregs->cwd, fpregs[0], 8); - hexvalue (ctx->uc_mcontext.fpregs->swd, fpregs[1], 8); - hexvalue (ctx->uc_mcontext.fpregs->ftw, fpregs[2], 8); - hexvalue (ctx->uc_mcontext.fpregs->rip, fpregs[3], 8); - hexvalue (ctx->uc_mcontext.fpregs->rdp, fpregs[4], 8); - - ADD_STRING ("\n\n FPUCW: "); - ADD_MEM (fpregs[0], 8); - ADD_STRING (" FPUSW: "); - ADD_MEM (fpregs[1], 8); - ADD_STRING (" TAG: "); - ADD_MEM (fpregs[2], 8); - ADD_STRING ("\n RIP: "); - ADD_MEM (fpregs[3], 8); - ADD_STRING (" RDP: "); - ADD_MEM (fpregs[4], 8); - - /* Now the real FPU registers. */ - hexvalue (ctx->uc_mcontext.fpregs->_st[0].exponent, fpregs[5], 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[0].significand[3] << 16 - | ctx->uc_mcontext.fpregs->_st[0].significand[2], fpregs[6], - 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[0].significand[1] << 16 - | ctx->uc_mcontext.fpregs->_st[0].significand[0], fpregs[7], - 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[1].exponent, fpregs[8], 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[1].significand[3] << 16 - | ctx->uc_mcontext.fpregs->_st[1].significand[2], fpregs[9], - 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[1].significand[1] << 16 - | ctx->uc_mcontext.fpregs->_st[1].significand[0], fpregs[10], - 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[2].exponent, fpregs[11], 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[2].significand[3] << 16 - | ctx->uc_mcontext.fpregs->_st[2].significand[2], fpregs[12], - 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[2].significand[1] << 16 - | ctx->uc_mcontext.fpregs->_st[2].significand[0], fpregs[13], - 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[3].exponent, fpregs[14], 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[3].significand[3] << 16 - | ctx->uc_mcontext.fpregs->_st[3].significand[2], fpregs[15], - 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[3].significand[1] << 16 - | ctx->uc_mcontext.fpregs->_st[3].significand[0], fpregs[16], - 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[4].exponent, fpregs[17], 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[4].significand[3] << 16 - | ctx->uc_mcontext.fpregs->_st[4].significand[2], fpregs[18], - 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[4].significand[1] << 16 - | ctx->uc_mcontext.fpregs->_st[4].significand[0], fpregs[19], - 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[5].exponent, fpregs[20], 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[5].significand[3] << 16 - | ctx->uc_mcontext.fpregs->_st[5].significand[2], fpregs[21], - 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[5].significand[1] << 16 - | ctx->uc_mcontext.fpregs->_st[5].significand[0], fpregs[22], - 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[6].exponent, fpregs[23], 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[6].significand[3] << 16 - | ctx->uc_mcontext.fpregs->_st[6].significand[2], fpregs[24], - 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[6].significand[1] << 16 - | ctx->uc_mcontext.fpregs->_st[6].significand[0], fpregs[25], - 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[7].exponent, fpregs[26], 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[7].significand[3] << 16 - | ctx->uc_mcontext.fpregs->_st[7].significand[2], fpregs[27], - 8); - hexvalue (ctx->uc_mcontext.fpregs->_st[7].significand[1] << 16 - | ctx->uc_mcontext.fpregs->_st[7].significand[0], fpregs[28], - 8); - - hexvalue (ctx->uc_mcontext.fpregs->mxcsr, fpregs[29], 4); - - for (i = 0; i < 16; i++) - hexvalue (ctx->uc_mcontext.fpregs->_xmm[i].element[3] << 24 - | ctx->uc_mcontext.fpregs->_xmm[i].element[2] << 16 - | ctx->uc_mcontext.fpregs->_xmm[i].element[1] << 8 - | ctx->uc_mcontext.fpregs->_xmm[i].element[0], xmmregs[i], - 32); - - - ADD_STRING ("\n\n ST(0) "); - ADD_MEM (fpregs[5], 4); - ADD_STRING (" "); - ADD_MEM (fpregs[6], 8); - ADD_MEM (fpregs[7], 8); - ADD_STRING (" ST(1) "); - ADD_MEM (fpregs[8], 4); - ADD_STRING (" "); - ADD_MEM (fpregs[9], 8); - ADD_MEM (fpregs[10], 8); - ADD_STRING ("\n ST(2) "); - ADD_MEM (fpregs[11], 4); - ADD_STRING (" "); - ADD_MEM (fpregs[12], 8); - ADD_MEM (fpregs[13], 8); - ADD_STRING (" ST(3) "); - ADD_MEM (fpregs[14], 4); - ADD_STRING (" "); - ADD_MEM (fpregs[15], 8); - ADD_MEM (fpregs[16], 8); - ADD_STRING ("\n ST(4) "); - ADD_MEM (fpregs[17], 4); - ADD_STRING (" "); - ADD_MEM (fpregs[18], 8); - ADD_MEM (fpregs[19], 8); - ADD_STRING (" ST(5) "); - ADD_MEM (fpregs[20], 4); - ADD_STRING (" "); - ADD_MEM (fpregs[21], 8); - ADD_MEM (fpregs[22], 8); - ADD_STRING ("\n ST(6) "); - ADD_MEM (fpregs[23], 4); - ADD_STRING (" "); - ADD_MEM (fpregs[24], 8); - ADD_MEM (fpregs[25], 8); - ADD_STRING (" ST(7) "); - ADD_MEM (fpregs[27], 4); - ADD_STRING (" "); - ADD_MEM (fpregs[27], 8); - ADD_MEM (fpregs[28], 8); - - ADD_STRING ("\n mxcsr: "); - ADD_MEM (fpregs[29], 4); - - ADD_STRING ("\n XMM0: "); - ADD_MEM (xmmregs[0], 32); - ADD_STRING (" XMM1: "); - ADD_MEM (xmmregs[0], 32); - ADD_STRING ("\n XMM2: "); - ADD_MEM (xmmregs[0], 32); - ADD_STRING (" XMM3: "); - ADD_MEM (xmmregs[0], 32); - ADD_STRING ("\n XMM4: "); - ADD_MEM (xmmregs[0], 32); - ADD_STRING (" XMM5: "); - ADD_MEM (xmmregs[0], 32); - ADD_STRING ("\n XMM6: "); - ADD_MEM (xmmregs[0], 32); - ADD_STRING (" XMM7: "); - ADD_MEM (xmmregs[0], 32); - ADD_STRING ("\n XMM8: "); - ADD_MEM (xmmregs[0], 32); - ADD_STRING (" XMM9: "); - ADD_MEM (xmmregs[0], 32); - ADD_STRING ("\n XMM10: "); - ADD_MEM (xmmregs[0], 32); - ADD_STRING (" XMM11: "); - ADD_MEM (xmmregs[0], 32); - ADD_STRING ("\n XMM12: "); - ADD_MEM (xmmregs[0], 32); - ADD_STRING (" XMM13: "); - ADD_MEM (xmmregs[0], 32); - ADD_STRING ("\n XMM14: "); - ADD_MEM (xmmregs[0], 32); - ADD_STRING (" XMM15: "); - ADD_MEM (xmmregs[0], 32); - - } - - ADD_STRING ("\n"); - - /* Write the stuff out. */ - writev (fd, iov, nr); -} - - -#define REGISTER_DUMP register_dump (fd, ctx) |