void mipsfbsd_fill_reg (char *regs, int regno) { int i; for (i = 0; i <= PC_REGNUM; i++) if ((regno == i || regno == -1) && ! CANNOT_STORE_REGISTER (i)) regcache_collect (i, regs + (i * mips_regsize (current_gdbarch))); }
void mipsfbsd_fill_fpreg (char *fpregs, int regno) { int i; for (i = FP0_REGNUM; i <= mips_regnum (current_gdbarch)->fp_control_status; i++) if ((regno == i || regno == -1) && ! CANNOT_STORE_REGISTER (i)) regcache_collect (i, fpregs + ((i - FP0_REGNUM) * mips_regsize (current_gdbarch))); }
void store_inferior_registers (int regno) { register unsigned int regaddr; char buf[80]; register int i; unsigned int offset = U_REGS_OFFSET; int scratch; if (regno >= 0) { if (CANNOT_STORE_REGISTER (regno)) return; regaddr = register_addr (regno, offset); errno = 0; if (regno == PCOQ_HEAD_REGNUM || regno == PCOQ_TAIL_REGNUM) { scratch = *(int *) ®isters[REGISTER_BYTE (regno)] | 0x3; ptrace (PT_WUREGS, PIDGET (inferior_ptid), (PTRACE_ARG3_TYPE) regaddr, scratch); if (errno != 0) { /* Error, even if attached. Failing to write these two registers is pretty serious. */ sprintf (buf, "writing register number %d", regno); perror_with_name (buf); } } else for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int)) { errno = 0; ptrace (PT_WUREGS, PIDGET (inferior_ptid), (PTRACE_ARG3_TYPE) regaddr, *(int *) ®isters[REGISTER_BYTE (regno) + i]); if (errno != 0) { /* Warning, not error, in case we are attached; sometimes the kernel doesn't let us at the registers. */ char *err = safe_strerror (errno); char *msg = alloca (strlen (err) + 128); sprintf (msg, "writing register %s: %s", REGISTER_NAME (regno), err); warning (msg); return; } regaddr += sizeof (int); } } else for (regno = 0; regno < NUM_REGS; regno++) store_inferior_registers (regno); }
void alphabsd_fill_fpreg (char *fpregs, int regno) { int i; for (i = FP0_REGNUM; i < FP0_REGNUM + NUM_FPREGS; i++) if ((regno == i || regno == -1) && ! CANNOT_STORE_REGISTER (i)) regcache_collect (i, fpregs + ((i - FP0_REGNUM) * 8)); if (regno == ALPHA_FPCR_REGNUM || regno == -1) regcache_collect (ALPHA_FPCR_REGNUM, fpregs + (32 * 8)); }
void alphabsd_fill_reg (char *regs, int regno) { int i; for (i = 0; i < NUM_GREGS; i++) if ((regno == i || regno == -1) && ! CANNOT_STORE_REGISTER (i)) regcache_collect (i, regs + (i * 8)); /* The PC travels in the ZERO slot. */ if (regno == PC_REGNUM || regno == -1) regcache_collect (PC_REGNUM, regs + (31 * 8)); }
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); } } }
void store_inferior_registers (int regno) { int reglo, reghi; int i; unsigned long ecp; if (regno == -1) { reglo = 0; reghi = NUM_REGS - 1; } else reglo = reghi = regno; ecp = registers_addr (PIDGET (inferior_ptid)); for (regno = reglo; regno <= reghi; regno++) { int ptrace_fun = PTRACE_POKEUSER; if (CANNOT_STORE_REGISTER (regno)) continue; #ifdef M68K ptrace_fun = regno == SP_REGNUM ? PTRACE_POKEUSP : PTRACE_POKEUSER; #endif for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (int)) { unsigned int reg; reg = *(unsigned int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno) + i]; errno = 0; ptrace (ptrace_fun, PIDGET (inferior_ptid), (PTRACE_ARG3_TYPE) (ecp + regmap[regno] + i), reg); if (errno) perror_with_name ("ptrace(PTRACE_POKEUSP)"); } } }
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 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); } }
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); } }
void store_inferior_registers (int regno) { unsigned int regaddr; char buf[80]; int i; unsigned int offset = U_REGS_OFFSET; int scratch; if (regno >= 0) { unsigned int addr, len, offset; if (CANNOT_STORE_REGISTER (regno)) return; offset = 0; len = DEPRECATED_REGISTER_RAW_SIZE (regno); /* Requests for register zero actually want the save_state's ss_flags member. As RM says: "Oh, what a hack!" */ if (regno == 0) { save_state_t ss; addr = HPPAH_OFFSETOF (save_state_t, ss_flags); len = sizeof (ss.ss_flags); /* Note that ss_flags is always an int, no matter what DEPRECATED_REGISTER_RAW_SIZE(0) says. Assuming all HP-UX PA machines are big-endian, put it at the least significant end of the value, and zap the rest of the buffer. */ offset = DEPRECATED_REGISTER_RAW_SIZE (0) - len; } /* Floating-point registers come from the ss_fpblock area. */ else if (regno >= HPPA_FP0_REGNUM) addr = (HPPAH_OFFSETOF (save_state_t, ss_fpblock) + (DEPRECATED_REGISTER_BYTE (regno) - DEPRECATED_REGISTER_BYTE (HPPA_FP0_REGNUM))); /* Wide registers come from the ss_wide area. I think it's more PC to test (ss_flags & SS_WIDEREGS) to select between ss_wide and ss_narrow than to use the raw register size. But checking ss_flags would require an extra ptrace call for every register reference. Bleah. */ else if (len == 8) addr = (HPPAH_OFFSETOF (save_state_t, ss_wide) + DEPRECATED_REGISTER_BYTE (regno)); /* Narrow registers come from the ss_narrow area. Note that ss_narrow starts with gr1, not gr0. */ else if (len == 4) addr = (HPPAH_OFFSETOF (save_state_t, ss_narrow) + (DEPRECATED_REGISTER_BYTE (regno) - DEPRECATED_REGISTER_BYTE (1))); else internal_error (__FILE__, __LINE__, "hppah-nat.c (write_register): unexpected register size"); #ifdef GDB_TARGET_IS_HPPA_20W /* Unbelieveable. The PC head and tail must be written in 64bit hunks or we will get an error. Worse yet, the oddball ptrace/ttrace layering will not allow us to perform a 64bit register store. What a crock. */ if (regno == HPPA_PCOQ_HEAD_REGNUM || regno == HPPA_PCOQ_TAIL_REGNUM && len == 8) { CORE_ADDR temp; temp = *(CORE_ADDR *)&deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)]; /* Set the priv level (stored in the low two bits of the PC. */ temp |= 0x3; ttrace_write_reg_64 (PIDGET (inferior_ptid), (CORE_ADDR)addr, (CORE_ADDR)&temp); /* If we fail to write the PC, give a true error instead of just a warning. */ if (errno != 0) { char *err = safe_strerror (errno); char *msg = alloca (strlen (err) + 128); sprintf (msg, "writing `%s' register: %s", REGISTER_NAME (regno), err); perror_with_name (msg); } return; } /* Another crock. HPUX complains if you write a nonzero value to the high part of IPSW. What will it take for HP to catch a clue about building sensible interfaces? */ if (regno == HPPA_IPSW_REGNUM && len == 8) *(int *)&deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)] = 0; #endif for (i = 0; i < len; i += sizeof (int)) { errno = 0; call_ptrace (PT_WUREGS, PIDGET (inferior_ptid), (PTRACE_ARG3_TYPE) addr + i, *(int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno) + i]); if (errno != 0) { /* Warning, not error, in case we are attached; sometimes the kernel doesn't let us at the registers. */ char *err = safe_strerror (errno); char *msg = alloca (strlen (err) + 128); sprintf (msg, "writing `%s' register: %s", REGISTER_NAME (regno), err); /* If we fail to write the PC, give a true error instead of just a warning. */ if (regno == HPPA_PCOQ_HEAD_REGNUM || regno == HPPA_PCOQ_TAIL_REGNUM) perror_with_name (msg); else warning (msg); return; } } } else for (regno = 0; regno < NUM_REGS; regno++) store_inferior_registers (regno); }