static void store_register (int regno) { int ret, tid; struct pt_regs regs; if (!register_valid[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 >= A1_REGNUM && regno <= PC_REGNUM) read_register_gen (regno, (char *) ®s.uregs[regno]); ret = ptrace (PTRACE_SETREGS, tid, 0, ®s); if (ret < 0) { warning ("Unable to store general register."); return; } }
static void store_regs (void) { int ret, regno, tid; struct pt_regs regs; /* Get the thread id for the ptrace call. */ tid = GET_THREAD_ID (inferior_ptid); /* Fetch the general registers. */ ret = ptrace (PTRACE_GETREGS, tid, 0, ®s); if (ret < 0) { warning ("Unable to fetch general registers."); return; } for (regno = A1_REGNUM; regno <= PC_REGNUM; regno++) { if (register_valid[regno]) read_register_gen (regno, (char *) ®s.uregs[regno]); } ret = ptrace (PTRACE_SETREGS, tid, 0, ®s); if (ret < 0) { warning ("Unable to store general registers."); return; } }
static void store_fpregs (void) { int ret, regno, tid; FPA11 fp; /* Get the thread id for the ptrace call. */ tid = GET_THREAD_ID (inferior_ptid); /* Read the floating point state. */ ret = ptrace (PT_GETFPREGS, tid, 0, &fp); if (ret < 0) { warning ("Unable to fetch the floating point registers."); return; } /* Store fpsr. */ if (register_valid[FPS_REGNUM]) read_register_gen (FPS_REGNUM, (char *) &fp.fpsr); /* Store the floating point registers. */ for (regno = F0_REGNUM; regno <= F7_REGNUM; regno++) { fetch_nwfpe_register (regno, &fp); } ret = ptrace (PTRACE_SETFPREGS, tid, 0, &fp); if (ret < 0) { warning ("Unable to store floating point registers."); return; } }
static void store_nwfpe_single (unsigned int fn, FPA11 * fpa11) { unsigned int mem[3]; read_register_gen (F0_REGNUM + fn, (char *) &mem[0]); fpa11->fpreg[fn].fSingle = mem[0]; fpa11->fType[fn] = typeSingle; }
static void store_nwfpe_double (unsigned int fn, FPA11 * fpa11) { unsigned int mem[3]; read_register_gen (F0_REGNUM + fn, (char *) &mem[0]); fpa11->fpreg[fn].fDouble[1] = mem[0]; fpa11->fpreg[fn].fDouble[0] = mem[1]; fpa11->fType[fn] = typeDouble; }
void fill_gregset (gdb_gregset_t *gregsetp, int regno) { if (-1 == regno) { int regnum; for (regnum = A1_REGNUM; regnum <= PC_REGNUM; regnum++) read_register_gen (regnum, (char *) &(*gregsetp)[regnum]); } else if (regno >= A1_REGNUM && regno <= PC_REGNUM) read_register_gen (regno, (char *) &(*gregsetp)[regno]); if (PS_REGNUM == regno || -1 == regno) { if (arm_apcs_32) read_register_gen (PS_REGNUM, (char *) &(*gregsetp)[CPSR_REGNUM]); else read_register_gen (PC_REGNUM, (char *) &(*gregsetp)[PC_REGNUM]); } }
void store_nwfpe_extended (unsigned int fn, FPA11 * fpa11) { unsigned int mem[3]; read_register_gen (F0_REGNUM + fn, (char *) &mem[0]); fpa11->fpreg[fn].fExtended[0] = mem[0]; /* sign & exponent */ fpa11->fpreg[fn].fExtended[2] = mem[1]; /* ls bits */ fpa11->fpreg[fn].fExtended[1] = mem[2]; /* ms bits */ fpa11->fType[fn] = typeDouble; }
static void child_store_inferior_registers (int r) { if (r < 0) { for (r = 0; r < NUM_REGS; r++) child_store_inferior_registers (r); } else { read_register_gen (r, 0); } }
void fill_fpregset (gdb_fpregset_t *fpregsetp, int regno) { FPA11 *fp = (FPA11 *) fpregsetp; if (-1 == regno) { int regnum; for (regnum = F0_REGNUM; regnum <= F7_REGNUM; regnum++) store_nwfpe_register (regnum, fp); } else if (regno >= F0_REGNUM && regno <= F7_REGNUM) { store_nwfpe_register (regno, fp); return; } /* Store fpsr. */ if (FPS_REGNUM == regno || -1 == regno) read_register_gen (FPS_REGNUM, (char *) &fp->fpsr); }
void generic_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval) { if (!target_has_registers) error ("No registers."); /* Normal systems don't optimize out things with register numbers. */ if (optimized != NULL) *optimized = 0; if (addrp) /* default assumption: not found in memory */ *addrp = 0; /* Note: since the current frame's registers could only have been saved by frames INTERIOR TO the current frame, we skip examining the current frame itself: otherwise, we would be getting the previous frame's registers which were saved by the current frame. */ while (frame && ((frame = frame->next) != NULL)) { if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame)) { if (lval) /* found it in a CALL_DUMMY frame */ *lval = not_lval; if (raw_buffer) memcpy (raw_buffer, generic_find_dummy_frame (frame->pc, frame->frame) + REGISTER_BYTE (regnum), REGISTER_RAW_SIZE (regnum)); return; } FRAME_INIT_SAVED_REGS (frame); if (frame->saved_regs != NULL && frame->saved_regs[regnum] != 0) { if (lval) /* found it saved on the stack */ *lval = lval_memory; if (regnum == SP_REGNUM) { if (raw_buffer) /* SP register treated specially */ store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), frame->saved_regs[regnum]); } else { if (addrp) /* any other register */ *addrp = frame->saved_regs[regnum]; if (raw_buffer) read_memory (frame->saved_regs[regnum], raw_buffer, REGISTER_RAW_SIZE (regnum)); } return; } } /* If we get thru the loop to this point, it means the register was not saved in any frame. Return the actual live-register value. */ if (lval) /* found it in a live register */ *lval = lval_register; if (addrp) *addrp = REGISTER_BYTE (regnum); if (raw_buffer) read_register_gen (regnum, raw_buffer); }