static void m68kbsd_collect_gregset (const struct regcache *regcache, void *gregs, int regnum) { char *regs = gregs; int i; for (i = M68K_D0_REGNUM; i <= M68K_PC_REGNUM; i++) { if (regnum == -1 || regnum == i) regcache_raw_collect (regcache, i, regs + i * 4); } }
static void m68kbsd_collect_fpregset (struct regcache *regcache, void *fpregs, int regnum) { char *regs = fpregs; int i; for (i = M68K_FP0_REGNUM; i <= M68K_FPI_REGNUM; i++) { if (regnum == -1 || regnum == i) regcache_raw_collect (regcache, i, regs + m68kbsd_fpreg_offset (i)); } }
static void store_fp_regs (const struct regcache *regcache) { struct fpreg inferior_fp_registers; int ret; int regno; for (regno = 0; regno <= 15; regno++) regcache_raw_collect (regcache, regno + ARM_D0_REGNUM, (char *) inferior_fp_registers.fpr_vfp.vfp_regs + 8 * regno); regcache_raw_collect (regcache, ARM_FPSCR_REGNUM, (char *) &inferior_fp_registers.fpr_vfp.vfp_fpscr); ret = ptrace (PT_SETFPREGS, ptid_get_pid (inferior_ptid), (PTRACE_TYPE_ARG3) &inferior_fp_registers, ptid_get_lwp(inferior_ptid)); if (ret < 0) warning (_("unable to store floating-point registers")); }
void fill_gregset (gdb_gregset_t *gregsetp, int regno) { int regi; elf_greg_t *regp = (elf_greg_t *) gregsetp; struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); const int elf_ngreg = 48; /* Start with zeros. */ memset (regp, 0, elf_ngreg * sizeof (*regp)); for (regi = 0; regi < ppc_num_gprs; regi++) { if ((regno == -1) || regno == tdep->ppc_gp0_regnum + regi) right_fill_reg (tdep->ppc_gp0_regnum + regi, (regp + PT_R0 + regi)); } if ((regno == -1) || regno == PC_REGNUM) right_fill_reg (PC_REGNUM, regp + PT_NIP); if ((regno == -1) || regno == tdep->ppc_lr_regnum) right_fill_reg (tdep->ppc_lr_regnum, regp + PT_LNK); if ((regno == -1) || regno == tdep->ppc_cr_regnum) regcache_raw_collect (current_regcache, tdep->ppc_cr_regnum, regp + PT_CCR); if ((regno == -1) || regno == tdep->ppc_xer_regnum) regcache_raw_collect (current_regcache, tdep->ppc_xer_regnum, regp + PT_XER); if ((regno == -1) || regno == tdep->ppc_ctr_regnum) right_fill_reg (tdep->ppc_ctr_regnum, regp + PT_CTR); #ifdef PT_MQ if (((regno == -1) || regno == tdep->ppc_mq_regnum) && (tdep->ppc_mq_regnum != -1)) right_fill_reg (tdep->ppc_mq_regnum, regp + PT_MQ); #endif if ((regno == -1) || regno == tdep->ppc_ps_regnum) right_fill_reg (tdep->ppc_ps_regnum, regp + PT_MSR); }
void fill_fpregset (const struct regcache *regcache, fpregset_t *fpregsetp, int regno) { int regi; char *from, *to; struct gdbarch *gdbarch = get_regcache_arch (regcache); /* FIXME, this is wrong for the N32 ABI which has 64 bit FP regs. */ for (regi = gdbarch_fp0_regnum (gdbarch); regi < gdbarch_fp0_regnum (gdbarch) + 32; regi++) { if ((regno == -1) || (regno == regi)) { const int fp0_regnum = gdbarch_fp0_regnum (gdbarch); to = (char *) &(fpregsetp->__fp_r.__fp_regs[regi - fp0_regnum]); regcache_raw_collect (regcache, regi, to); } } if (regno == -1 || regno == mips_regnum (gdbarch)->fp_control_status) { char fsrbuf[8]; /* We can't fill the FSR register directly from the regcache, because there is a size issue: On one hand, fpregsetp->fp_csr is 32bits long, while the regcache expects a 64bits long buffer. So we use a buffer of the correct size and copy the register value from that buffer. */ regcache_raw_collect (regcache, mips_regnum (gdbarch)->fp_control_status, fsrbuf); memcpy (&fpregsetp->__fp_csr, fsrbuf + 4, 4); } }
static void ia64_fbsd_regcache_collect (struct regcache *regcache, int regno, void *regs) { int ofs; if (regno < 0 || regno >= NUM_REGS) return; ofs = reg_offset[regno]; if (regno == IA64_BSP_REGNUM) { uint64_t bsp, bspstore; regcache_raw_collect (regcache, regno, &bsp); regcache_raw_collect (regcache, IA64_BSPSTORE_REGNUM, &bspstore); *(uint64_t *)((char *)regs + ofs) = bsp - bspstore; } else { if (ofs >= 0) regcache_raw_collect (regcache, regno, (char*)regs + ofs); } }
void fill_fpregset (gdb_fpregset_t *fpregsetp, int regno) { int i; for (i = HPPA_FP0_REGNUM; i < HPPA_FP0_REGNUM + 32 * 2; i++) { /* Gross. fpregset_t is double, registers[x] has single precision reg. */ char *to = (char *) &((*fpregsetp)[(i - HPPA_FP0_REGNUM) / 2]); if ((i - HPPA_FP0_REGNUM) & 1) to += 4; regcache_raw_collect (current_regcache, i, to); } }
static void store_register (const struct regcache *regcache, int regno) { int ret, tid; elf_gregset_t regs; if (REG_VALID != regcache_register_status (regcache, regno)) return; /* Get the thread id for the ptrace call. */ tid = GET_THREAD_ID (inferior_ptid); /* Get the general registers from the process. */ ret = ptrace (PTRACE_GETREGS, tid, 0, ®s); if (ret < 0) { warning (_("Unable to fetch general registers.")); return; } if (regno >= ARM_A1_REGNUM && regno <= ARM_PC_REGNUM) regcache_raw_collect (regcache, regno, (char *) ®s[regno]); else if (arm_apcs_32 && regno == ARM_PS_REGNUM) regcache_raw_collect (regcache, regno, (char *) ®s[ARM_CPSR_GREGNUM]); else if (!arm_apcs_32 && regno == ARM_PS_REGNUM) regcache_raw_collect (regcache, ARM_PC_REGNUM, (char *) ®s[ARM_PC_REGNUM]); ret = ptrace (PTRACE_SETREGS, tid, 0, ®s); if (ret < 0) { warning (_("Unable to store general register.")); return; } }
void mipsnbsd_fill_fpreg (const struct regcache *regcache, char *fpregs, int regno) { struct gdbarch *gdbarch = get_regcache_arch (regcache); int i; for (i = gdbarch_fp0_regnum (gdbarch); i <= mips_regnum (gdbarch)->fp_control_status; i++) if ((regno == i || regno == -1) && ! gdbarch_cannot_store_register (gdbarch, i)) regcache_raw_collect (regcache, i, fpregs + ((i - gdbarch_fp0_regnum (gdbarch)) * mips_isa_regsize (gdbarch))); }
void fill_gregset (gdb_gregset_t *gregsetp, int regno) { int i; for (i = 0; i < sizeof (greg_map) / sizeof (greg_map[0]); i++) { int mregno = greg_map[i]; if (regno == -1 || regno == mregno) { regcache_raw_collect(current_regcache, mregno, &(*gregsetp)[i]); } } }
static void m68kbsd_collect_fpregset (const struct regcache *regcache, void *fpregs, int regnum) { struct gdbarch *gdbarch = get_regcache_arch (regcache); char *regs = fpregs; int i; for (i = M68K_FP0_REGNUM; i <= M68K_FPI_REGNUM; i++) { if (regnum == -1 || regnum == i) regcache_raw_collect (regcache, i, regs + m68kbsd_fpreg_offset (gdbarch, i)); } }
void arm_linux_collect_nwfpe (const struct regset *regset, const struct regcache *regcache, int regnum, void *regs_buf, size_t len) { gdb_byte *regs = regs_buf; int regno; for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++) if (regnum == -1 || regnum == regno) collect_nwfpe_register (regcache, regno, regs); if (regnum == ARM_FPS_REGNUM || regnum == -1) regcache_raw_collect (regcache, ARM_FPS_REGNUM, regs + INT_REGISTER_SIZE * ARM_FPS_REGNUM); }
void sparc32_collect_gregset (const struct sparc_gregset *gregset, const struct regcache *regcache, int regnum, void *gregs) { gdb_byte *regs = gregs; int i; if (regnum == SPARC32_PSR_REGNUM || regnum == -1) regcache_raw_collect (regcache, SPARC32_PSR_REGNUM, regs + gregset->r_psr_offset); if (regnum == SPARC32_PC_REGNUM || regnum == -1) regcache_raw_collect (regcache, SPARC32_PC_REGNUM, regs + gregset->r_pc_offset); if (regnum == SPARC32_NPC_REGNUM || regnum == -1) regcache_raw_collect (regcache, SPARC32_NPC_REGNUM, regs + gregset->r_npc_offset); if (regnum == SPARC32_Y_REGNUM || regnum == -1) regcache_raw_collect (regcache, SPARC32_Y_REGNUM, regs + gregset->r_y_offset); if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1) { int offset = gregset->r_g1_offset; /* %g0 is always zero. */ for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++) { if (regnum == i || regnum == -1) regcache_raw_collect (regcache, i, regs + offset); offset += 4; } } if ((regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM) || regnum == -1) { /* Not all of the register set variants include Locals and Inputs. For those that don't, we read them off the stack. */ if (gregset->r_l0_offset != -1) { int offset = gregset->r_l0_offset; for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++) { if (regnum == i || regnum == -1) regcache_raw_collect (regcache, i, regs + offset); offset += 4; } } } }
void i386bsd_collect_gregset (const struct regcache *regcache, void *gregs, int regnum) { char *regs = (char *) gregs; int i; for (i = 0; i < ARRAY_SIZE (i386bsd_r_reg_offset); i++) { if (regnum == -1 || regnum == i) { int offset = i386bsd_r_reg_offset[i]; if (offset != -1) regcache_raw_collect (regcache, i, regs + offset); } } }
static void store_regs (const struct regcache *regcache) { struct gdbarch *gdbarch = get_regcache_arch (regcache); struct reg inferior_registers; int ret; int regno; for (regno = ARM_A1_REGNUM; regno < ARM_SP_REGNUM; regno++) regcache_raw_collect (regcache, regno, (char *) &inferior_registers.r[regno]); regcache_raw_collect (regcache, ARM_SP_REGNUM, (char *) &inferior_registers.r_sp); regcache_raw_collect (regcache, ARM_LR_REGNUM, (char *) &inferior_registers.r_lr); if (arm_apcs_32) { regcache_raw_collect (regcache, ARM_PC_REGNUM, (char *) &inferior_registers.r_pc); regcache_raw_collect (regcache, ARM_PS_REGNUM, (char *) &inferior_registers.r_cpsr); } else { unsigned pc_val; unsigned psr_val; regcache_raw_collect (regcache, ARM_PC_REGNUM, (char *) &pc_val); regcache_raw_collect (regcache, ARM_PS_REGNUM, (char *) &psr_val); pc_val = gdbarch_addr_bits_remove (gdbarch, pc_val); psr_val ^= gdbarch_addr_bits_remove (gdbarch, psr_val); inferior_registers.r_pc = pc_val | psr_val; } ret = ptrace (PT_SETREGS, ptid_get_pid (inferior_ptid), (PTRACE_TYPE_ARG3) &inferior_registers, 0); if (ret < 0) warning (_("unable to store general registers")); }
static void store_xtregs (struct regcache *regcache, int regnum) { int tid = ptid_get_lwp (inferior_ptid); const xtensa_regtable_t *ptr; char xtregs [XTENSA_ELF_XTREG_SIZE]; if (ptrace (PTRACE_GETXTREGS, tid, 0, (long)&xtregs) < 0) perror_with_name (_("Couldn't get extended registers")); for (ptr = xtensa_regmap_table; ptr->name; ptr++) if (regnum == ptr->gdb_regnum || regnum == -1) regcache_raw_collect (regcache, ptr->gdb_regnum, xtregs + ptr->ptrace_offset); if (ptrace (PTRACE_SETXTREGS, tid, 0, (long)&xtregs) < 0) perror_with_name (_("Couldn't write extended registers")); }
static void store_register (int regno) { /* This isn't really an address. But ptrace thinks of it as one. */ CORE_ADDR regaddr; char mess[128]; /* For messages */ int i; unsigned int offset; /* Offset of registers within the u area. */ int tid; char buf[MAX_REGISTER_SIZE]; if (CANNOT_STORE_REGISTER (regno)) { return; } /* Overload thread id onto process id */ tid = TIDGET (inferior_ptid); if (tid == 0) tid = PIDGET (inferior_ptid); /* no thread id, just use process id */ offset = U_REGS_OFFSET; regaddr = register_addr (regno, offset); /* Put the contents of regno into a local buffer */ regcache_raw_collect (current_regcache, regno, buf); /* Store the local buffer into the inferior a chunk at the time. */ for (i = 0; i < register_size (current_gdbarch, regno); i += sizeof (PTRACE_XFER_TYPE)) { errno = 0; ptrace (PT_WRITE_U, tid, (PTRACE_ARG3_TYPE) regaddr, *(PTRACE_XFER_TYPE *) (buf + i)); regaddr += sizeof (PTRACE_XFER_TYPE); if (errno != 0) { sprintf (mess, "writing register %s (#%d)", REGISTER_NAME (regno), regno); perror_with_name (mess); } } }
/* Given a pointer to a floating point register set in /proc format (fpregset_t *), update the register specified by REGNO from gdb's idea of the current floating point register set. If REGNO is -1, update them all. */ void fill_fpregset (gdb_fpregset_t *fpregsetp, int regno) { int regi; struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); bfd_byte *fpp = (void *) fpregsetp; if (ppc_floating_point_unit_p (current_gdbarch)) { for (regi = 0; regi < ppc_num_fprs; regi++) { if ((regno == -1) || (regno == tdep->ppc_fp0_regnum + regi)) regcache_raw_collect (current_regcache, tdep->ppc_fp0_regnum + regi, fpp + 8 * regi); } if (regno == -1 || regno == tdep->ppc_fpscr_regnum) right_fill_reg (tdep->ppc_fpscr_regnum, (fpp + 8 * 32)); } }
static void amd64dfly_collect_uthread (const struct regcache *regcache, int regnum, CORE_ADDR addr) { gdb_byte buf[8]; int i; gdb_assert (regnum >= -1); for (i = 0; i < ARRAY_SIZE (amd64dfly_jmp_buf_reg_offset); i++) { if (amd64dfly_jmp_buf_reg_offset[i] != -1 && (regnum == -1 || regnum == i)) { regcache_raw_collect (regcache, i, buf); write_memory (addr + amd64dfly_jmp_buf_reg_offset[i], buf, 8); } } }
static void i386fbsd_collect_uthread (const struct regcache *regcache, int regnum, CORE_ADDR addr) { char buf[4]; int i; gdb_assert (regnum >= -1); for (i = 0; i < ARRAY_SIZE (i386fbsd_jmp_buf_reg_offset); i++) { if (i386fbsd_jmp_buf_reg_offset[i] != -1 && (regnum == -1 || regnum == i)) { regcache_raw_collect (regcache, i, buf); write_memory (addr + i386fbsd_jmp_buf_reg_offset[i], buf, 4); } } }
void amd64_collect_native_gregset (const struct regcache *regcache, void *gregs, int regnum) { char *regs = gregs; struct gdbarch *gdbarch = get_regcache_arch (regcache); int num_regs = amd64_native_gregset64_num_regs; int i; if (gdbarch_ptr_bit (gdbarch) == 32) { num_regs = amd64_native_gregset32_num_regs; /* Make sure %eax, %ebx, %ecx, %edx, %esi, %edi, %ebp, %esp and %eip get zero-extended to 64 bits. */ for (i = 0; i <= I386_EIP_REGNUM; i++) { if (regnum == -1 || regnum == i) memset (regs + amd64_native_gregset_reg_offset (gdbarch, i), 0, 8); } /* Ditto for %cs, %ss, %ds, %es, %fs, and %gs. */ for (i = I386_CS_REGNUM; i <= I386_GS_REGNUM; i++) { if (regnum == -1 || regnum == i) memset (regs + amd64_native_gregset_reg_offset (gdbarch, i), 0, 8); } } if (num_regs > gdbarch_num_regs (gdbarch)) num_regs = gdbarch_num_regs (gdbarch); for (i = 0; i < num_regs; i++) { if (regnum == -1 || regnum == i) { int offset = amd64_native_gregset_reg_offset (gdbarch, i); if (offset != -1) regcache_raw_collect (regcache, i, regs + offset); } } }
static void store_register (const struct regcache *regcache, int regno) { struct gdbarch *gdbarch = get_regcache_arch (regcache); pid_t tid; int val; if (gdbarch_cannot_store_register (gdbarch, regno)) return; tid = get_ptrace_pid (regcache_get_ptid (regcache)); errno = 0; regcache_raw_collect (regcache, regno, &val); ptrace (PTRACE_POKEUSER, tid, hppa_linux_register_addr (regno, 0), val); if (errno != 0) error (_("Couldn't write register %s (#%d): %s."), gdbarch_register_name (gdbarch, regno), regno, safe_strerror (errno)); }
static void store_register (int regno) { int tid; int val; if (CANNOT_STORE_REGISTER (regno)) return; /* GNU/Linux LWP ID's are process ID's. */ tid = TIDGET (inferior_ptid); if (tid == 0) tid = PIDGET (inferior_ptid); /* Not a threaded program. */ errno = 0; regcache_raw_collect (current_regcache, regno, &val); ptrace (PTRACE_POKEUSER, tid, register_addr (regno, 0), val); if (errno != 0) error (_("Couldn't write register %s (#%d): %s."), REGISTER_NAME (regno), regno, safe_strerror (errno)); }
static void ppc_ravenscar_generic_store_registers (const struct ravenscar_reg_info *reg_info, struct regcache *regcache, int regnum) { struct gdbarch *gdbarch = get_regcache_arch (regcache); int buf_size = register_size (gdbarch, regnum); gdb_byte buf[buf_size]; ULONGEST register_address; if (register_in_thread_descriptor_p (reg_info, regnum)) register_address = ptid_get_tid (inferior_ptid) + reg_info->context_offsets [regnum]; else return; regcache_raw_collect (regcache, regnum, buf); write_memory (register_address, buf, buf_size); }
static void ia64_linux_store_register (const struct regcache *regcache, int regnum) { struct gdbarch *gdbarch = get_regcache_arch (regcache); CORE_ADDR addr; size_t size; PTRACE_TYPE_RET *buf; int pid, i; if (ia64_cannot_store_register (gdbarch, regnum)) return; /* Cater for systems like GNU/Linux, that implement threads as separate processes. */ pid = ptid_get_lwp (inferior_ptid); if (pid == 0) pid = ptid_get_pid (inferior_ptid); /* This isn't really an address, but ptrace thinks of it as one. */ addr = ia64_register_addr (gdbarch, regnum); size = register_size (gdbarch, regnum); gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0); buf = alloca (size); /* Write the register contents into the inferior a chunk at a time. */ regcache_raw_collect (regcache, regnum, buf); for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++) { errno = 0; ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)addr, buf[i]); if (errno != 0) error (_("Couldn't write register %s (#%d): %s."), gdbarch_register_name (gdbarch, regnum), regnum, safe_strerror (errno)); addr += sizeof (PTRACE_TYPE_RET); } }
static void store_register (const struct regcache *regcache, int regno) { int tid; int val; gdb_assert (!have_ptrace_getregs); if (regmap[regno] == -1) return; /* GNU/Linux LWP ID's are process ID's. */ tid = TIDGET (inferior_ptid); if (tid == 0) tid = PIDGET (inferior_ptid); /* Not a threaded program. */ errno = 0; regcache_raw_collect (regcache, regno, &val); ptrace (PTRACE_POKEUSER, tid, 4 * regmap[regno], val); if (errno != 0) error (_("Couldn't write register %s (#%d): %s."), gdbarch_register_name (get_regcache_arch (regcache), regno), regno, safe_strerror (errno)); }
static void store_register (const struct regcache *regcache, int regno) { struct gdbarch *gdbarch = get_regcache_arch (regcache); int tid; int val; if (gdbarch_cannot_store_register (gdbarch, regno)) return; /* GNU/Linux LWP ID's are process ID's. */ tid = TIDGET (inferior_ptid); if (tid == 0) tid = PIDGET (inferior_ptid); /* Not a threaded program. */ errno = 0; regcache_raw_collect (regcache, regno, &val); ptrace (PTRACE_POKEUSER, tid, hppa_linux_register_addr (regno, 0), val); if (errno != 0) error (_("Couldn't write register %s (#%d): %s."), gdbarch_register_name (gdbarch, regno), regno, safe_strerror (errno)); }
static void inf_ptrace_store_register (int regnum) { CORE_ADDR addr; size_t size; PTRACE_TYPE_RET *buf; int pid, i; if (CANNOT_STORE_REGISTER (regnum)) return; /* Cater for systems like GNU/Linux, that implement threads as separate processes. */ pid = ptid_get_lwp (inferior_ptid); if (pid == 0) pid = ptid_get_pid (inferior_ptid); /* This isn't really an address, but ptrace thinks of it as one. */ addr = inf_ptrace_register_u_offset (regnum); size = register_size (current_gdbarch, regnum); gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0); buf = alloca (size); /* Write the register contents into the inferior a chunk at a time. */ regcache_raw_collect (current_regcache, regnum, buf); for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++) { errno = 0; ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)addr, buf[i]); if (errno != 0) error (_("Couldn't write register %s (#%d): %s."), REGISTER_NAME (regnum), regnum, safe_strerror (errno)); addr += sizeof (PTRACE_TYPE_RET); } }
void collect_nwfpe_register (const struct regcache *regcache, int regno, gdb_byte *regs) { gdb_byte *reg_data; gdb_byte reg_tag; gdb_byte buf[FP_REGISTER_SIZE]; regcache_raw_collect (regcache, regno, buf); /* NOTE drow/2006-06-07: This code uses the tag already in the register buffer. I've preserved that when moving the code from the native file to the target file. But this doesn't always make sense. */ reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE; reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET]; switch (reg_tag) { case typeSingle: memcpy (reg_data, buf, 4); break; case typeDouble: memcpy (reg_data, buf + 4, 4); memcpy (reg_data + 4, buf, 4); break; case typeExtended: memcpy (reg_data, buf, 4); memcpy (reg_data + 4, buf + 8, 4); memcpy (reg_data + 8, buf + 4, 4); break; default: break; } }
static void store_register (int regnum) { CORE_ADDR addr; size_t size; PTRACE_TYPE_RET *buf; int tid, i; if (CANNOT_STORE_REGISTER (regnum)) return; /* GNU/Linux LWP ID's are process ID's. */ tid = TIDGET (inferior_ptid); if (tid == 0) tid = PIDGET (inferior_ptid); /* Not a threaded program. */ /* This isn't really an address. But ptrace thinks of it as one. */ addr = register_addr (regnum, U_REGS_OFFSET); size = register_size (current_gdbarch, regnum); gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0); buf = alloca (size); /* Write the register contents into the inferior a chunk at the time. */ regcache_raw_collect (current_regcache, regnum, buf); for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++) { errno = 0; ptrace (PT_WRITE_U, tid, (PTRACE_TYPE_ARG3) addr, buf[i]); if (errno != 0) error (_("Couldn't write register %s (#%d): %s."), REGISTER_NAME (regnum), regnum, safe_strerror (errno)); addr += sizeof (PTRACE_TYPE_RET); } }