values in the GDB's register array. */
static void
-store_gregs_to_thread (const struct regcache *regcache)
+store_gregs_to_thread (const struct regcache *regcache, ptid_t ptid)
{
int ret, tid;
elf_gregset_t regs;
/* Make sure REGS can hold all registers contents on both aarch64
and arm. */
gdb_static_assert (sizeof (regs) >= 18 * 4);
- tid = ptid_get_lwp (inferior_ptid);
+ tid = ptid_get_lwp (ptid);
iovec.iov_base = ®s;
if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
values in the GDB's register array. */
static void
-store_fpregs_to_thread (const struct regcache *regcache)
+store_fpregs_to_thread (const struct regcache *regcache, ptid_t ptid)
{
int ret, tid;
elf_fpregset_t regs;
/* Make sure REGS can hold all VFP registers contents on both aarch64
and arm. */
gdb_static_assert (sizeof regs >= VFP_REGS_SIZE);
- tid = ptid_get_lwp (inferior_ptid);
+ tid = ptid_get_lwp (ptid);
iovec.iov_base = ®s;
static void
aarch64_linux_store_inferior_registers (struct target_ops *ops,
struct regcache *regcache,
- int regno)
+ ptid_t ptid, int regno)
{
if (regno == -1)
{
- store_gregs_to_thread (regcache);
- store_fpregs_to_thread (regcache);
+ store_gregs_to_thread (regcache, ptid);
+ store_fpregs_to_thread (regcache, ptid);
}
else if (regno < AARCH64_V0_REGNUM)
- store_gregs_to_thread (regcache);
+ store_gregs_to_thread (regcache, ptid);
else
- store_fpregs_to_thread (regcache);
+ store_fpregs_to_thread (regcache, ptid);
}
/* Fill register REGNO (if it is a general-purpose register) in
static void
aix_thread_store_registers (struct target_ops *ops,
- struct regcache *regcache, int regno)
+ struct regcache *regcache,
+ ptid_t ptid, int regno)
{
struct thread_info *thread;
pthdb_tid_t tid;
struct target_ops *beneath = find_target_beneath (ops);
- if (!PD_TID (inferior_ptid))
- beneath->to_store_registers (beneath, regcache, regno);
+ if (!PD_TID (ptid))
+ beneath->to_store_registers (beneath, regcache, ptid, regno);
else
{
- thread = find_thread_ptid (inferior_ptid);
+ thread = find_thread_ptid (ptid);
tid = thread->priv->tid;
if (tid == PTHDB_INVALID_TID)
static void
amd64_linux_store_inferior_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum)
+ struct regcache *regcache,
+ ptid_t ptid, int regnum)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int tid;
/* GNU/Linux LWP ID's are process ID's. */
- tid = ptid_get_lwp (inferior_ptid);
+ tid = ptid_get_lwp (ptid);
if (tid == 0)
- tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
+ tid = ptid_get_pid (ptid); /* Not a threaded program. */
if (regnum == -1 || amd64_native_gregset_supplies_p (gdbarch, regnum))
{
the contents from regcache. */
static void
-store_fpregs (const struct regcache *regcache)
+store_fpregs (const struct regcache *regcache, ptid_t ptid)
{
int ret, regno, tid;
gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
/* Get the thread id for the ptrace call. */
- tid = ptid_get_lwp (inferior_ptid);
+ tid = ptid_get_lwp (ptid);
/* Read the floating point state. */
if (have_ptrace_getregset == TRIBOOL_TRUE)
}
static void
-store_regs (const struct regcache *regcache)
+store_regs (const struct regcache *regcache, ptid_t ptid)
{
int ret, regno, tid;
elf_gregset_t regs;
/* Get the thread id for the ptrace call. */
- tid = ptid_get_lwp (inferior_ptid);
+ tid = ptid_get_lwp (ptid);
/* Fetch the general registers. */
if (have_ptrace_getregset == TRIBOOL_TRUE)
}
static void
-store_wmmx_regs (const struct regcache *regcache)
+store_wmmx_regs (const struct regcache *regcache, ptid_t ptid)
{
char regbuf[IWMMXT_REGS_SIZE];
int ret, regno, tid;
/* Get the thread id for the ptrace call. */
- tid = ptid_get_lwp (inferior_ptid);
+ tid = ptid_get_lwp (ptid);
ret = ptrace (PTRACE_GETWMMXREGS, tid, 0, regbuf);
if (ret < 0)
}
static void
-store_vfp_regs (const struct regcache *regcache)
+store_vfp_regs (const struct regcache *regcache, ptid_t ptid)
{
gdb_byte regbuf[VFP_REGS_SIZE];
int ret, regno, tid;
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
/* Get the thread id for the ptrace call. */
- tid = ptid_get_lwp (inferior_ptid);
+ tid = ptid_get_lwp (ptid);
if (have_ptrace_getregset == TRIBOOL_TRUE)
{
static void
arm_linux_store_inferior_registers (struct target_ops *ops,
- struct regcache *regcache, int regno)
+ struct regcache *regcache,
+ ptid_t ptid, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
if (-1 == regno)
{
- store_regs (regcache);
+ store_regs (regcache, ptid);
if (tdep->have_wmmx_registers)
- store_wmmx_regs (regcache);
+ store_wmmx_regs (regcache, ptid);
if (tdep->vfp_register_count > 0)
- store_vfp_regs (regcache);
+ store_vfp_regs (regcache, ptid);
if (tdep->have_fpa_registers)
- store_fpregs (regcache);
+ store_fpregs (regcache, ptid);
}
else
{
if (regno < ARM_F0_REGNUM || regno == ARM_PS_REGNUM)
- store_regs (regcache);
+ store_regs (regcache, ptid);
else if ((regno >= ARM_F0_REGNUM) && (regno <= ARM_FPS_REGNUM))
- store_fpregs (regcache);
+ store_fpregs (regcache, ptid);
else if (tdep->have_wmmx_registers
&& regno >= ARM_WR0_REGNUM && regno <= ARM_WCGR7_REGNUM)
- store_wmmx_regs (regcache);
+ store_wmmx_regs (regcache, ptid);
else if (tdep->vfp_register_count > 0
&& regno >= ARM_D0_REGNUM
&& regno <= ARM_D0_REGNUM + tdep->vfp_register_count)
- store_vfp_regs (regcache);
+ store_vfp_regs (regcache, ptid);
}
}
static void
-store_register (const struct regcache *regcache, int regno)
+store_register (const struct regcache *regcache, ptid_t ptid, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
struct reg inferior_registers;
int ret;
- ret = ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+ ret = ptrace (PT_GETREGS, ptid_get_pid (ptid),
(PTRACE_TYPE_ARG3) &inferior_registers, 0);
if (ret < 0)
break;
}
- ret = ptrace (PT_SETREGS, ptid_get_pid (inferior_ptid),
+ ret = ptrace (PT_SETREGS, ptid_get_pid (ptid),
(PTRACE_TYPE_ARG3) &inferior_registers, 0);
if (ret < 0)
inferior_registers.r_pc = pc_val | psr_val;
}
- ret = ptrace (PT_SETREGS, ptid_get_pid (inferior_ptid),
+ ret = ptrace (PT_SETREGS, ptid_get_pid (ptid),
(PTRACE_TYPE_ARG3) &inferior_registers, 0);
if (ret < 0)
}
static void
-store_fp_register (const struct regcache *regcache, int regno)
+store_fp_register (const struct regcache *regcache, ptid_t ptid, int regno)
{
struct fpreg inferior_fp_registers;
int ret;
- ret = ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),
+ ret = ptrace (PT_GETFPREGS, ptid_get_pid (ptid),
(PTRACE_TYPE_ARG3) &inferior_fp_registers, 0);
if (ret < 0)
break;
}
- ret = ptrace (PT_SETFPREGS, ptid_get_pid (inferior_ptid),
+ ret = ptrace (PT_SETFPREGS, ptid_get_pid (ptid),
(PTRACE_TYPE_ARG3) &inferior_fp_registers, 0);
if (ret < 0)
}
static void
-store_fp_regs (const struct regcache *regcache)
+store_fp_regs (const struct regcache *regcache, ptid_t ptid)
{
struct fpreg inferior_fp_registers;
int ret;
regcache_raw_collect (regcache, ARM_FPS_REGNUM,
(char *) &inferior_fp_registers.fpr_fpsr);
- ret = ptrace (PT_SETFPREGS, ptid_get_pid (inferior_ptid),
+ ret = ptrace (PT_SETFPREGS, ptid_get_pid (ptid),
(PTRACE_TYPE_ARG3) &inferior_fp_registers, 0);
if (ret < 0)
static void
armnbsd_store_registers (struct target_ops *ops,
- struct regcache *regcache, int regno)
+ struct regcache *regcache,
+ ptid_t ptid, int regno)
{
if (regno >= 0)
{
if (regno < ARM_F0_REGNUM || regno > ARM_FPS_REGNUM)
- store_register (regcache, regno);
+ store_register (regcache, regno, ptid);
else
- store_fp_register (regcache, regno);
+ store_fp_register (regcache, regno, ptid);
}
else
{
- store_regs (regcache);
- store_fp_regs (regcache);
+ store_regs (regcache, ptid);
+ store_fp_regs (regcache, ptid);
}
}
static void
bsd_uthread_store_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum)
+ struct regcache *regcache,
+ ptid_t ptid, int regnum)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
struct bsd_uthread_ops *uthread_ops
= (struct bsd_uthread_ops *) gdbarch_data (gdbarch, bsd_uthread_data);
struct target_ops *beneath = find_target_beneath (ops);
- ptid_t ptid = inferior_ptid;
CORE_ADDR addr = ptid_get_tid (ptid);
CORE_ADDR active_addr;
{
/* Updating the thread that is currently running; pass the
request to the layer beneath. */
- beneath->to_store_registers (beneath, regcache, regnum);
+ beneath->to_store_registers (beneath, regcache, ptid, regnum);
}
}
/* Store one register. */
static void
-store_register (const struct regcache *regcache, int regno)
+store_register (const struct regcache *regcache, ptid_t ptid, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int tid;
return;
/* GNU/Linux LWP ID's are process ID's. */
- tid = ptid_get_lwp (inferior_ptid);
+ tid = ptid_get_lwp (ptid);
if (tid == 0)
- tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
+ tid = ptid_get_pid (ptid); /* Not a threaded program. */
errno = 0;
regcache_raw_collect (regcache, regno, &val);
static void
hppa_linux_store_inferior_registers (struct target_ops *ops,
- struct regcache *regcache, int regno)
+ struct regcache *regcache,
+ ptid_t ptid, int regno)
{
if (-1 == regno)
{
for (regno = 0;
regno < gdbarch_num_regs (get_regcache_arch (regcache));
regno++)
- store_register (regcache, regno);
+ store_register (regcache, regno, ptid);
}
else
{
- store_register (regcache, regno);
+ store_register (regcache, regno, ptid);
}
}
/* Store one register. */
static void
-store_register (const struct regcache *regcache, int regno)
+store_register (const struct regcache *regcache, ptid_t ptid, int regno)
{
int tid;
int val;
return;
/* GNU/Linux LWP ID's are process ID's. */
- tid = ptid_get_lwp (inferior_ptid);
+ tid = ptid_get_lwp (ptid);
if (tid == 0)
- tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
+ tid = ptid_get_pid (ptid); /* Not a threaded program. */
errno = 0;
regcache_raw_collect (regcache, regno, &val);
registers). */
static void
i386_linux_store_inferior_registers (struct target_ops *ops,
- struct regcache *regcache, int regno)
+ struct regcache *regcache,
+ ptid_t ptid, int regno)
{
int tid;
for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
if (regno == -1 || regno == i)
- store_register (regcache, i);
+ store_register (regcache, ptid, i);
return;
}
/* GNU/Linux LWP ID's are process ID's. */
- tid = ptid_get_lwp (inferior_ptid);
+ tid = ptid_get_lwp (ptid);
if (tid == 0)
- tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
+ tid = ptid_get_pid (ptid); /* Not a threaded program. */
/* Use the PTRACE_SETFPXREGS requests whenever possible, since it
transfers more registers in one system call. But remember that
/* Store register REGNUM into the inferior. */
static void
-ia64_linux_store_register (const struct regcache *regcache, int regnum)
+ia64_linux_store_register (const struct regcache *regcache,
+ ptid_t ptid, int regnum)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
CORE_ADDR addr;
/* Cater for systems like GNU/Linux, that implement threads as
separate processes. */
- pid = ptid_get_lwp (inferior_ptid);
+ pid = ptid_get_lwp (ptid);
if (pid == 0)
- pid = ptid_get_pid (inferior_ptid);
+ pid = ptid_get_pid (ptid);
/* This isn't really an address, but ptrace thinks of it as one. */
addr = ia64_register_addr (gdbarch, regnum);
static void
ia64_linux_store_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum)
+ struct regcache *regcache,
+ ptid_t ptid, int regnum)
{
if (regnum == -1)
for (regnum = 0;
regnum < gdbarch_num_regs (get_regcache_arch (regcache));
regnum++)
- ia64_linux_store_register (regcache, regnum);
+ ia64_linux_store_register (regcache, ptid, regnum);
else
- ia64_linux_store_register (regcache, regnum);
+ ia64_linux_store_register (regcache, ptid, regnum);
}
static void
inf_child_store_inferior_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum)
+ struct regcache *regcache,
+ ptid_t ptid, int regnum)
{
}
/* Store register REGNUM into the inferior. */
static void
-inf_ptrace_store_register (const struct regcache *regcache, int regnum)
+inf_ptrace_store_register (const struct regcache *regcache,
+ ptid_t ptid, int regnum)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
CORE_ADDR addr;
/* Cater for systems like GNU/Linux, that implement threads as
separate processes. */
- pid = ptid_get_lwp (inferior_ptid);
+ pid = ptid_get_lwp (ptid);
if (pid == 0)
- pid = ptid_get_pid (inferior_ptid);
+ pid = ptid_get_pid (ptid);
size = register_size (gdbarch, regnum);
gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
static void
inf_ptrace_store_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum)
+ struct regcache *regcache,
+ ptid_t ptid, int regnum)
{
if (regnum == -1)
for (regnum = 0;
regnum < gdbarch_num_regs (get_regcache_arch (regcache));
regnum++)
- inf_ptrace_store_register (regcache, regnum);
+ inf_ptrace_store_register (regcache, ptid, regnum);
else
- inf_ptrace_store_register (regcache, regnum);
+ inf_ptrace_store_register (regcache, ptid, regnum);
}
/* Create a "traditional" ptrace target. REGISTER_U_OFFSET should be
/* Store one register. */
static void
-store_register (const struct regcache *regcache, int regno)
+store_register (const struct regcache *regcache, ptid_t ptid, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
long regaddr, val;
gdb_byte buf[M68K_MAX_REGISTER_SIZE];
/* Overload thread id onto process id. */
- tid = ptid_get_lwp (inferior_ptid);
+ tid = ptid_get_lwp (ptid);
if (tid == 0)
- tid = ptid_get_pid (inferior_ptid); /* no thread id, just use
+ tid = ptid_get_pid (ptid); /* no thread id, just use
process id. */
regaddr = 4 * regmap[regno];
Otherwise, REGNO specifies which register (so we can save time). */
static void
-old_store_inferior_registers (const struct regcache *regcache, int regno)
+old_store_inferior_registers (const struct regcache *regcache,
+ ptid_t ptid, int regno)
{
if (regno >= 0)
{
- store_register (regcache, regno);
+ store_register (regcache, ptid, regno);
}
else
{
regno < gdbarch_num_regs (get_regcache_arch (regcache));
regno++)
{
- store_register (regcache, regno);
+ store_register (regcache, ptid, regno);
}
}
}
registers). */
static void
m68k_linux_store_inferior_registers (struct target_ops *ops,
- struct regcache *regcache, int regno)
+ struct regcache *regcache,
+ ptid_t ptid, int regno)
{
int tid;
SETREGS request isn't available. */
if (! have_ptrace_getregs)
{
- old_store_inferior_registers (regcache, regno);
+ old_store_inferior_registers (regcache, ptid, regno);
return;
}
/* GNU/Linux LWP ID's are process ID's. */
- tid = ptid_get_lwp (inferior_ptid);
+ tid = ptid_get_lwp (ptid);
if (tid == 0)
- tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
+ tid = ptid_get_pid (ptid); /* Not a threaded program. */
/* Use the PTRACE_SETFPREGS requests whenever possible, since it
transfers more registers in one system call. But remember that
static void (*super_fetch_registers) (struct target_ops *,
struct regcache *, ptid_t, int);
static void (*super_store_registers) (struct target_ops *,
- struct regcache *, int);
+ struct regcache *, ptid_t, int);
static void (*super_close) (struct target_ops *);
static void
mips64_linux_regsets_store_registers (struct target_ops *ops,
- struct regcache *regcache, int regno)
+ struct regcache *regcache,
+ ptid_t ptid, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int is_fp, is_dsp;
else
is_dsp = 0;
- tid = ptid_get_lwp (inferior_ptid);
+ tid = ptid_get_lwp (ptid);
if (tid == 0)
- tid = ptid_get_pid (inferior_ptid);
+ tid = ptid_get_pid (ptid);
if (regno == -1 || (!is_fp && !is_dsp))
{
}
if (is_dsp)
- super_store_registers (ops, regcache, regno);
+ super_store_registers (ops, regcache, ptid, regno);
else if (regno == -1 && have_dsp)
{
for (regi = mips_regnum (gdbarch)->dspacc;
regi < mips_regnum (gdbarch)->dspacc + 6;
regi++)
- super_store_registers (ops, regcache, regi);
- super_store_registers (ops, regcache, mips_regnum (gdbarch)->dspctl);
+ super_store_registers (ops, regcache, ptid, regi);
+ super_store_registers (ops, regcache, ptid, mips_regnum (gdbarch)->dspctl);
}
}
static void
mips64_linux_store_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum)
+ struct regcache *regcache,
+ ptid_t ptid, int regnum)
{
/* Unless we already know that PTRACE_GETREGS does not work, try it. */
if (have_ptrace_regsets)
- mips64_linux_regsets_store_registers (ops, regcache, regnum);
+ mips64_linux_regsets_store_registers (ops, regcache, ptid, regnum);
/* If we know, or just found out, that PTRACE_GETREGS does not work, fall
back to PTRACE_PEEKUSER. */
if (!have_ptrace_regsets)
- super_store_registers (ops, regcache, regnum);
+ super_store_registers (ops, regcache, ptid, regnum);
}
/* Return the address in the core dump or inferior of register
static void
ppc_linux_store_inferior_registers (struct target_ops *ops,
- struct regcache *regcache, int regno)
+ struct regcache *regcache,
+ ptid_t ptid, int regno)
{
/* Overload thread id onto process id. */
- int tid = ptid_get_lwp (inferior_ptid);
+ int tid = ptid_get_lwp (ptid);
/* No thread id, just use process id. */
if (tid == 0)
- tid = ptid_get_pid (inferior_ptid);
+ tid = ptid_get_pid (ptid);
if (regno >= 0)
store_register (regcache, tid, regno);
static void
ppcnbsd_store_inferior_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum)
+ struct regcache *regcache,
+ ptid_t ptid, int regnum)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
{
struct reg regs;
- if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+ if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
ppc_collect_gregset (&ppcnbsd_gregset, regcache,
regnum, ®s, sizeof regs);
- if (ptrace (PT_SETREGS, ptid_get_pid (inferior_ptid),
+ if (ptrace (PT_SETREGS, ptid_get_pid (ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't write registers"));
}
{
struct fpreg fpregs;
- if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),
+ if (ptrace (PT_GETFPREGS, ptid_get_pid (ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get FP registers"));
ppc_collect_fpregset (&ppcnbsd_fpregset, regcache,
regnum, &fpregs, sizeof fpregs);
- if (ptrace (PT_SETFPREGS, ptid_get_pid (inferior_ptid),
+ if (ptrace (PT_SETFPREGS, ptid_get_pid (ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't set FP registers"));
}
static void
ppcobsd_store_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum)
+ struct regcache *regcache,
+ ptid_t ptid, int regnum)
{
struct reg regs;
- if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+ if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
regnum, ®s, sizeof regs);
#endif
- if (ptrace (PT_SETREGS, ptid_get_pid (inferior_ptid),
+ if (ptrace (PT_SETREGS, ptid_get_pid (ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't write registers"));
{
struct fpreg fpregs;
- if (ptrace (PT_GETFPREGS, ptid_get_pid (inferior_ptid),
+ if (ptrace (PT_GETFPREGS, ptid_get_pid (ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't get floating point status"));
ppc_collect_fpregset (&ppcobsd_fpregset, regcache,
regnum, &fpregs, sizeof fpregs);
- if (ptrace (PT_SETFPREGS, ptid_get_pid (inferior_ptid),
+ if (ptrace (PT_SETFPREGS, ptid_get_pid (ptid),
(PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
perror_with_name (_("Couldn't write floating point status"));
}
static void
ppc_ravenscar_generic_store_registers
(const struct ravenscar_reg_info *reg_info,
- struct regcache *regcache, int regnum)
+ struct regcache *regcache, ptid_t ptid, int regnum)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int buf_size = register_size (gdbarch, regnum);
if (register_in_thread_descriptor_p (reg_info, regnum))
register_address
- = ptid_get_tid (inferior_ptid) + reg_info->context_offsets [regnum];
+ = ptid_get_tid (ptid) + reg_info->context_offsets [regnum];
else
return;
for most PowerPC targets. */
static void
-ppc_ravenscar_powerpc_store_registers (struct regcache *regcache, int regnum)
+ppc_ravenscar_powerpc_store_registers (struct regcache *regcache, ptid_t ptid,
+ int regnum)
{
- ppc_ravenscar_generic_store_registers (&ppc_reg_info, regcache, regnum);
+ ppc_ravenscar_generic_store_registers (&ppc_reg_info, regcache, ptid, regnum);
}
/* The ravenscar_arch_ops vector for most PowerPC targets. */
for E500 targets. */
static void
-ppc_ravenscar_e500_store_registers (struct regcache *regcache, int regnum)
+ppc_ravenscar_e500_store_registers (struct regcache *regcache, ptid_t ptid,
+ int regnum)
{
- ppc_ravenscar_generic_store_registers (&e500_reg_info, regcache, regnum);
+ ppc_ravenscar_generic_store_registers (&e500_reg_info, regcache, ptid,
+ regnum);
}
/* The ravenscar_arch_ops vector for E500 targets. */
ps_err_e
ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, const prgregset_t gregset)
{
- struct cleanup *old_chain = save_inferior_ptid ();
struct regcache *regcache;
+ ptid_t ptid = ptid_build (ptid_get_pid (ph->ptid), lwpid, 0);
- inferior_ptid = ptid_build (ptid_get_pid (ph->ptid), lwpid, 0);
- regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
-
+ regcache = get_thread_arch_regcache (ptid, target_gdbarch ());
supply_gregset (regcache, (const gdb_gregset_t *) gregset);
- target_store_registers (regcache, -1);
+ target_store_registers (regcache, ptid, -1);
- do_cleanups (old_chain);
return PS_OK;
}
ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
const gdb_prfpregset_t *fpregset)
{
- struct cleanup *old_chain = save_inferior_ptid ();
struct regcache *regcache;
+ ptid_t ptid = ptid_build (ptid_get_pid (ph->ptid), lwpid, 0);
- inferior_ptid = ptid_build (ptid_get_pid (ph->ptid), lwpid, 0);
- regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
-
+ regcache = get_thread_arch_regcache (ptid, target_gdbarch ());
supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
- target_store_registers (regcache, -1);
+ target_store_registers (regcache, ptid, -1);
- do_cleanups (old_chain);
return PS_OK;
}
static void procfs_fetch_registers (struct target_ops *,
struct regcache *, ptid_t, int);
static void procfs_store_registers (struct target_ops *,
- struct regcache *, int);
+ struct regcache *, ptid_t, int);
static void procfs_pass_signals (struct target_ops *self,
int, unsigned char *);
static void procfs_kill_inferior (struct target_ops *ops);
static void
procfs_store_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum)
+ struct regcache *regcache,
+ ptid_t ptid, int regnum)
{
gdb_gregset_t *gregs;
procinfo *pi;
- int pid = ptid_get_pid (inferior_ptid);
- int tid = ptid_get_lwp (inferior_ptid);
+ int pid = ptid_get_pid (ptid);
+ int tid = ptid_get_lwp (ptid);
struct gdbarch *gdbarch = get_regcache_arch (regcache);
pi = find_procinfo_or_die (pid, tid);
if (pi == NULL)
error (_("procfs: store_registers: failed to find procinfo for %s"),
- target_pid_to_str (inferior_ptid));
+ target_pid_to_str (ptid));
gregs = proc_get_gregs (pi);
if (gregs == NULL)
static char *ravenscar_extra_thread_info (struct target_ops *self,
struct thread_info *tp);
static int ravenscar_thread_alive (struct target_ops *ops, ptid_t ptid);
-static void ravenscar_store_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum);
static void ravenscar_prepare_to_store (struct target_ops *self,
struct regcache *regcache);
static void ravenscar_resume (struct target_ops *ops, ptid_t ptid, int step,
static void
ravenscar_store_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum)
+ struct regcache *regcache,
+ ptid_t ptid, int regnum)
{
struct target_ops *beneath = find_target_beneath (ops);
if (!ravenscar_runtime_initialized ()
- || ptid_equal (inferior_ptid, base_magic_null_ptid)
- || ptid_equal (inferior_ptid, ravenscar_running_thread ()))
- beneath->to_store_registers (beneath, regcache, regnum);
+ || ptid_equal (ptid, base_magic_null_ptid)
+ || ptid_equal (ptid, ravenscar_running_thread ()))
+ beneath->to_store_registers (beneath, regcache, ptid, regnum);
else
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
struct ravenscar_arch_ops *arch_ops
= gdbarch_ravenscar_ops (gdbarch);
- arch_ops->to_store_registers (regcache, regnum);
+ arch_ops->to_store_registers (regcache, ptid, regnum);
}
}
struct ravenscar_arch_ops
{
void (*to_fetch_registers) (struct regcache *, ptid_t, int);
- void (*to_store_registers) (struct regcache *, int);
+ void (*to_store_registers) (struct regcache *, ptid_t, int);
void (*to_prepare_to_store) (struct regcache *);
};
static void
record_btrace_store_registers (struct target_ops *ops,
- struct regcache *regcache, int regno)
+ struct regcache *regcache,
+ ptid_t ptid, int regno)
{
struct target_ops *t;
if (!record_btrace_generating_corefile
- && record_btrace_is_replaying (ops, inferior_ptid))
+ && record_btrace_is_replaying (ops, ptid))
error (_("Cannot write registers while replaying."));
gdb_assert (may_write_registers != 0);
t = ops->beneath;
- t->to_store_registers (t, regcache, regno);
+ t->to_store_registers (t, regcache, ptid, regno);
}
/* The to_prepare_to_store method of target record-btrace. */
static void
record_full_store_registers (struct target_ops *ops,
struct regcache *regcache,
- int regno)
+ ptid_t ptid, int regno)
{
if (!record_full_gdb_operation_disable)
{
record_full_registers_change (regcache, regno);
}
- ops->beneath->to_store_registers (ops->beneath, regcache, regno);
+ ops->beneath->to_store_registers (ops->beneath, regcache, ptid, regno);
}
/* "to_xfer_partial" method. Behavior is conditional on
static void
record_full_core_store_registers (struct target_ops *ops,
struct regcache *regcache,
- int regno)
+ ptid_t ptid, int regno)
{
if (record_full_gdb_operation_disable)
regcache_raw_collect (regcache, regno,
chain_before_invalidate_register
= make_cleanup_regcache_invalidate (regcache, regnum);
- target_store_registers (regcache, regnum);
+ target_store_registers (regcache, regcache->ptid, regnum);
/* The target did not throw an error so we can discard invalidating the
register and restore the cleanup chain to what it was. */
static void
gdbsim_store_register (struct target_ops *ops,
- struct regcache *regcache, int regno)
+ struct regcache *regcache,
+ ptid_t ptid, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct inferior *inf = find_inferior_ptid (ptid);
struct sim_inferior_data *sim_data
- = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
+ = get_sim_inferior_data (inf, SIM_INSTANCE_NEEDED);
if (regno == -1)
{
for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
- gdbsim_store_register (ops, regcache, regno);
+ gdbsim_store_register (ops, regcache, ptid, regno);
return;
}
else if (gdbarch_register_sim_regno (gdbarch, regno) >= 0)
static void
remote_store_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum)
+ struct regcache *regcache,
+ ptid_t ptid, int regnum)
{
struct remote_arch_state *rsa = get_remote_arch_state ();
int i;
set_remote_traceframe ();
- set_general_thread (inferior_ptid);
+ set_general_thread (ptid);
if (regnum >= 0)
{
#include "solib.h"
#include "solib-aix.h"
#include "xml-utils.h"
+#include "inferior.h"
/* If the kernel has to deliver a signal, it pushes a sigcontext
structure on the stack and then calls the signal handler, passing
regcache_raw_write_signed (regcache, tdep->ppc_toc_regnum,
solib_aix_get_toc_value (func_addr));
- target_store_registers (regcache, -1);
+ target_store_registers (regcache, inferior_ptid, -1);
return sp;
}
#include "ppc-tdep.h"
#include "value.h"
#include "xcoffread.h"
+#include "inferior.h"
/* Implement the "push_dummy_call" gdbarch method. */
breakpoint. */
regcache_raw_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr);
- target_store_registers (regcache, -1);
+ target_store_registers (regcache, inferior_ptid, -1);
return sp;
}
/* Store register REGNO back into the inferior. */
static void
-store_register (struct regcache *regcache, int regno)
+store_register (struct regcache *regcache, ptid_t ptid, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int addr[MAX_REGISTER_SIZE];
/* Floating-point registers. */
if (isfloat)
- rs6000_ptrace32 (PT_WRITE_FPR, ptid_get_pid (inferior_ptid), addr, nr, 0);
+ rs6000_ptrace32 (PT_WRITE_FPR, ptid_get_pid (ptid), addr, nr, 0);
/* Bogus register number. */
else if (nr < 0)
the register's value is passed by value, but for 64-bit inferiors,
the address of a buffer containing the value is passed. */
if (!ARCH64 ())
- rs6000_ptrace32 (PT_WRITE_GPR, ptid_get_pid (inferior_ptid),
+ rs6000_ptrace32 (PT_WRITE_GPR, ptid_get_pid (ptid),
(int *) nr, *addr, 0);
else
{
memcpy (&buf, addr, 8);
else
buf = *addr;
- rs6000_ptrace64 (PT_WRITE_GPR, ptid_get_pid (inferior_ptid),
+ rs6000_ptrace64 (PT_WRITE_GPR, ptid_get_pid (ptid),
nr, 0, &buf);
}
}
static void
rs6000_store_inferior_registers (struct target_ops *ops,
- struct regcache *regcache, int regno)
+ struct regcache *regcache,
+ ptid_t ptid, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
if (regno != -1)
- store_register (regcache, regno);
+ store_register (regcache, ptid, regno);
else
{
regno < tdep->ppc_gp0_regnum + ppc_num_gprs;
regno++)
{
- store_register (regcache, regno);
+ store_register (regcache, ptid, regno);
}
/* Write floating point registers. */
if (tdep->ppc_fp0_regnum >= 0)
for (regno = 0; regno < ppc_num_fprs; regno++)
- store_register (regcache, tdep->ppc_fp0_regnum + regno);
+ store_register (regcache, ptid, tdep->ppc_fp0_regnum + regno);
/* Write special registers. */
- store_register (regcache, gdbarch_pc_regnum (gdbarch));
- store_register (regcache, tdep->ppc_ps_regnum);
- store_register (regcache, tdep->ppc_cr_regnum);
- store_register (regcache, tdep->ppc_lr_regnum);
- store_register (regcache, tdep->ppc_ctr_regnum);
- store_register (regcache, tdep->ppc_xer_regnum);
+ store_register (regcache, ptid, gdbarch_pc_regnum (gdbarch));
+ store_register (regcache, ptid, tdep->ppc_ps_regnum);
+ store_register (regcache, ptid, tdep->ppc_cr_regnum);
+ store_register (regcache, ptid, tdep->ppc_lr_regnum);
+ store_register (regcache, ptid, tdep->ppc_ctr_regnum);
+ store_register (regcache, ptid, tdep->ppc_xer_regnum);
if (tdep->ppc_fpscr_regnum >= 0)
- store_register (regcache, tdep->ppc_fpscr_regnum);
+ store_register (regcache, ptid, tdep->ppc_fpscr_regnum);
if (tdep->ppc_mq_regnum >= 0)
- store_register (regcache, tdep->ppc_mq_regnum);
+ store_register (regcache, ptid, tdep->ppc_mq_regnum);
}
}
-1, do this for all registers. */
static void
s390_linux_store_inferior_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum)
+ struct regcache *regcache,
+ ptid_t ptid, int regnum)
{
- int tid = s390_inferior_tid ();
+ int tid = s390_inferior_tid (ptid);
if (regnum == -1 || S390_IS_GREGSET_REGNUM (regnum))
store_regs (regcache, tid, regnum);
static void
shnbsd_store_inferior_registers (struct target_ops *ops,
- struct regcache *regcache, int regno)
+ struct regcache *regcache,
+ ptid_t ptid, int regno)
{
if (regno == -1 || GETREGS_SUPPLIES (get_regcache_arch (regcache), regno))
{
struct reg inferior_registers;
- if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+ if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
(PTRACE_TYPE_ARG3) &inferior_registers, 0) == -1)
perror_with_name (_("Couldn't get registers"));
(char *) &inferior_registers,
SHNBSD_SIZEOF_GREGS);
- if (ptrace (PT_SETREGS, ptid_get_pid (inferior_ptid),
+ if (ptrace (PT_SETREGS, ptid_get_pid (ptid),
(PTRACE_TYPE_ARG3) &inferior_registers, 0) == -1)
perror_with_name (_("Couldn't set registers"));
static void
sol_thread_store_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum)
+ struct regcache *regcache,
+ ptid_t ptid, int regnum)
{
thread_t thread;
td_thrhandle_t thandle;
prgregset_t gregset;
prfpregset_t fpregset;
- if (!ptid_tid_p (inferior_ptid))
+ if (!ptid_tid_p (ptid))
{
struct target_ops *beneath = find_target_beneath (ops);
/* It's an LWP; pass the request on to the layer beneath. */
- beneath->to_store_registers (beneath, regcache, regnum);
+ beneath->to_store_registers (beneath, regcache, ptid, regnum);
return;
}
- /* Solaris thread: convert INFERIOR_PTID into a td_thrhandle_t. */
- thread = ptid_get_tid (inferior_ptid);
+ /* Solaris thread: convert PTID into a td_thrhandle_t. */
+ thread = ptid_get_tid (ptid);
val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
if (val != TD_OK)
void
sparc_store_inferior_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum)
+ struct regcache *regcache,
+ ptid_t ptid, int regnum)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int pid;
/* NOTE: cagney/2002-12-02: See comment in fetch_inferior_registers
about threaded assumptions. */
- pid = ptid_get_lwp (inferior_ptid);
+ pid = ptid_get_lwp (ptid);
if (pid == 0)
- pid = ptid_get_pid (inferior_ptid);
+ pid = ptid_get_pid (ptid);
if (regnum == -1 || sparc_gregset_supplies_p (gdbarch, regnum))
{
extern void sparc_fetch_inferior_registers (struct target_ops *,
struct regcache *, ptid_t, int);
extern void sparc_store_inferior_registers (struct target_ops *,
- struct regcache *, int);
+ struct regcache *, ptid_t, int);
#endif /* sparc-nat.h */
#include "ravenscar-thread.h"
#include "sparc-ravenscar-thread.h"
-static void sparc_ravenscar_store_registers (struct regcache *regcache,
- int regnum);
static void sparc_ravenscar_prepare_to_store (struct regcache *regcache);
/* Register offsets from a referenced address (exempli gratia the
thread. */
static void
-sparc_ravenscar_store_registers (struct regcache *regcache, int regnum)
+sparc_ravenscar_store_registers (struct regcache *regcache, ptid_t ptid,
+ int regnum)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int buf_size = register_size (gdbarch, regnum);
ULONGEST register_address;
if (register_in_thread_descriptor_p (regnum))
- register_address =
- ptid_get_tid (inferior_ptid) + sparc_register_offsets [regnum];
+ register_address = ptid_get_tid (ptid) + sparc_register_offsets [regnum];
else if (register_on_stack_p (regnum))
{
regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM,
/* Override the store_inferior_register routine. */
static void
spu_store_inferior_registers (struct target_ops *ops,
- struct regcache *regcache, int regno)
+ struct regcache *regcache,
+ ptid_t ptid, int regno)
{
int fd;
ULONGEST addr;
/* Override the to_store_registers routine. */
static void
spu_store_registers (struct target_ops *ops,
- struct regcache *regcache, int regno)
+ struct regcache *regcache, ptid_t ptid, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
struct target_ops *ops_beneath = find_target_beneath (ops);
/* This version applies only if we're currently in spu_run. */
if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
{
- ops_beneath->to_store_registers (ops_beneath, regcache, regno);
+ ops_beneath->to_store_registers (ops_beneath, regcache, ptid, regno);
return;
}
/* We must be stopped on a spu_run system call. */
- if (!parse_spufs_run (inferior_ptid, &spufs_fd, &spufs_addr))
+ if (!parse_spufs_run (ptid, &spufs_fd, &spufs_addr))
return;
/* The NPC register is found in PPC memory at SPUFS_ADDR. */
}
static void
-delegate_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
+delegate_store_registers (struct target_ops *self, struct regcache *arg1, ptid_t arg2, int arg3)
{
self = self->beneath;
- self->to_store_registers (self, arg1, arg2);
+ self->to_store_registers (self, arg1, arg2, arg3);
}
static void
-tdefault_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
+tdefault_store_registers (struct target_ops *self, struct regcache *arg1, ptid_t arg2, int arg3)
{
noprocess ();
}
static void
-debug_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
+debug_store_registers (struct target_ops *self, struct regcache *arg1, ptid_t arg2, int arg3)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_store_registers (...)\n", debug_target.to_shortname);
- debug_target.to_store_registers (&debug_target, arg1, arg2);
+ debug_target.to_store_registers (&debug_target, arg1, arg2, arg3);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_store_registers (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_regcache_p (arg1);
fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_int (arg2);
+ target_debug_print_ptid_t (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
fputs_unfiltered (")\n", gdb_stdlog);
}
}
void
-target_store_registers (struct regcache *regcache, int regno)
+target_store_registers (struct regcache *regcache, ptid_t ptid, int regno)
{
if (!may_write_registers)
error (_("Writing to registers is not allowed (regno %d)"), regno);
- current_target.to_store_registers (¤t_target, regcache, regno);
+ current_target.to_store_registers (¤t_target, regcache, ptid, regno);
if (targetdebug)
{
debug_print_register ("target_store_registers", regcache, regno);
void (*to_fetch_registers) (struct target_ops *, struct regcache *, ptid_t,
int)
TARGET_DEFAULT_IGNORE ();
- void (*to_store_registers) (struct target_ops *, struct regcache *, int)
+ void (*to_store_registers) (struct target_ops *, struct regcache *, ptid_t,
+ int)
TARGET_DEFAULT_NORETURN (noprocess ());
void (*to_prepare_to_store) (struct target_ops *, struct regcache *)
TARGET_DEFAULT_NORETURN (noprocess ());
It can store as many registers as it wants to, so target_prepare_to_store
must have been previously called. Calls error() if there are problems. */
-extern void target_store_registers (struct regcache *regcache, int regs);
+extern void target_store_registers (struct regcache *regcache, ptid_t ptid,
+ int regs);
/* Get ready to modify the registers array. On machines which store
individual registers, this doesn't need to do anything. On machines
static void
store_inferior_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum)
+ struct regcache *regcache,
+ ptid_t ptid, int regnum)
{
elf_gregset_t regs;
int tid;
- tid = ptid_get_lwp (inferior_ptid);
+ tid = ptid_get_lwp (ptid);
if (tid == 0)
- tid = ptid_get_pid (inferior_ptid);
+ tid = ptid_get_pid (ptid);
if (ptrace (PTRACE_GETREGS, tid, 0, (PTRACE_TYPE_ARG3) ®s) < 0)
perror_with_name (_("Couldn't get registers"));
static void
vaxbsd_store_inferior_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum)
+ struct regcache *regcache,
+ ptid_t ptid, int regnum)
{
struct reg regs;
- if (ptrace (PT_GETREGS, ptid_get_pid (inferior_ptid),
+ if (ptrace (PT_GETREGS, ptid_get_pid (ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't get registers"));
vaxbsd_collect_gregset (regcache, ®s, regnum);
- if (ptrace (PT_SETREGS, ptid_get_pid (inferior_ptid),
+ if (ptrace (PT_SETREGS, ptid_get_pid (ptid),
(PTRACE_TYPE_ARG3) ®s, 0) == -1)
perror_with_name (_("Couldn't write registers"));
}
/* Store a new register value into the current thread context. */
static void
windows_store_inferior_registers (struct target_ops *ops,
- struct regcache *regcache, int r)
+ struct regcache *regcache,
+ ptid_t ptid, int r)
{
- windows_thread_info *th = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
+ windows_thread_info *th = thread_rec (ptid_get_tid (ptid), TRUE);
/* Check if current_thread exists. Windows sometimes uses a non-existent
thread id in its events. */
supply_gregset_reg (regcache, ®s, regnum);
}
-/* Store greg-register(s) in GDB's register
- array into the process/thread specified by TID. */
+/* Store greg-register(s) in REGCACHE into the process/thread specified by
+ PTID. */
static void
-store_gregs (struct regcache *regcache, int regnum)
+store_gregs (struct regcache *regcache, ptid_t ptid, int regnum)
{
- int tid = ptid_get_lwp (inferior_ptid);
+ int tid = ptid_get_lwp (ptid);
gdb_gregset_t regs;
int areg;
}
static void
-store_xtregs (struct regcache *regcache, int regnum)
+store_xtregs (struct regcache *regcache, ptid_t ptid, int regnum)
{
- int tid = ptid_get_lwp (inferior_ptid);
+ int tid = ptid_get_lwp (ptid);
const xtensa_regtable_t *ptr;
char xtregs [XTENSA_ELF_XTREG_SIZE];
static void
xtensa_linux_store_inferior_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum)
+ struct regcache *regcache,
+ ptid_t ptid, int regnum)
{
if (regnum == -1)
{
- store_gregs (regcache, regnum);
- store_xtregs (regcache, regnum);
+ store_gregs (regcache, ptid, regnum);
+ store_xtregs (regcache, ptid, regnum);
}
else if ((regnum < xtreg_lo) || (regnum > xtreg_high))
- store_gregs (regcache, regnum);
+ store_gregs (regcache, ptid, regnum);
else
- store_xtregs (regcache, regnum);
+ store_xtregs (regcache, ptid, regnum);
}
/* Called by libthread_db. */
projects / thirdparty / binutils-gdb.git / commitdiff
