static void ppc_fill_gregset (void *buf) { int i; for (i = 0; i < 32; i++) collect_register (i, (char *) buf + ppc_regmap[i]); for (i = 64; i < 70; i++) collect_register (i, (char *) buf + ppc_regmap[i]); }
static void s390_supply_ptrace_register (struct regcache *regcache, int regno, const char *buf) { int size = register_size (regcache->tdesc, regno); if (size < sizeof (long)) { const struct regs_info *regs_info = (*the_low_target.regs_info) (); struct usrregs_info *usr = regs_info->usrregs; int regaddr = usr->regmap[regno]; if ((regno ^ 1) < usr->num_regs && usr->regmap[regno ^ 1] == regaddr) { supply_register (regcache, regno & ~1, buf); supply_register (regcache, (regno & ~1) + 1, buf + sizeof (long) - size); } else if (regaddr == PT_PSWMASK) { /* Convert 8-byte PSW mask to 4 bytes by setting bit 12 and copying the basic addressing mode into the PSW address. */ char *mask = alloca (size); char *addr = alloca (register_size (regcache->tdesc, regno ^ 1)); memcpy (mask, buf, size); mask[1] |= 0x8; supply_register (regcache, regno, mask); collect_register (regcache, regno ^ 1, addr); addr[0] &= ~0x80; addr[0] |= (buf[size] & 0x80); supply_register (regcache, regno ^ 1, addr); } else if (regaddr == PT_PSWADDR) { /* Convert 8-byte PSW address to 4 bytes by truncating, but keeping the addressing mode bit (which was set from the mask). */ char *addr = alloca (size); char amode; collect_register (regcache, regno, addr); amode = addr[0] & 0x80; memcpy (addr, buf + sizeof (long) - size, size); addr[0] &= ~0x80; addr[0] |= amode; supply_register (regcache, regno, addr); } else if ((regaddr >= PT_GPR0 && regaddr <= PT_GPR15) || regaddr == PT_ORIGGPR2) supply_register (regcache, regno, buf + sizeof (long) - size); else supply_register (regcache, regno, buf); } else supply_register (regcache, regno, buf); }
void arm_fill_gregset (struct regcache *regcache, void *buf) { int i; uint32_t *regs = (uint32_t *) buf; for (i = ARM_A1_REGNUM; i <= ARM_PC_REGNUM; i++) collect_register (regcache, i, ®s[i]); collect_register (regcache, ARM_PS_REGNUM, ®s[16]); }
static void aarch64_fill_fpregset (struct regcache *regcache, void *buf) { struct user_fpsimd_state *regset = buf; int i; for (i = 0; i < AARCH64_V_REGS_NUM; i++) collect_register (regcache, AARCH64_V0_REGNO + i, ®set->vregs[i]); collect_register (regcache, AARCH64_FPSR_REGNO, ®set->fpsr); collect_register (regcache, AARCH64_FPCR_REGNO, ®set->fpcr); }
static void aarch64_fill_gregset (struct regcache *regcache, void *buf) { struct user_pt_regs *regset = buf; int i; for (i = 0; i < AARCH64_X_REGS_NUM; i++) collect_register (regcache, AARCH64_X0_REGNO + i, ®set->regs[i]); collect_register (regcache, AARCH64_SP_REGNO, ®set->sp); collect_register (regcache, AARCH64_PC_REGNO, ®set->pc); collect_register (regcache, AARCH64_CPSR_REGNO, ®set->pstate); }
static void ppc_collect_ptrace_register (int regno, char *buf) { int size = register_size (regno); memset (buf, 0, sizeof (long)); if (size < sizeof (long)) collect_register (regno, buf + sizeof (long) - size); else collect_register (regno, buf); }
/* Store our register values back into the inferior. If REGNO is -1, do this for all registers. Otherwise, REGNO specifies which register (so we can save time). */ static void usr_store_inferior_registers (int regno) { CORE_ADDR regaddr; int i, size; char *buf; if (regno >= 0) { if (regno >= the_low_target.num_regs) return; if ((*the_low_target.cannot_store_register) (regno) == 1) return; regaddr = register_addr (regno); if (regaddr == -1) return; errno = 0; size = (register_size (regno) + sizeof (PTRACE_XFER_TYPE) - 1) & - sizeof (PTRACE_XFER_TYPE); buf = alloca (size); memset (buf, 0, size); if (the_low_target.left_pad_xfer && register_size (regno) < sizeof (PTRACE_XFER_TYPE)) collect_register (regno, (buf + sizeof (PTRACE_XFER_TYPE) - register_size (regno))); else collect_register (regno, buf); for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE)) { errno = 0; ptrace (PTRACE_POKEUSER, inferior_pid, (PTRACE_ARG3_TYPE) regaddr, *(PTRACE_XFER_TYPE *) (buf + i)); if (errno != 0) { if ((*the_low_target.cannot_store_register) (regno) == 0) { char *err = strerror (errno); char *msg = alloca (strlen (err) + 128); sprintf (msg, "writing register %d: %s", regno, err); error (msg); return; } } regaddr += sizeof (PTRACE_XFER_TYPE); } } else for (regno = 0; regno < the_low_target.num_regs; regno++) usr_store_inferior_registers (regno); }
static void lynx_ppc_fill_fpregset (struct regcache *regcache, char *buf) { int i; /* f0 - f31 */ for (i = 0; i < 32; i++) collect_register (regcache, F0_REGNUM + i, buf + offsetof (usr_fcontext_t, ufc_freg[i])); /* fpscr */ collect_register (regcache, FPSCR_REGNUM, buf + offsetof (usr_fcontext_t, ufc_fpscr)); }
void arm_fill_gregset (struct regcache *regcache, void *buf) { int i; uint32_t *regs = (uint32_t *) buf; uint32_t cpsr = regs[ARM_CPSR_GREGNUM]; for (i = ARM_A1_REGNUM; i <= ARM_PC_REGNUM; i++) collect_register (regcache, i, ®s[i]); collect_register (regcache, ARM_PS_REGNUM, ®s[ARM_CPSR_GREGNUM]); /* Keep reserved bits bit 20 to bit 23. */ regs[ARM_CPSR_GREGNUM] = ((regs[ARM_CPSR_GREGNUM] & 0xff0fffff) | (cpsr & 0x00f00000)); }
static void arm_fill_wmmxregset (void *buf) { int i; if (!(arm_hwcap & HWCAP_IWMMXT)) return; for (i = 0; i < 16; i++) collect_register (arm_num_regs + i, (char *) buf + i * 8); /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */ for (i = 0; i < 6; i++) collect_register (arm_num_regs + i + 16, (char *) buf + 16 * 8 + i * 4); }
/* When PC is at a syscall instruction, return the PC of the next instruction to be executed. */ static CORE_ADDR get_next_pcs_syscall_next_pc (struct arm_get_next_pcs *self) { CORE_ADDR next_pc = 0; CORE_ADDR pc = regcache_read_pc (self->regcache); int is_thumb = arm_is_thumb_mode (); ULONGEST svc_number = 0; struct regcache *regcache = self->regcache; if (is_thumb) { collect_register (regcache, 7, &svc_number); next_pc = pc + 2; } else { unsigned long this_instr; unsigned long svc_operand; target_read_memory (pc, (unsigned char *) &this_instr, 4); svc_operand = (0x00ffffff & this_instr); if (svc_operand) /* OABI. */ { svc_number = svc_operand - 0x900000; } else /* EABI. */ { collect_register (regcache, 7, &svc_number); } next_pc = pc + 4; } /* This is a sigreturn or sigreturn_rt syscall. */ if (svc_number == __NR_sigreturn || svc_number == __NR_rt_sigreturn) { /* SIGRETURN or RT_SIGRETURN may affect the arm thumb mode, so update IS_THUMB. */ next_pc = arm_sigreturn_next_pc (regcache, svc_number, &is_thumb); } /* Addresses for calling Thumb functions have the bit 0 set. */ if (is_thumb) next_pc = MAKE_THUMB_ADDR (next_pc); return next_pc; }
static void nto_store_registers (struct regcache *regcache, int regno) { procfs_greg greg; int err; ptid_t ptid; TRACE ("%s (regno:%d)\n", __func__, regno); if (current_inferior == NULL) { TRACE ("current_inferior is NULL\n"); return; } ptid = thread_to_gdb_id (current_inferior); if (!nto_set_thread (ptid)) return; memset (&greg, 0, sizeof (greg)); for (regno = 0; regno != the_low_target.num_regs; ++regno) { const unsigned int regoffset = the_low_target.register_offset (regno); collect_register (regcache, regno, ((char *)&greg) + regoffset); } err = devctl (nto_inferior.ctl_fd, DCMD_PROC_SETGREG, &greg, sizeof (greg), 0); if (err != EOK) TRACE ("Error: setting registers.\n"); }
static inline void collect_unsigned_int_64 (int regnum, unsigned long long *addr) { char buf[8]; collect_register (regnum, buf); *addr = extract_unsigned_integer (buf, 8); }
static void xtensa_fill_gregset (struct regcache *regcache, void *buf) { elf_greg_t* rset = (elf_greg_t*)buf; int ar0_regnum; char *ptr; int i; /* Take care of AR registers. */ ar0_regnum = find_regno ("ar0"); ptr = (char*)&rset[R_A0]; for (i = ar0_regnum; i < ar0_regnum + XCHAL_NUM_AREGS; i++) { collect_register (regcache, i, ptr); ptr += register_size(i); } /* Loop registers, if hardware has it. */ #if XCHAL_HAVE_LOOP collect_register_by_name (regcache, "lbeg", (char*)&rset[R_LBEG]); collect_register_by_name (regcache, "lend", (char*)&rset[R_LEND]); collect_register_by_name (regcache, "lcount", (char*)&rset[R_LCOUNT]); #endif collect_register_by_name (regcache, "sar", (char*)&rset[R_SAR]); collect_register_by_name (regcache, "pc", (char*)&rset[R_PC]); collect_register_by_name (regcache, "ps", (char*)&rset[R_PS]); collect_register_by_name (regcache, "windowbase", (char*)&rset[R_WB]); collect_register_by_name (regcache, "windowstart", (char*)&rset[R_WS]); }
static void s390_fill_gregset (void *buf) { int i; for (i = 0; i < 34; i++) collect_register (i, (char *) buf + s390_regmap[i]); }
static void arm_fill_wmmxregset (struct regcache *regcache, void *buf) { int i; if (regcache->tdesc != tdesc_arm_with_iwmmxt) return; for (i = 0; i < 16; i++) collect_register (regcache, arm_num_regs + i, (char *) buf + i * 8); /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */ for (i = 0; i < 6; i++) collect_register (regcache, arm_num_regs + i + 16, (char *) buf + 16 * 8 + i * 4); }
static inline void collect_unsigned_int (int regnum, unsigned int *addr) { char buf[4]; collect_register (regnum, buf); *addr = extract_unsigned_integer (buf, 4); }
static void mips_collect_register (struct regcache *regcache, int use_64bit, int regno, union mips_register *reg) { union mips_register tmp_reg; if (use_64bit) { collect_register (regcache, regno, &tmp_reg.reg64); *reg = tmp_reg; } else { collect_register (regcache, regno, &tmp_reg.reg32); reg->reg64 = tmp_reg.reg32; } }
static void x86_64_fill_gregset (void *buf) { int i; for (i = 0; i < X86_64_NUM_GREGS; i++) collect_register (i, ((char *) buf) + x86_64_regmap[i]); }
static void sh_fill_gregset (struct regcache *regcache, void *buf) { int i; for (i = 0; i < 23; i++) if (sh_regmap[i] != -1) collect_register (regcache, i, (char *) buf + sh_regmap[i]); }
static void nios2_collect_register (int regno, union nios2_register *reg) { union nios2_register tmp_reg; collect_register (regno, &tmp_reg.reg32); reg->reg32 = tmp_reg.reg32; }
static void m68k_fill_gregset (void *buf) { int i; for (i = 0; i < m68k_num_gregs; i++) collect_register (i, (char *) buf + m68k_regmap[i]); }
static void m68k_fill_gregset (struct regcache *regcache, void *buf) { int i; for (i = 0; i < m68k_num_gregs; i++) collect_register (regcache, i, (char *) buf + m68k_regmap[i]); }
static void nios2_collect_register (struct regcache *regcache, int regno, union nios2_register *reg) { union nios2_register tmp_reg; collect_register (regcache, regno, &tmp_reg.reg32); reg->reg32 = tmp_reg.reg32; }
static void i386_fill_gregset (void *buf) { int i; for (i = 0; i < i386_num_regs; i++) collect_register (i, ((char *) buf) + i386_regmap[i]); }
static void s390_fill_vxrs_low (struct regcache *regcache, void *buf) { int v0 = find_regno (regcache->tdesc, "v0l"); int i; for (i = 0; i < 16; i++) collect_register (regcache, v0 + i, (char *) buf + 8 * i); }
static void s390_fill_vxrs_high (struct regcache *regcache, void *buf) { int v16 = find_regno (regcache->tdesc, "v16"); int i; for (i = 0; i < 16; i++) collect_register (regcache, v16 + i, (char *) buf + 16 * i); }
static void tile_fill_gregset (struct regcache *regcache, void *buf) { int i; for (i = 0; i < tile_num_regs; i++) if (tile_regmap[i] != -1) collect_register (regcache, i, ((uint_reg_t *) buf) + tile_regmap[i]); }
static void m68k_fill_fpregset (struct regcache *regcache, void *buf) { int i; for (i = m68k_num_gregs; i < m68k_num_regs; i++) collect_register (regcache, i, ((char *) buf + (m68k_regmap[i] - m68k_regmap[m68k_num_gregs]))); }
static void arm_fill_gregset (struct regcache *regcache, void *buf) { int i; for (i = 0; i < arm_num_regs; i++) if (arm_regmap[i] != -1) collect_register (regcache, i, ((char *) buf) + arm_regmap[i]); }