FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

* regcache.c (struct regcache): Add ptid_t member.

Browse source 
(regcache_xmalloc): Initialize it.
	(regcache_cpy_no_passthrough): Do not refer to current_regcache.
	(regcache_dup): Likewise.
	(regcache_dup_no_passthrough): Likewise.
	(current_regcache): Make static.
	(registers_ptid): Remove variable.
	(get_thread_regcache): New function.
	(get_current_regcache): New function.
	(registers_changed): Implement by freeing current regcache.
	(regcache_raw_read): Do not refer to current_regcache.  Set
	inferior_ptid to regcache->ptid while calling target routines.
	(regcache_raw_write): Likewise.
	(regcache_raw_supply): Do not refer to current_regcache.
	(read_pc_pid): Use thread regcache.  Do not modify inferior_ptid.
	(write_pc_pid): Likewise.
	(build_regcache): Remove.
	(_initialize_regcache): Do not call DEPRECATED_REGISTER_GDBARCH_SWAP
	or deprecated_register_gdbarch_swap.  Do not initialize
	registers_ptid.
	* regcache.h (get_current_regcache): Add prototype.
	(get_thread_regcache): Likewise.
	(current_regcache): Remove declaration.

	* corelow.c (core_open): Replace current_regcache by
	get_current_regcache ().
	* frame.c (frame_pop): Likewise.
	(put_frame_register): Likewise.
	(get_current_frame, create_new_frame): Likewise.
	* mi/mi-main.c (mi_cmd_data_write_register_values): Likewise.
	* stack.c (return_command): Likewise.
	* infcall.c (call_function_by_hand): Likewise.
	* infrun.c (resume): Likewise.
	(save_inferior_status, restore_inferior_status): Likewise.
	* linux-fork.c (fork_load_infrun_state): Likewise.
	(fork_save_infrun_state): Likewise.
	* win32-nat.c (win32_resume): Likewise.
	* i386fbsd-nat.c (i386fbsd_resume): Likewise.
	* monitor.c (monitor_wait): Likewise.
	* remote.c (remote_wait): Likewise.
	* remote-mips.c (mips_wait): Likewise.

	* bsd-kvm.c (bsd_kvm_open): Likewise
	(bsd_kvm_proc_cmd, bsd_kvm_pcb_cmd): Likewise.
	* fbsd-nat.c (fbsd_make_corefile_notes): Likewise.
	* i386-linux-nat.c (i386_linux_resume): Likewise.
	* ia64-linux-nat.c (ia64_linux_insert_watchpoint): Likewise.
	(ia64_linux_stopped_data_address): Likewise.

	* frv-tdep.c (frv_fdpic_loadmap_addresses): Likewise.
	* m32c-tdep.c (m32c_virtual_frame_pointer): Likewise.
	* mep-tdep.c (current_me_module, current_options): Likewise.
	* mips-tdep.c (deprecated_mips_set_processor_regs_hack): Likewise.

	* linux-nat.c (linux_nat_do_thread_registers): Use thread
	regcache instead of current_regcache.  Call target_fetch_registers.
	(linux_nat_corefile_thread_callback): Update call site.
	(linux_nat_do_registers): Likewise.
	* procfs.c (procfs_do_thread_registers): Use thread regcache instead
	of current_regcache.
	(procfs_make_note_section): Likewise.
	* proc-service.c (ps_lgetregs, ps_lsetregs): Likewise.
	(ps_lgetfpregs, ps_lsetfpregs): Likewise.
	* sol-thread.c (ps_lgetregs, ps_lsetregs): Likewise.
	(ps_lgetfpregs, ps_lsetfpregs): Likewise.
This commit is contained in:
Ulrich Weigand 2007-06-16 17:16:26 +00:00
parent 7cc23052d5
commit 594f77850b
28 changed files with 225 additions and 158 deletions
Download patch file Download diff file Expand all files Collapse all files

68
gdb/ChangeLog
View file

@ -1,3 +1,71 @@
2007-06-16 Ulrich Weigand <uweigand@de.ibm.com>
* regcache.c (struct regcache): Add ptid_t member.
(regcache_xmalloc): Initialize it.
(regcache_cpy_no_passthrough): Do not refer to current_regcache.
(regcache_dup): Likewise.
(regcache_dup_no_passthrough): Likewise.
(current_regcache): Make static.
(registers_ptid): Remove variable.
(get_thread_regcache): New function.
(get_current_regcache): New function.
(registers_changed): Implement by freeing current regcache.
(regcache_raw_read): Do not refer to current_regcache. Set
inferior_ptid to regcache->ptid while calling target routines.
(regcache_raw_write): Likewise.
(regcache_raw_supply): Do not refer to current_regcache.
(read_pc_pid): Use thread regcache. Do not modify inferior_ptid.
(write_pc_pid): Likewise.
(build_regcache): Remove.
(_initialize_regcache): Do not call DEPRECATED_REGISTER_GDBARCH_SWAP
or deprecated_register_gdbarch_swap. Do not initialize
registers_ptid.
* regcache.h (get_current_regcache): Add prototype.
(get_thread_regcache): Likewise.
(current_regcache): Remove declaration.
* corelow.c (core_open): Replace current_regcache by
get_current_regcache ().
* frame.c (frame_pop): Likewise.
(put_frame_register): Likewise.
(get_current_frame, create_new_frame): Likewise.
* mi/mi-main.c (mi_cmd_data_write_register_values): Likewise.
* stack.c (return_command): Likewise.
* infcall.c (call_function_by_hand): Likewise.
* infrun.c (resume): Likewise.
(save_inferior_status, restore_inferior_status): Likewise.
* linux-fork.c (fork_load_infrun_state): Likewise.
(fork_save_infrun_state): Likewise.
* win32-nat.c (win32_resume): Likewise.
* i386fbsd-nat.c (i386fbsd_resume): Likewise.
* monitor.c (monitor_wait): Likewise.
* remote.c (remote_wait): Likewise.
* remote-mips.c (mips_wait): Likewise.
* bsd-kvm.c (bsd_kvm_open): Likewise
(bsd_kvm_proc_cmd, bsd_kvm_pcb_cmd): Likewise.
* fbsd-nat.c (fbsd_make_corefile_notes): Likewise.
* i386-linux-nat.c (i386_linux_resume): Likewise.
* ia64-linux-nat.c (ia64_linux_insert_watchpoint): Likewise.
(ia64_linux_stopped_data_address): Likewise.
* frv-tdep.c (frv_fdpic_loadmap_addresses): Likewise.
* m32c-tdep.c (m32c_virtual_frame_pointer): Likewise.
* mep-tdep.c (current_me_module, current_options): Likewise.
* mips-tdep.c (deprecated_mips_set_processor_regs_hack): Likewise.
* linux-nat.c (linux_nat_do_thread_registers): Use thread
regcache instead of current_regcache. Call target_fetch_registers.
(linux_nat_corefile_thread_callback): Update call site.
(linux_nat_do_registers): Likewise.
* procfs.c (procfs_do_thread_registers): Use thread regcache instead
of current_regcache.
(procfs_make_note_section): Likewise.
* proc-service.c (ps_lgetregs, ps_lsetregs): Likewise.
(ps_lgetfpregs, ps_lsetfpregs): Likewise.
* sol-thread.c (ps_lgetregs, ps_lsetregs): Likewise.
(ps_lgetfpregs, ps_lsetfpregs): Likewise.
2007-06-15 Ulrich Weigand <uweigand@de.ibm.com> 2007-06-15 Ulrich Weigand <uweigand@de.ibm.com>
* regcache.c (read_register, read_register_pid): Remove. * regcache.c (read_register, read_register_pid): Remove.

6
gdb/bsd-kvm.c
View file

@ -91,7 +91,7 @@ bsd_kvm_open (char *filename, int from_tty)
core_kd = temp_kd; core_kd = temp_kd;
push_target (&bsd_kvm_ops); push_target (&bsd_kvm_ops);
target_fetch_registers (current_regcache, -1); target_fetch_registers (get_current_regcache (), -1);
reinit_frame_cache (); reinit_frame_cache ();
print_stack_frame (get_selected_frame (NULL), -1, 1); print_stack_frame (get_selected_frame (NULL), -1, 1);
@ -273,7 +273,7 @@ bsd_kvm_proc_cmd (char *arg, int fromtty)
if (kvm_read (core_kd, addr, &bsd_kvm_paddr, sizeof bsd_kvm_paddr) == -1) if (kvm_read (core_kd, addr, &bsd_kvm_paddr, sizeof bsd_kvm_paddr) == -1)
error (("%s"), kvm_geterr (core_kd)); error (("%s"), kvm_geterr (core_kd));
target_fetch_registers (current_regcache, -1); target_fetch_registers (get_current_regcache (), -1);
reinit_frame_cache (); reinit_frame_cache ();
print_stack_frame (get_selected_frame (NULL), -1, 1); print_stack_frame (get_selected_frame (NULL), -1, 1);
@ -293,7 +293,7 @@ bsd_kvm_pcb_cmd (char *arg, int fromtty)
bsd_kvm_paddr = (struct pcb *)(u_long) parse_and_eval_address (arg); bsd_kvm_paddr = (struct pcb *)(u_long) parse_and_eval_address (arg);
target_fetch_registers (current_regcache, -1); target_fetch_registers (get_current_regcache (), -1);
reinit_frame_cache (); reinit_frame_cache ();
print_stack_frame (get_selected_frame (NULL), -1, 1); print_stack_frame (get_selected_frame (NULL), -1, 1);

2
gdb/corelow.c
View file

@ -375,7 +375,7 @@ core_open (char *filename, int from_tty)
if (ontop) if (ontop)
{ {
/* Fetch all registers from core file. */ /* Fetch all registers from core file. */
target_fetch_registers (current_regcache, -1); target_fetch_registers (get_current_regcache (), -1);
/* Now, set up the frame cache, and print the top of stack. */ /* Now, set up the frame cache, and print the top of stack. */
reinit_frame_cache (); reinit_frame_cache ();

2
gdb/fbsd-nat.c
View file

@ -146,7 +146,7 @@ char *
fbsd_make_corefile_notes (bfd *obfd, int *note_size) fbsd_make_corefile_notes (bfd *obfd, int *note_size)
{ {
struct gdbarch *gdbarch = current_gdbarch; struct gdbarch *gdbarch = current_gdbarch;
const struct regcache *regcache = current_regcache; const struct regcache *regcache = get_current_regcache ();
gregset_t gregs; gregset_t gregs;
fpregset_t fpregs; fpregset_t fpregs;
char *note_data = NULL; char *note_data = NULL;

10
gdb/frame.c
View file

@ -526,7 +526,7 @@ frame_pop (struct frame_info *this_frame)
/* Make a copy of all the register values unwound from this frame. /* Make a copy of all the register values unwound from this frame.
Save them in a scratch buffer so that there isn't a race between Save them in a scratch buffer so that there isn't a race between
trying to extract the old values from the current_regcache while trying to extract the old values from the current regcache while
at the same time writing new values into that same cache. */ at the same time writing new values into that same cache. */
scratch = frame_save_as_regcache (prev_frame); scratch = frame_save_as_regcache (prev_frame);
cleanups = make_cleanup_regcache_xfree (scratch); cleanups = make_cleanup_regcache_xfree (scratch);
@ -541,7 +541,7 @@ frame_pop (struct frame_info *this_frame)
(arguably a bug in the target code mind). */ (arguably a bug in the target code mind). */
/* Now copy those saved registers into the current regcache. /* Now copy those saved registers into the current regcache.
Here, regcache_cpy() calls regcache_restore(). */ Here, regcache_cpy() calls regcache_restore(). */
regcache_cpy (current_regcache, scratch); regcache_cpy (get_current_regcache (), scratch);
do_cleanups (cleanups); do_cleanups (cleanups);
/* We've made right mess of GDB's local state, just discard /* We've made right mess of GDB's local state, just discard
@ -714,7 +714,7 @@ put_frame_register (struct frame_info *frame, int regnum,
break; break;
} }
case lval_register: case lval_register:
regcache_cooked_write (current_regcache, realnum, buf); regcache_cooked_write (get_current_regcache (), realnum, buf);
break; break;
default: default:
error (_("Attempt to assign to an unmodifiable value.")); error (_("Attempt to assign to an unmodifiable value."));
@ -919,7 +919,7 @@ get_current_frame (void)
if (current_frame == NULL) if (current_frame == NULL)
{ {
struct frame_info *sentinel_frame = struct frame_info *sentinel_frame =
create_sentinel_frame (current_regcache); create_sentinel_frame (get_current_regcache ());
if (catch_exceptions (uiout, unwind_to_current_frame, sentinel_frame, if (catch_exceptions (uiout, unwind_to_current_frame, sentinel_frame,
RETURN_MASK_ERROR) != 0) RETURN_MASK_ERROR) != 0)
{ {
@ -1031,7 +1031,7 @@ create_new_frame (CORE_ADDR addr, CORE_ADDR pc)
fi = FRAME_OBSTACK_ZALLOC (struct frame_info); fi = FRAME_OBSTACK_ZALLOC (struct frame_info);
fi->next = create_sentinel_frame (current_regcache); fi->next = create_sentinel_frame (get_current_regcache ());
/* Select/initialize both the unwind function and the frame's type /* Select/initialize both the unwind function and the frame's type
based on the PC. */ based on the PC. */

6
gdb/frv-tdep.c
View file

@ -112,17 +112,19 @@ frv_fdpic_loadmap_addresses (struct gdbarch *gdbarch, CORE_ADDR *interp_addr,
return -1; return -1;
else else
{ {
struct regcache *regcache = get_current_regcache ();
if (interp_addr != NULL) if (interp_addr != NULL)
{ {
ULONGEST val; ULONGEST val;
regcache_cooked_read_unsigned (current_regcache, regcache_cooked_read_unsigned (regcache,
fdpic_loadmap_interp_regnum, &val); fdpic_loadmap_interp_regnum, &val);
*interp_addr = val; *interp_addr = val;
} }
if (exec_addr != NULL) if (exec_addr != NULL)
{ {
ULONGEST val; ULONGEST val;
regcache_cooked_read_unsigned (current_regcache, regcache_cooked_read_unsigned (regcache,
fdpic_loadmap_exec_regnum, &val); fdpic_loadmap_exec_regnum, &val);
*exec_addr = val; *exec_addr = val;
} }

6
gdb/i386-linux-nat.c
View file

@ -738,14 +738,12 @@ i386_linux_resume (ptid_t ptid, int step, enum target_signal signal)
if (step) if (step)
{ {
struct cleanup *old_chain = save_inferior_ptid (); struct regcache *regcache = get_thread_regcache (pid_to_ptid (pid));
struct regcache *regcache = current_regcache;
ULONGEST pc; ULONGEST pc;
gdb_byte buf[LINUX_SYSCALL_LEN]; gdb_byte buf[LINUX_SYSCALL_LEN];
request = PTRACE_SINGLESTEP; request = PTRACE_SINGLESTEP;
inferior_ptid = pid_to_ptid (pid);
regcache_cooked_read_unsigned (regcache, PC_REGNUM, &pc); regcache_cooked_read_unsigned (regcache, PC_REGNUM, &pc);
/* Returning from a signal trampoline is done by calling a /* Returning from a signal trampoline is done by calling a
@ -784,8 +782,6 @@ i386_linux_resume (ptid_t ptid, int step, enum target_signal signal)
write_memory (addr, (gdb_byte *) &eflags, 4); write_memory (addr, (gdb_byte *) &eflags, 4);
} }
} }
do_cleanups (old_chain);
} }
if (ptrace (request, pid, 0, target_signal_to_host (signal)) == -1) if (ptrace (request, pid, 0, target_signal_to_host (signal)) == -1)

5
gdb/i386fbsd-nat.c
View file

@ -49,6 +49,7 @@ i386fbsd_resume (ptid_t ptid, int step, enum target_signal signal)
if (!step) if (!step)
{ {
struct regcache *regcache = get_current_regcache ();
ULONGEST eflags; ULONGEST eflags;
/* Workaround for a bug in FreeBSD. Make sure that the trace /* Workaround for a bug in FreeBSD. Make sure that the trace
@ -61,10 +62,10 @@ i386fbsd_resume (ptid_t ptid, int step, enum target_signal signal)
never goes through the kernel's trap() function which would never goes through the kernel's trap() function which would
normally clear it. */ normally clear it. */
regcache_cooked_read_unsigned (current_regcache, I386_EFLAGS_REGNUM, regcache_cooked_read_unsigned (regcache, I386_EFLAGS_REGNUM,
&eflags); &eflags);
if (eflags & 0x0100) if (eflags & 0x0100)
regcache_cooked_write_unsigned (current_regcache, I386_EFLAGS_REGNUM, regcache_cooked_write_unsigned (regcache, I386_EFLAGS_REGNUM,
eflags & ~0x0100); eflags & ~0x0100);
request = PT_CONTINUE; request = PT_CONTINUE;

4
gdb/ia64-linux-nat.c
View file

@ -595,7 +595,7 @@ ia64_linux_insert_watchpoint (CORE_ADDR addr, int len, int rw)
} }
store_debug_register_pair (ptid, idx, &dbr_addr, &dbr_mask); store_debug_register_pair (ptid, idx, &dbr_addr, &dbr_mask);
enable_watchpoints_in_psr (current_regcache); enable_watchpoints_in_psr (get_current_regcache ());
return 0; return 0;
} }
@ -632,7 +632,7 @@ ia64_linux_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
int tid; int tid;
struct siginfo siginfo; struct siginfo siginfo;
ptid_t ptid = inferior_ptid; ptid_t ptid = inferior_ptid;
struct regcache *regcache = current_regcache; struct regcache *regcache = get_current_regcache ();
tid = TIDGET(ptid); tid = TIDGET(ptid);
if (tid == 0) if (tid == 0)

10
gdb/infcall.c
View file

@ -469,7 +469,7 @@ call_function_by_hand (struct value *function, int nargs, struct value **args)
{ {
sp = push_dummy_code (current_gdbarch, sp, funaddr, sp = push_dummy_code (current_gdbarch, sp, funaddr,
using_gcc, args, nargs, values_type, using_gcc, args, nargs, values_type,
&real_pc, &bp_addr, current_regcache); &real_pc, &bp_addr, get_current_regcache ());
dummy_addr = sp; dummy_addr = sp;
} }
else else
@ -477,7 +477,7 @@ call_function_by_hand (struct value *function, int nargs, struct value **args)
dummy_addr = sp; dummy_addr = sp;
sp = push_dummy_code (current_gdbarch, sp, funaddr, sp = push_dummy_code (current_gdbarch, sp, funaddr,
using_gcc, args, nargs, values_type, using_gcc, args, nargs, values_type,
&real_pc, &bp_addr, current_regcache); &real_pc, &bp_addr, get_current_regcache ());
} }
break; break;
case AT_ENTRY_POINT: case AT_ENTRY_POINT:
@ -672,9 +672,9 @@ You must use a pointer to function type variable. Command ignored."), arg_name);
/* Create the dummy stack frame. Pass in the call dummy address as, /* Create the dummy stack frame. Pass in the call dummy address as,
presumably, the ABI code knows where, in the call dummy, the presumably, the ABI code knows where, in the call dummy, the
return address should be pointed. */ return address should be pointed. */
sp = gdbarch_push_dummy_call (current_gdbarch, function, current_regcache, sp = gdbarch_push_dummy_call (current_gdbarch, function,
bp_addr, nargs, args, sp, struct_return, get_current_regcache (), bp_addr, nargs, args,
struct_addr); sp, struct_return, struct_addr);
/* Set up a frame ID for the dummy frame so we can pass it to /* Set up a frame ID for the dummy frame so we can pass it to
set_momentary_breakpoint. We need to give the breakpoint a frame set_momentary_breakpoint. We need to give the breakpoint a frame

9
gdb/infrun.c
View file

@ -528,7 +528,8 @@ resume (int step, enum target_signal sig)
if (breakpoint_here_p (read_pc ()) == permanent_breakpoint_here) if (breakpoint_here_p (read_pc ()) == permanent_breakpoint_here)
{ {
if (gdbarch_skip_permanent_breakpoint_p (current_gdbarch)) if (gdbarch_skip_permanent_breakpoint_p (current_gdbarch))
gdbarch_skip_permanent_breakpoint (current_gdbarch, current_regcache); gdbarch_skip_permanent_breakpoint (current_gdbarch,
get_current_regcache ());
else else
error (_("\ error (_("\
The program is stopped at a permanent breakpoint, but GDB does not know\n\ The program is stopped at a permanent breakpoint, but GDB does not know\n\
@ -3218,7 +3219,7 @@ Further execution is probably impossible.\n"));
if (proceed_to_finish) if (proceed_to_finish)
/* NB: The copy goes through to the target picking up the value of /* NB: The copy goes through to the target picking up the value of
all the registers. */ all the registers. */
regcache_cpy (stop_registers, current_regcache); regcache_cpy (stop_registers, get_current_regcache ());
if (stop_stack_dummy) if (stop_stack_dummy)
{ {
@ -3675,7 +3676,7 @@ save_inferior_status (int restore_stack_info)
inf_status->stop_registers = regcache_dup_no_passthrough (stop_registers); inf_status->stop_registers = regcache_dup_no_passthrough (stop_registers);
inf_status->registers = regcache_dup (current_regcache); inf_status->registers = regcache_dup (get_current_regcache ());
inf_status->selected_frame_id = get_frame_id (get_selected_frame (NULL)); inf_status->selected_frame_id = get_frame_id (get_selected_frame (NULL));
return inf_status; return inf_status;
@ -3730,7 +3731,7 @@ restore_inferior_status (struct inferior_status *inf_status)
(and perhaps other times). */ (and perhaps other times). */
if (target_has_execution) if (target_has_execution)
/* NB: The register write goes through to the target. */ /* NB: The register write goes through to the target. */
regcache_cpy (current_regcache, inf_status->registers); regcache_cpy (get_current_regcache (), inf_status->registers);
regcache_xfree (inf_status->registers); regcache_xfree (inf_status->registers);
/* FIXME: If we are being called after stopping in a function which /* FIXME: If we are being called after stopping in a function which

4
gdb/linux-fork.c
View file

@ -245,7 +245,7 @@ fork_load_infrun_state (struct fork_info *fp)
linux_nat_switch_fork (inferior_ptid); linux_nat_switch_fork (inferior_ptid);
if (fp->savedregs && fp->clobber_regs) if (fp->savedregs && fp->clobber_regs)
regcache_cpy (current_regcache, fp->savedregs); regcache_cpy (get_current_regcache (), fp->savedregs);
registers_changed (); registers_changed ();
reinit_frame_cache (); reinit_frame_cache ();
@ -278,7 +278,7 @@ fork_save_infrun_state (struct fork_info *fp, int clobber_regs)
if (fp->savedregs) if (fp->savedregs)
regcache_xfree (fp->savedregs); regcache_xfree (fp->savedregs);
fp->savedregs = regcache_dup (current_regcache); fp->savedregs = regcache_dup (get_current_regcache ());
fp->clobber_regs = clobber_regs; fp->clobber_regs = clobber_regs;
fp->pc = read_pc (); fp->pc = read_pc ();

34
gdb/linux-nat.c
View file

@ -2583,19 +2583,26 @@ linux_nat_do_thread_registers (bfd *obfd, ptid_t ptid,
gdb_fpxregset_t fpxregs; gdb_fpxregset_t fpxregs;
#endif #endif
unsigned long lwp = ptid_get_lwp (ptid); unsigned long lwp = ptid_get_lwp (ptid);
struct gdbarch *gdbarch = current_gdbarch; struct regcache *regcache = get_thread_regcache (ptid);
struct gdbarch *gdbarch = get_regcache_arch (regcache);
const struct regset *regset; const struct regset *regset;
int core_regset_p; int core_regset_p;
struct cleanup *old_chain;
old_chain = save_inferior_ptid ();
inferior_ptid = ptid;
target_fetch_registers (regcache, -1);
do_cleanups (old_chain);
core_regset_p = gdbarch_regset_from_core_section_p (gdbarch); core_regset_p = gdbarch_regset_from_core_section_p (gdbarch);
if (core_regset_p if (core_regset_p
&& (regset = gdbarch_regset_from_core_section (gdbarch, ".reg", && (regset = gdbarch_regset_from_core_section (gdbarch, ".reg",
sizeof (gregs))) != NULL sizeof (gregs))) != NULL
&& regset->collect_regset != NULL) && regset->collect_regset != NULL)
regset->collect_regset (regset, current_regcache, -1, regset->collect_regset (regset, regcache, -1,
&gregs, sizeof (gregs)); &gregs, sizeof (gregs));
else else
fill_gregset (current_regcache, &gregs, -1); fill_gregset (regcache, &gregs, -1);
note_data = (char *) elfcore_write_prstatus (obfd, note_data = (char *) elfcore_write_prstatus (obfd,
note_data, note_data,
@ -2607,10 +2614,10 @@ linux_nat_do_thread_registers (bfd *obfd, ptid_t ptid,
&& (regset = gdbarch_regset_from_core_section (gdbarch, ".reg2", && (regset = gdbarch_regset_from_core_section (gdbarch, ".reg2",
sizeof (fpregs))) != NULL sizeof (fpregs))) != NULL
&& regset->collect_regset != NULL) && regset->collect_regset != NULL)
regset->collect_regset (regset, current_regcache, -1, regset->collect_regset (regset, regcache, -1,
&fpregs, sizeof (fpregs)); &fpregs, sizeof (fpregs));
else else
fill_fpregset (current_regcache, &fpregs, -1); fill_fpregset (regcache, &fpregs, -1);
note_data = (char *) elfcore_write_prfpreg (obfd, note_data = (char *) elfcore_write_prfpreg (obfd,
note_data, note_data,
@ -2622,10 +2629,10 @@ linux_nat_do_thread_registers (bfd *obfd, ptid_t ptid,
&& (regset = gdbarch_regset_from_core_section (gdbarch, ".reg-xfp", && (regset = gdbarch_regset_from_core_section (gdbarch, ".reg-xfp",
sizeof (fpxregs))) != NULL sizeof (fpxregs))) != NULL
&& regset->collect_regset != NULL) && regset->collect_regset != NULL)
regset->collect_regset (regset, current_regcache, -1, regset->collect_regset (regset, regcache, -1,
&fpxregs, sizeof (fpxregs)); &fpxregs, sizeof (fpxregs));
else else
fill_fpxregset (current_regcache, &fpxregs, -1); fill_fpxregset (regcache, &fpxregs, -1);
note_data = (char *) elfcore_write_prxfpreg (obfd, note_data = (char *) elfcore_write_prxfpreg (obfd,
note_data, note_data,
@ -2650,21 +2657,12 @@ static int
linux_nat_corefile_thread_callback (struct lwp_info *ti, void *data) linux_nat_corefile_thread_callback (struct lwp_info *ti, void *data)
{ {
struct linux_nat_corefile_thread_data *args = data; struct linux_nat_corefile_thread_data *args = data;
ptid_t saved_ptid = inferior_ptid;
inferior_ptid = ti->ptid;
registers_changed ();
/* FIXME should not be necessary; fill_gregset should do it automatically. */
target_fetch_registers (current_regcache, -1);
args->note_data = linux_nat_do_thread_registers (args->obfd, args->note_data = linux_nat_do_thread_registers (args->obfd,
ti->ptid, ti->ptid,
args->note_data, args->note_data,
args->note_size); args->note_size);
args->num_notes++; args->num_notes++;
inferior_ptid = saved_ptid;
registers_changed ();
/* FIXME should not be necessary; fill_gregset should do it automatically. */
target_fetch_registers (current_regcache, -1);
return 0; return 0;
} }
@ -2675,15 +2673,11 @@ static char *
linux_nat_do_registers (bfd *obfd, ptid_t ptid, linux_nat_do_registers (bfd *obfd, ptid_t ptid,
char *note_data, int *note_size) char *note_data, int *note_size)
{ {
registers_changed ();
/* FIXME should not be necessary; fill_gregset should do it automatically. */
target_fetch_registers (current_regcache, -1);
return linux_nat_do_thread_registers (obfd, return linux_nat_do_thread_registers (obfd,
ptid_build (ptid_get_pid (inferior_ptid), ptid_build (ptid_get_pid (inferior_ptid),
ptid_get_pid (inferior_ptid), ptid_get_pid (inferior_ptid),
0), 0),
note_data, note_size); note_data, note_size);
return note_data;
} }
/* Fills the "to_make_corefile_note" target vector. Builds the note /* Fills the "to_make_corefile_note" target vector. Builds the note

7
gdb/m32c-tdep.c
View file

@ -2535,6 +2535,7 @@ m32c_virtual_frame_pointer (CORE_ADDR pc,
CORE_ADDR func_addr, func_end, sal_end; CORE_ADDR func_addr, func_end, sal_end;
struct m32c_prologue p; struct m32c_prologue p;
struct regcache *regcache = get_current_regcache ();
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
if (!find_pc_partial_function (pc, &name, &func_addr, &func_end)) if (!find_pc_partial_function (pc, &name, &func_addr, &func_end))
@ -2544,15 +2545,15 @@ m32c_virtual_frame_pointer (CORE_ADDR pc,
switch (p.kind) switch (p.kind)
{ {
case prologue_with_frame_ptr: case prologue_with_frame_ptr:
*frame_regnum = m32c_banked_register (tdep->fb, current_regcache)->num; *frame_regnum = m32c_banked_register (tdep->fb, regcache)->num;
*frame_offset = p.frame_ptr_offset; *frame_offset = p.frame_ptr_offset;
break; break;
case prologue_sans_frame_ptr: case prologue_sans_frame_ptr:
*frame_regnum = m32c_banked_register (tdep->sp, current_regcache)->num; *frame_regnum = m32c_banked_register (tdep->sp, regcache)->num;
*frame_offset = p.frame_size; *frame_offset = p.frame_size;
break; break;
default: default:
*frame_regnum = m32c_banked_register (tdep->sp, current_regcache)->num; *frame_regnum = m32c_banked_register (tdep->sp, regcache)->num;
*frame_offset = 0; *frame_offset = 0;
break; break;
} }

4
gdb/mep-tdep.c
View file

@ -852,7 +852,7 @@ current_me_module ()
if (target_has_registers) if (target_has_registers)
{ {
ULONGEST regval; ULONGEST regval;
regcache_cooked_read_unsigned (current_regcache, regcache_cooked_read_unsigned (get_current_regcache (),
MEP_MODULE_REGNUM, &regval); MEP_MODULE_REGNUM, &regval);
return regval; return regval;
} }
@ -875,7 +875,7 @@ current_options ()
if (target_has_registers) if (target_has_registers)
{ {
ULONGEST regval; ULONGEST regval;
regcache_cooked_read_unsigned (current_regcache, regcache_cooked_read_unsigned (get_current_regcache (),
MEP_OPT_REGNUM, &regval); MEP_OPT_REGNUM, &regval);
return regval; return regval;
} }

2
gdb/mi/mi-main.c
View file

@ -634,7 +634,7 @@ mi_cmd_data_write_register_values (char *command, char **argv, int argc)
value = parse_and_eval_address (argv[i + 1]); value = parse_and_eval_address (argv[i + 1]);
/* Write it down. */ /* Write it down. */
regcache_cooked_write_signed (current_regcache, regnum, value); regcache_cooked_write_signed (get_current_regcache (), regnum, value);
} }
else else
{ {

2
gdb/mips-tdep.c
View file

@ -4434,7 +4434,7 @@ deprecated_mips_set_processor_regs_hack (void)
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
ULONGEST prid; ULONGEST prid;
regcache_cooked_read_unsigned (current_regcache, regcache_cooked_read_unsigned (get_current_regcache (),
MIPS_PRID_REGNUM, &prid); MIPS_PRID_REGNUM, &prid);
if ((prid & ~0xf) == 0x700) if ((prid & ~0xf) == 0x700)
tdep->mips_processor_reg_names = mips_r3041_reg_names; tdep->mips_processor_reg_names = mips_r3041_reg_names;

4
gdb/monitor.c
View file

@ -1109,10 +1109,10 @@ monitor_wait (ptid_t ptid, struct target_waitstatus *status)
} }
if (current_monitor->register_pattern) if (current_monitor->register_pattern)
parse_register_dump (current_regcache, buf, resp_len); parse_register_dump (get_current_regcache (), buf, resp_len);
#else #else
monitor_debug ("Wait fetching registers after stop\n"); monitor_debug ("Wait fetching registers after stop\n");
monitor_dump_regs (current_regcache); monitor_dump_regs (get_current_regcache ());
#endif #endif
status->kind = TARGET_WAITKIND_STOPPED; status->kind = TARGET_WAITKIND_STOPPED;

24
gdb/proc-service.c
View file

@ -257,11 +257,13 @@ ps_err_e
ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset) ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset)
{ {
struct cleanup *old_chain = save_inferior_ptid (); struct cleanup *old_chain = save_inferior_ptid ();
struct regcache *regcache;
inferior_ptid = BUILD_LWP (lwpid, ph->pid); inferior_ptid = BUILD_LWP (lwpid, ph->pid);
regcache = get_thread_regcache (inferior_ptid);
target_fetch_registers (current_regcache, -1); target_fetch_registers (regcache, -1);
fill_gregset (current_regcache, (gdb_gregset_t *) gregset, -1); fill_gregset (regcache, (gdb_gregset_t *) gregset, -1);
do_cleanups (old_chain); do_cleanups (old_chain);
return PS_OK; return PS_OK;
@ -274,11 +276,13 @@ ps_err_e
ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, const prgregset_t gregset) ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, const prgregset_t gregset)
{ {
struct cleanup *old_chain = save_inferior_ptid (); struct cleanup *old_chain = save_inferior_ptid ();
struct regcache *regcache;
inferior_ptid = BUILD_LWP (lwpid, ph->pid); inferior_ptid = BUILD_LWP (lwpid, ph->pid);
regcache = get_thread_regcache (inferior_ptid);
supply_gregset (current_regcache, (const gdb_gregset_t *) gregset); supply_gregset (regcache, (const gdb_gregset_t *) gregset);
target_store_registers (current_regcache, -1); target_store_registers (regcache, -1);
do_cleanups (old_chain); do_cleanups (old_chain);
return PS_OK; return PS_OK;
@ -292,11 +296,13 @@ ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
gdb_prfpregset_t *fpregset) gdb_prfpregset_t *fpregset)
{ {
struct cleanup *old_chain = save_inferior_ptid (); struct cleanup *old_chain = save_inferior_ptid ();
struct regcache *regcache;
inferior_ptid = BUILD_LWP (lwpid, ph->pid); inferior_ptid = BUILD_LWP (lwpid, ph->pid);
regcache = get_thread_regcache (inferior_ptid);
target_fetch_registers (current_regcache, -1); target_fetch_registers (regcache, -1);
fill_fpregset (current_regcache, (gdb_fpregset_t *) fpregset, -1); fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1);
do_cleanups (old_chain); do_cleanups (old_chain);
return PS_OK; return PS_OK;
@ -310,11 +316,13 @@ ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
const gdb_prfpregset_t *fpregset) const gdb_prfpregset_t *fpregset)
{ {
struct cleanup *old_chain = save_inferior_ptid (); struct cleanup *old_chain = save_inferior_ptid ();
struct regcache *regcache;
inferior_ptid = BUILD_LWP (lwpid, ph->pid); inferior_ptid = BUILD_LWP (lwpid, ph->pid);
regcache = get_thread_regcache (inferior_ptid);
supply_fpregset (current_regcache, (const gdb_fpregset_t *) fpregset); supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
target_store_registers (current_regcache, -1); target_store_registers (regcache, -1);
do_cleanups (old_chain); do_cleanups (old_chain);
return PS_OK; return PS_OK;

7
gdb/procfs.c
View file

@ -6013,13 +6013,14 @@ static char *
procfs_do_thread_registers (bfd *obfd, ptid_t ptid, procfs_do_thread_registers (bfd *obfd, ptid_t ptid,
char *note_data, int *note_size) char *note_data, int *note_size)
{ {
struct regcache *regcache = get_thread_regcache (ptid);
gdb_gregset_t gregs; gdb_gregset_t gregs;
gdb_fpregset_t fpregs; gdb_fpregset_t fpregs;
unsigned long merged_pid; unsigned long merged_pid;
merged_pid = TIDGET (ptid) << 16 | PIDGET (ptid); merged_pid = TIDGET (ptid) << 16 | PIDGET (ptid);
fill_gregset (current_regcache, &gregs, -1); fill_gregset (regcache, &gregs, -1);
#if defined (UNIXWARE) #if defined (UNIXWARE)
note_data = (char *) elfcore_write_lwpstatus (obfd, note_data = (char *) elfcore_write_lwpstatus (obfd,
note_data, note_data,
@ -6035,7 +6036,7 @@ procfs_do_thread_registers (bfd *obfd, ptid_t ptid,
stop_signal, stop_signal,
&gregs); &gregs);
#endif #endif
fill_fpregset (current_regcache, &fpregs, -1); fill_fpregset (regcache, &fpregs, -1);
note_data = (char *) elfcore_write_prfpreg (obfd, note_data = (char *) elfcore_write_prfpreg (obfd,
note_data, note_data,
note_size, note_size,
@ -6106,7 +6107,7 @@ procfs_make_note_section (bfd *obfd, int *note_size)
psargs); psargs);
#ifdef UNIXWARE #ifdef UNIXWARE
fill_gregset (current_regcache, &gregs, -1); fill_gregset (get_current_regcache (), &gregs, -1);
note_data = elfcore_write_pstatus (obfd, note_data, note_size, note_data = elfcore_write_pstatus (obfd, note_data, note_size,
PIDGET (inferior_ptid), PIDGET (inferior_ptid),
stop_signal, &gregs); stop_signal, &gregs);

112
gdb/regcache.c
View file

@ -203,6 +203,9 @@ struct regcache
regcache_cpy(). The actual contents are determined by the regcache_cpy(). The actual contents are determined by the
reggroup_save and reggroup_restore methods. */ reggroup_save and reggroup_restore methods. */
int readonly_p; int readonly_p;
/* If this is a read-write cache, which thread's registers is
it connected to? */
ptid_t ptid;
}; };
struct regcache * struct regcache *
@ -219,6 +222,7 @@ regcache_xmalloc (struct gdbarch *gdbarch)
regcache->register_valid_p regcache->register_valid_p
= XCALLOC (descr->sizeof_raw_register_valid_p, gdb_byte); = XCALLOC (descr->sizeof_raw_register_valid_p, gdb_byte);
regcache->readonly_p = 1; regcache->readonly_p = 1;
regcache->ptid = minus_one_ptid;
return regcache; return regcache;
} }
@ -357,9 +361,9 @@ regcache_cpy_no_passthrough (struct regcache *dst, struct regcache *src)
gdb_assert (src != NULL && dst != NULL); gdb_assert (src != NULL && dst != NULL);
gdb_assert (src->descr->gdbarch == dst->descr->gdbarch); gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
/* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
move of data into the current_regcache(). Doing this would be move of data into the current regcache. Doing this would be
silly - it would mean that valid_p would be completely invalid. */ silly - it would mean that valid_p would be completely invalid. */
gdb_assert (dst != current_regcache); gdb_assert (dst->readonly_p);
memcpy (dst->registers, src->registers, dst->descr->sizeof_raw_registers); memcpy (dst->registers, src->registers, dst->descr->sizeof_raw_registers);
memcpy (dst->register_valid_p, src->register_valid_p, memcpy (dst->register_valid_p, src->register_valid_p,
dst->descr->sizeof_raw_register_valid_p); dst->descr->sizeof_raw_register_valid_p);
@ -369,7 +373,6 @@ struct regcache *
regcache_dup (struct regcache *src) regcache_dup (struct regcache *src)
{ {
struct regcache *newbuf; struct regcache *newbuf;
gdb_assert (current_regcache != NULL);
newbuf = regcache_xmalloc (src->descr->gdbarch); newbuf = regcache_xmalloc (src->descr->gdbarch);
regcache_cpy (newbuf, src); regcache_cpy (newbuf, src);
return newbuf; return newbuf;
@ -379,7 +382,6 @@ struct regcache *
regcache_dup_no_passthrough (struct regcache *src) regcache_dup_no_passthrough (struct regcache *src)
{ {
struct regcache *newbuf; struct regcache *newbuf;
gdb_assert (current_regcache != NULL);
newbuf = regcache_xmalloc (src->descr->gdbarch); newbuf = regcache_xmalloc (src->descr->gdbarch);
regcache_cpy_no_passthrough (newbuf, src); regcache_cpy_no_passthrough (newbuf, src);
return newbuf; return newbuf;
@ -412,16 +414,38 @@ regcache_invalidate (struct regcache *regcache, int regnum)
/* Global structure containing the current regcache. */ /* Global structure containing the current regcache. */
/* FIXME: cagney/2002-05-11: The two global arrays registers[] and /* FIXME: cagney/2002-05-11: The two global arrays registers[] and
deprecated_register_valid[] currently point into this structure. */ deprecated_register_valid[] currently point into this structure. */
struct regcache *current_regcache; static struct regcache *current_regcache;
/* NOTE: this is a write-through cache. There is no "dirty" bit for /* NOTE: this is a write-through cache. There is no "dirty" bit for
recording if the register values have been changed (eg. by the recording if the register values have been changed (eg. by the
user). Therefore all registers must be written back to the user). Therefore all registers must be written back to the
target when appropriate. */ target when appropriate. */
/* The thread/process associated with the current set of registers. */ struct regcache *get_thread_regcache (ptid_t ptid)
{
/* NOTE: uweigand/2007-05-05: We need to detect the thread's
current architecture at this point. */
struct gdbarch *thread_gdbarch = current_gdbarch;
if (current_regcache && ptid_equal (current_regcache->ptid, ptid)
&& get_regcache_arch (current_regcache) == thread_gdbarch)
return current_regcache;
if (current_regcache)
regcache_xfree (current_regcache);
current_regcache = regcache_xmalloc (thread_gdbarch);
current_regcache->readonly_p = 0;
current_regcache->ptid = ptid;
return current_regcache;
}
struct regcache *get_current_regcache (void)
{
return get_thread_regcache (inferior_ptid);
}
static ptid_t registers_ptid;
/* Observer for the target_changed event. */ /* Observer for the target_changed event. */
@ -447,7 +471,8 @@ registers_changed (void)
{ {
int i; int i;
registers_ptid = pid_to_ptid (-1); regcache_xfree (current_regcache);
current_regcache = NULL;
/* Force cleanup of any alloca areas if using C alloca instead of /* Force cleanup of any alloca areas if using C alloca instead of
a builtin alloca. This particular call is used to clean up a builtin alloca. This particular call is used to clean up
@ -455,9 +480,6 @@ registers_changed (void)
during lengthy interactions between gdb and the target before during lengthy interactions between gdb and the target before
gdb gives control to the user (ie watchpoints). */ gdb gives control to the user (ie watchpoints). */
alloca (0); alloca (0);
for (i = 0; i < current_regcache->descr->nr_raw_registers; i++)
regcache_invalidate (current_regcache, i);
} }
@ -472,14 +494,13 @@ regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
On the bright side, at least there is a regcache object. */ On the bright side, at least there is a regcache object. */
if (!regcache->readonly_p) if (!regcache->readonly_p)
{ {
gdb_assert (regcache == current_regcache);
if (! ptid_equal (registers_ptid, inferior_ptid))
{
registers_changed ();
registers_ptid = inferior_ptid;
}
if (!regcache_valid_p (regcache, regnum)) if (!regcache_valid_p (regcache, regnum))
target_fetch_registers (regcache, regnum); {
struct cleanup *old_chain = save_inferior_ptid ();
inferior_ptid = regcache->ptid;
target_fetch_registers (regcache, regnum);
do_cleanups (old_chain);
}
#if 0 #if 0
/* FIXME: cagney/2004-08-07: At present a number of targets /* FIXME: cagney/2004-08-07: At present a number of targets
forget (or didn't know that they needed) to set this leading to forget (or didn't know that they needed) to set this leading to
@ -615,6 +636,8 @@ void
regcache_raw_write (struct regcache *regcache, int regnum, regcache_raw_write (struct regcache *regcache, int regnum,
const gdb_byte *buf) const gdb_byte *buf)
{ {
struct cleanup *old_chain;
gdb_assert (regcache != NULL && buf != NULL); gdb_assert (regcache != NULL && buf != NULL);
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers); gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
gdb_assert (!regcache->readonly_p); gdb_assert (!regcache->readonly_p);
@ -624,14 +647,6 @@ regcache_raw_write (struct regcache *regcache, int regnum,
if (gdbarch_cannot_store_register (current_gdbarch, regnum)) if (gdbarch_cannot_store_register (current_gdbarch, regnum))
return; return;
/* Make certain that the correct cache is selected. */
gdb_assert (regcache == current_regcache);
if (! ptid_equal (registers_ptid, inferior_ptid))
{
registers_changed ();
registers_ptid = inferior_ptid;
}
/* If we have a valid copy of the register, and new value == old /* If we have a valid copy of the register, and new value == old
value, then don't bother doing the actual store. */ value, then don't bother doing the actual store. */
if (regcache_valid_p (regcache, regnum) if (regcache_valid_p (regcache, regnum)
@ -639,11 +654,16 @@ regcache_raw_write (struct regcache *regcache, int regnum,
regcache->descr->sizeof_register[regnum]) == 0)) regcache->descr->sizeof_register[regnum]) == 0))
return; return;
old_chain = save_inferior_ptid ();
inferior_ptid = regcache->ptid;
target_prepare_to_store (regcache); target_prepare_to_store (regcache);
memcpy (register_buffer (regcache, regnum), buf, memcpy (register_buffer (regcache, regnum), buf,
regcache->descr->sizeof_register[regnum]); regcache->descr->sizeof_register[regnum]);
regcache->register_valid_p[regnum] = 1; regcache->register_valid_p[regnum] = 1;
target_store_registers (regcache, regnum); target_store_registers (regcache, regnum);
do_cleanups (old_chain);
} }
void void
@ -767,15 +787,6 @@ regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers); gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
gdb_assert (!regcache->readonly_p); gdb_assert (!regcache->readonly_p);
/* FIXME: kettenis/20030828: It shouldn't be necessary to handle
CURRENT_REGCACHE specially here. */
if (regcache == current_regcache
&& !ptid_equal (registers_ptid, inferior_ptid))
{
registers_changed ();
registers_ptid = inferior_ptid;
}
regbuf = register_buffer (regcache, regnum); regbuf = register_buffer (regcache, regnum);
size = regcache->descr->sizeof_register[regnum]; size = regcache->descr->sizeof_register[regnum];
@ -820,16 +831,11 @@ regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
CORE_ADDR CORE_ADDR
read_pc_pid (ptid_t ptid) read_pc_pid (ptid_t ptid)
{ {
struct regcache *regcache = current_regcache; struct regcache *regcache = get_thread_regcache (ptid);
struct gdbarch *gdbarch = get_regcache_arch (regcache); struct gdbarch *gdbarch = get_regcache_arch (regcache);
ptid_t saved_inferior_ptid;
CORE_ADDR pc_val; CORE_ADDR pc_val;
/* In case ptid != inferior_ptid. */
saved_inferior_ptid = inferior_ptid;
inferior_ptid = ptid;
if (gdbarch_read_pc_p (gdbarch)) if (gdbarch_read_pc_p (gdbarch))
pc_val = gdbarch_read_pc (gdbarch, regcache); pc_val = gdbarch_read_pc (gdbarch, regcache);
/* Else use per-frame method on get_current_frame. */ /* Else use per-frame method on get_current_frame. */
@ -842,7 +848,6 @@ read_pc_pid (ptid_t ptid)
else else
internal_error (__FILE__, __LINE__, _("read_pc_pid: Unable to find PC")); internal_error (__FILE__, __LINE__, _("read_pc_pid: Unable to find PC"));
inferior_ptid = saved_inferior_ptid;
return pc_val; return pc_val;
} }
@ -855,15 +860,9 @@ read_pc (void)
void void
write_pc_pid (CORE_ADDR pc, ptid_t ptid) write_pc_pid (CORE_ADDR pc, ptid_t ptid)
{ {
struct regcache *regcache = current_regcache; struct regcache *regcache = get_thread_regcache (ptid);
struct gdbarch *gdbarch = get_regcache_arch (regcache); struct gdbarch *gdbarch = get_regcache_arch (regcache);
ptid_t saved_inferior_ptid;
/* In case ptid != inferior_ptid. */
saved_inferior_ptid = inferior_ptid;
inferior_ptid = ptid;
if (gdbarch_write_pc_p (gdbarch)) if (gdbarch_write_pc_p (gdbarch))
gdbarch_write_pc (gdbarch, regcache, pc); gdbarch_write_pc (gdbarch, regcache, pc);
else if (PC_REGNUM >= 0) else if (PC_REGNUM >= 0)
@ -871,8 +870,6 @@ write_pc_pid (CORE_ADDR pc, ptid_t ptid)
else else
internal_error (__FILE__, __LINE__, internal_error (__FILE__, __LINE__,
_("write_pc_pid: Unable to update PC")); _("write_pc_pid: Unable to update PC"));
inferior_ptid = saved_inferior_ptid;
} }
void void
@ -891,13 +888,6 @@ reg_flush_command (char *command, int from_tty)
printf_filtered (_("Register cache flushed.\n")); printf_filtered (_("Register cache flushed.\n"));
} }
static void
build_regcache (void)
{
current_regcache = regcache_xmalloc (current_gdbarch);
current_regcache->readonly_p = 0;
}
static void static void
dump_endian_bytes (struct ui_file *file, enum bfd_endian endian, dump_endian_bytes (struct ui_file *file, enum bfd_endian endian,
const unsigned char *buf, long len) const unsigned char *buf, long len)
@ -1162,18 +1152,12 @@ void
_initialize_regcache (void) _initialize_regcache (void)
{ {
regcache_descr_handle = gdbarch_data_register_post_init (init_regcache_descr); regcache_descr_handle = gdbarch_data_register_post_init (init_regcache_descr);
DEPRECATED_REGISTER_GDBARCH_SWAP (current_regcache);
deprecated_register_gdbarch_swap (NULL, 0, build_regcache);
observer_attach_target_changed (regcache_observer_target_changed); observer_attach_target_changed (regcache_observer_target_changed);
add_com ("flushregs", class_maintenance, reg_flush_command, add_com ("flushregs", class_maintenance, reg_flush_command,
_("Force gdb to flush its register cache (maintainer command)")); _("Force gdb to flush its register cache (maintainer command)"));
/* Initialize the thread/process associated with the current set of
registers. For now, -1 is special, and means `no current process'. */
registers_ptid = pid_to_ptid (-1);
add_cmd ("registers", class_maintenance, maintenance_print_registers, _("\ add_cmd ("registers", class_maintenance, maintenance_print_registers, _("\
Print the internal register configuration.\n\ Print the internal register configuration.\n\
Takes an optional file parameter."), &maintenanceprintlist); Takes an optional file parameter."), &maintenanceprintlist);

3
gdb/regcache.h
View file

@ -26,7 +26,8 @@
struct regcache; struct regcache;
struct gdbarch; struct gdbarch;
extern struct regcache *current_regcache; extern struct regcache *get_current_regcache (void);
extern struct regcache *get_thread_regcache (ptid_t ptid);
void regcache_xfree (struct regcache *regcache); void regcache_xfree (struct regcache *regcache);
struct cleanup *make_cleanup_regcache_xfree (struct regcache *regcache); struct cleanup *make_cleanup_regcache_xfree (struct regcache *regcache);

9
gdb/remote-mips.c
View file

@ -1755,19 +1755,20 @@ mips_wait (ptid_t ptid, struct target_waitstatus *status)
&rpc, &rfp, &rsp, flags); &rpc, &rfp, &rsp, flags);
if (nfields >= 3) if (nfields >= 3)
{ {
struct regcache *regcache = get_current_regcache ();
char buf[MAX_REGISTER_SIZE]; char buf[MAX_REGISTER_SIZE];
store_unsigned_integer (buf, register_size (current_gdbarch, PC_REGNUM), rpc); store_unsigned_integer (buf, register_size (current_gdbarch, PC_REGNUM), rpc);
regcache_raw_supply (current_regcache, PC_REGNUM, buf); regcache_raw_supply (regcache, PC_REGNUM, buf);
store_unsigned_integer (buf, register_size (current_gdbarch, PC_REGNUM), rfp); store_unsigned_integer (buf, register_size (current_gdbarch, PC_REGNUM), rfp);
regcache_raw_supply (current_regcache, 30, buf); /* This register they are avoiding and so it is unnamed */ regcache_raw_supply (regcache, 30, buf); /* This register they are avoiding and so it is unnamed */
store_unsigned_integer (buf, register_size (current_gdbarch, SP_REGNUM), rsp); store_unsigned_integer (buf, register_size (current_gdbarch, SP_REGNUM), rsp);
regcache_raw_supply (current_regcache, SP_REGNUM, buf); regcache_raw_supply (regcache, SP_REGNUM, buf);
store_unsigned_integer (buf, register_size (current_gdbarch, DEPRECATED_FP_REGNUM), 0); store_unsigned_integer (buf, register_size (current_gdbarch, DEPRECATED_FP_REGNUM), 0);
regcache_raw_supply (current_regcache, DEPRECATED_FP_REGNUM, buf); regcache_raw_supply (regcache, DEPRECATED_FP_REGNUM, buf);
if (nfields == 9) if (nfields == 9)
{ {

5
gdb/remote.c
View file

@ -3232,7 +3232,7 @@ Packet: '%s'\n"),
if (fieldsize < register_size (current_gdbarch, if (fieldsize < register_size (current_gdbarch,
reg->regnum)) reg->regnum))
warning (_("Remote reply is too short: %s"), buf); warning (_("Remote reply is too short: %s"), buf);
regcache_raw_supply (current_regcache, regcache_raw_supply (get_current_regcache (),
reg->regnum, regs); reg->regnum, regs);
} }
@ -3429,7 +3429,8 @@ Packet: '%s'\n"),
if (fieldsize < register_size (current_gdbarch, if (fieldsize < register_size (current_gdbarch,
reg->regnum)) reg->regnum))
warning (_("Remote reply is too short: %s"), buf); warning (_("Remote reply is too short: %s"), buf);
regcache_raw_supply (current_regcache, reg->regnum, regs); regcache_raw_supply (get_current_regcache (),
reg->regnum, regs);
} }
if (*p++ != ';') if (*p++ != ';')

32
gdb/sol-thread.c
View file

@ -1087,16 +1087,18 @@ ps_err_e
ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset) ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset)
{ {
struct cleanup *old_chain; struct cleanup *old_chain;
struct regcache *regcache;
old_chain = save_inferior_ptid (); old_chain = save_inferior_ptid ();
inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid)); inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
regcache = get_thread_regcache (inferior_ptid);
if (target_has_execution) if (target_has_execution)
procfs_ops.to_fetch_registers (current_regcache, -1); procfs_ops.to_fetch_registers (regcache, -1);
else else
orig_core_ops.to_fetch_registers (current_regcache, -1); orig_core_ops.to_fetch_registers (regcache, -1);
fill_gregset (current_regcache, (gdb_gregset_t *) gregset, -1); fill_gregset (regcache, (gdb_gregset_t *) gregset, -1);
do_cleanups (old_chain); do_cleanups (old_chain);
@ -1110,16 +1112,18 @@ ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
const prgregset_t gregset) const prgregset_t gregset)
{ {
struct cleanup *old_chain; struct cleanup *old_chain;
struct regcache *regcache;
old_chain = save_inferior_ptid (); old_chain = save_inferior_ptid ();
inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid)); inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
regcache = get_thread_regcache (inferior_ptid);
supply_gregset (current_regcache, (const gdb_gregset_t *) gregset); supply_gregset (regcache, (const gdb_gregset_t *) gregset);
if (target_has_execution) if (target_has_execution)
procfs_ops.to_store_registers (current_regcache, -1); procfs_ops.to_store_registers (regcache, -1);
else else
orig_core_ops.to_store_registers (current_regcache, -1); orig_core_ops.to_store_registers (regcache, -1);
do_cleanups (old_chain); do_cleanups (old_chain);
@ -1219,16 +1223,18 @@ ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
prfpregset_t *fpregset) prfpregset_t *fpregset)
{ {
struct cleanup *old_chain; struct cleanup *old_chain;
struct regcache *regcache;
old_chain = save_inferior_ptid (); old_chain = save_inferior_ptid ();
inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid)); inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
regcache = get_thread_regcache (inferior_ptid);
if (target_has_execution) if (target_has_execution)
procfs_ops.to_fetch_registers (current_regcache, -1); procfs_ops.to_fetch_registers (regcache, -1);
else else
orig_core_ops.to_fetch_registers (current_regcache, -1); orig_core_ops.to_fetch_registers (regcache, -1);
fill_fpregset (current_regcache, (gdb_fpregset_t *) fpregset, -1); fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1);
do_cleanups (old_chain); do_cleanups (old_chain);
@ -1242,16 +1248,18 @@ ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
const prfpregset_t * fpregset) const prfpregset_t * fpregset)
{ {
struct cleanup *old_chain; struct cleanup *old_chain;
struct regcache *regcache;
old_chain = save_inferior_ptid (); old_chain = save_inferior_ptid ();
inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid)); inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
regcache = get_thread_regcache (inferior_ptid);
supply_fpregset (current_regcache, (const gdb_fpregset_t *) fpregset); supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
if (target_has_execution) if (target_has_execution)
procfs_ops.to_store_registers (current_regcache, -1); procfs_ops.to_store_registers (regcache, -1);
else else
orig_core_ops.to_store_registers (current_regcache, -1); orig_core_ops.to_store_registers (regcache, -1);
do_cleanups (old_chain); do_cleanups (old_chain);

2
gdb/stack.c
View file

@ -1850,7 +1850,7 @@ If you continue, the return value that you specified will be ignored.\n";
NULL, NULL, NULL) NULL, NULL, NULL)
== RETURN_VALUE_REGISTER_CONVENTION); == RETURN_VALUE_REGISTER_CONVENTION);
gdbarch_return_value (current_gdbarch, return_type, gdbarch_return_value (current_gdbarch, return_type,
current_regcache, NULL /*read*/, get_current_regcache (), NULL /*read*/,
value_contents (return_value) /*write*/); value_contents (return_value) /*write*/);
} }

2
gdb/win32-nat.c
View file

@ -1318,7 +1318,7 @@ win32_resume (ptid_t ptid, int step, enum target_signal sig)
if (step) if (step)
{ {
/* Single step by setting t bit */ /* Single step by setting t bit */
win32_fetch_inferior_registers (current_regcache, PS_REGNUM); win32_fetch_inferior_registers (get_current_regcache (), PS_REGNUM);
th->context.EFlags |= FLAG_TRACE_BIT; th->context.EFlags |= FLAG_TRACE_BIT;
} }

2
gdb/windows-nat.c
View file

@ -1318,7 +1318,7 @@ win32_resume (ptid_t ptid, int step, enum target_signal sig)
if (step) if (step)
{ {
/* Single step by setting t bit */ /* Single step by setting t bit */
win32_fetch_inferior_registers (current_regcache, PS_REGNUM); win32_fetch_inferior_registers (get_current_regcache (), PS_REGNUM);
th->context.EFlags |= FLAG_TRACE_BIT; th->context.EFlags |= FLAG_TRACE_BIT;
} }