From 9c742269ec8507d924d7a0c815155ca5aa21467a Mon Sep 17 00:00:00 2001 From: Simon Marchi Date: Sun, 5 Nov 2023 04:47:26 +0000 Subject: [PATCH] gdb: remove get_current_regcache Remove get_current_regcache, inlining the call to get_thread_regcache in callers. When possible, pass the right thread_info object known from the local context. Otherwise, fall back to passing `inferior_thread ()`. This makes the reference to global context bubble up one level, a small step towards the long term goal of reducing the number of references to global context (or rather, moving those references as close as possible to the top of the call tree). No behavior change expected. Change-Id: Ifa6980c88825d803ea586546b6b4c633c33be8d6 --- gdb/arc-tdep.c | 6 +++--- gdb/breakpoint.c | 2 +- gdb/bsd-kvm.c | 6 +++--- gdb/corelow.c | 2 +- gdb/frame.c | 9 +++++---- gdb/frv-tdep.c | 2 +- gdb/i386-fbsd-nat.c | 2 +- gdb/i386-tdep.c | 3 +-- gdb/ia64-linux-nat.c | 2 +- gdb/infcall.c | 7 ++++--- gdb/infcmd.c | 5 +++-- gdb/infrun.c | 23 ++++++++++------------- gdb/linux-fork.c | 10 ++++++---- gdb/m32c-tdep.c | 2 +- gdb/mep-tdep.c | 4 ++-- gdb/mi/mi-main.c | 3 +-- gdb/or1k-tdep.c | 2 +- gdb/procfs.c | 2 +- gdb/record-btrace.c | 2 +- gdb/record-full.c | 20 ++++++++++---------- gdb/regcache-dump.c | 5 +++-- gdb/regcache.c | 6 ------ gdb/regcache.h | 1 - gdb/reverse.c | 7 ++++--- gdb/solib-darwin.c | 6 +++--- gdb/solib-svr4.c | 2 +- gdb/stack.c | 6 +++--- gdb/symfile.c | 2 +- gdb/tracepoint.c | 4 ++-- gdb/windows-nat.c | 4 ++-- gdb/xtensa-tdep.c | 6 ++++-- 31 files changed, 80 insertions(+), 83 deletions(-) diff --git a/gdb/arc-tdep.c b/gdb/arc-tdep.c index 0740eff02e4..a22b5bff246 100644 --- a/gdb/arc-tdep.c +++ b/gdb/arc-tdep.c @@ -322,7 +322,7 @@ arc_insn_get_operand_value (const struct arc_instruction &insn, return insn.operands[operand_num].value; default: /* Value in instruction is a register number. */ - struct regcache *regcache = get_current_regcache (); + regcache *regcache = get_thread_regcache (inferior_thread ()); ULONGEST value; regcache_cooked_read_unsigned (regcache, insn.operands[operand_num].value, @@ -351,7 +351,7 @@ arc_insn_get_operand_value_signed (const struct arc_instruction &insn, return insn.operands[operand_num].value; default: /* Value in instruction is a register number. */ - struct regcache *regcache = get_current_regcache (); + regcache *regcache = get_thread_regcache (inferior_thread ()); LONGEST value; regcache_cooked_read_signed (regcache, insn.operands[operand_num].value, @@ -449,7 +449,7 @@ arc_insn_get_branch_target (const struct arc_instruction &insn) /* LEAVE_S: PC = BLINK. */ else if (insn.insn_class == LEAVE) { - struct regcache *regcache = get_current_regcache (); + regcache *regcache = get_thread_regcache (inferior_thread ()); ULONGEST value; regcache_cooked_read_unsigned (regcache, ARC_BLINK_REGNUM, &value); return value; diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c index a6b9b2402ed..cd8f36fbf05 100644 --- a/gdb/breakpoint.c +++ b/gdb/breakpoint.c @@ -13946,7 +13946,7 @@ insert_single_step_breakpoint (struct gdbarch *gdbarch, int insert_single_step_breakpoints (struct gdbarch *gdbarch) { - struct regcache *regcache = get_current_regcache (); + regcache *regcache = get_thread_regcache (inferior_thread ()); std::vector next_pcs; next_pcs = gdbarch_software_single_step (gdbarch, regcache); diff --git a/gdb/bsd-kvm.c b/gdb/bsd-kvm.c index 0ed95f6246c..bb2d038b2ce 100644 --- a/gdb/bsd-kvm.c +++ b/gdb/bsd-kvm.c @@ -136,7 +136,7 @@ bsd_kvm_target_open (const char *arg, int from_tty) thread_info *thr = add_thread_silent (&bsd_kvm_ops, bsd_kvm_ptid); switch_to_thread (thr); - target_fetch_registers (get_current_regcache (), -1); + target_fetch_registers (get_thread_regcache (thr), -1); reinit_frame_cache (); print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1); @@ -334,7 +334,7 @@ bsd_kvm_proc_cmd (const char *arg, int fromtty) if (kvm_read (core_kd, addr, &bsd_kvm_paddr, sizeof bsd_kvm_paddr) == -1) error (("%s"), kvm_geterr (core_kd)); - target_fetch_registers (get_current_regcache (), -1); + target_fetch_registers (get_thread_regcache (inferior_thread ()), -1); reinit_frame_cache (); print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1); @@ -354,7 +354,7 @@ bsd_kvm_pcb_cmd (const char *arg, int fromtty) bsd_kvm_paddr = (struct pcb *)(u_long) parse_and_eval_address (arg); - target_fetch_registers (get_current_regcache (), -1); + target_fetch_registers (get_thread_regcache (inferior_thread ()), -1); reinit_frame_cache (); print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1); diff --git a/gdb/corelow.c b/gdb/corelow.c index 91b442b4426..a38d9622f39 100644 --- a/gdb/corelow.c +++ b/gdb/corelow.c @@ -773,7 +773,7 @@ core_target_open (const char *arg, int from_tty) } /* Fetch all registers from core file. */ - target_fetch_registers (get_current_regcache (), -1); + target_fetch_registers (get_thread_regcache (inferior_thread ()), -1); /* Now, set up the frame cache, and print the top of stack. */ reinit_frame_cache (); diff --git a/gdb/frame.c b/gdb/frame.c index dfd92991d99..5ac84a8d0cd 100644 --- a/gdb/frame.c +++ b/gdb/frame.c @@ -1164,7 +1164,7 @@ frame_pop (frame_info_ptr this_frame) definition can lead to targets writing back bogus values (arguably a bug in the target code mind). */ /* Now copy those saved registers into the current regcache. */ - get_current_regcache ()->restore (scratch.get ()); + get_thread_regcache (inferior_thread ())->restore (scratch.get ()); /* We've made right mess of GDB's local state, just discard everything. */ @@ -1445,7 +1445,7 @@ put_frame_register (frame_info_ptr frame, int regnum, break; } case lval_register: - get_current_regcache ()->cooked_write (realnum, buf); + get_thread_regcache (inferior_thread ())->cooked_write (realnum, buf); break; default: error (_("Attempt to assign to an unmodifiable value.")); @@ -1690,7 +1690,8 @@ get_current_frame (void) if (sentinel_frame == NULL) sentinel_frame = create_sentinel_frame (current_program_space, current_inferior ()->aspace, - get_current_regcache (), 0, 0).get (); + get_thread_regcache (inferior_thread ()), + 0, 0).get (); /* Set the current frame before computing the frame id, to avoid recursion inside compute_frame_id, in case the frame's @@ -2024,7 +2025,7 @@ create_new_frame (frame_id id) fi->next = create_sentinel_frame (current_program_space, current_inferior ()->aspace, - get_current_regcache (), + get_thread_regcache (inferior_thread ()), id.stack_addr, id.code_addr).get (); /* Set/update this frame's cached PC value, found in the next frame. diff --git a/gdb/frv-tdep.c b/gdb/frv-tdep.c index 3656f6fcb66..6528cf3e405 100644 --- a/gdb/frv-tdep.c +++ b/gdb/frv-tdep.c @@ -114,7 +114,7 @@ frv_fdpic_loadmap_addresses (struct gdbarch *gdbarch, CORE_ADDR *interp_addr, return -1; else { - struct regcache *regcache = get_current_regcache (); + regcache *regcache = get_thread_regcache (inferior_thread ()); if (interp_addr != NULL) { diff --git a/gdb/i386-fbsd-nat.c b/gdb/i386-fbsd-nat.c index e2c0e611717..7eb3b40e369 100644 --- a/gdb/i386-fbsd-nat.c +++ b/gdb/i386-fbsd-nat.c @@ -233,7 +233,7 @@ i386_fbsd_nat_target::resume (ptid_t ptid, int step, enum gdb_signal signal) if (!step) { - struct regcache *regcache = get_current_regcache (); + regcache *regcache = get_thread_regcache (inferior_thread ()); ULONGEST eflags; /* Workaround for a bug in FreeBSD. Make sure that the trace diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c index 1ddca2410fd..f5ff55de47a 100644 --- a/gdb/i386-tdep.c +++ b/gdb/i386-tdep.c @@ -8907,11 +8907,10 @@ i386_target_description (uint64_t xcr0, bool segments) static unsigned long i386_mpx_bd_base (void) { - struct regcache *rcache; ULONGEST ret; enum register_status regstatus; - rcache = get_current_regcache (); + regcache *rcache = get_thread_regcache (inferior_thread ()); gdbarch *arch = rcache->arch (); i386_gdbarch_tdep *tdep = gdbarch_tdep (arch); diff --git a/gdb/ia64-linux-nat.c b/gdb/ia64-linux-nat.c index f9f21d8e067..a610de60d44 100644 --- a/gdb/ia64-linux-nat.c +++ b/gdb/ia64-linux-nat.c @@ -693,7 +693,7 @@ ia64_linux_nat_target::stopped_data_address (CORE_ADDR *addr_p) { CORE_ADDR psr; siginfo_t siginfo; - struct regcache *regcache = get_current_regcache (); + regcache *regcache = get_thread_regcache (inferior_thread ()); if (!linux_nat_get_siginfo (inferior_ptid, &siginfo)) return false; diff --git a/gdb/infcall.c b/gdb/infcall.c index e62c2205808..8252feea074 100644 --- a/gdb/infcall.c +++ b/gdb/infcall.c @@ -482,7 +482,7 @@ get_call_return_value (struct call_return_meta_info *ri) else { gdbarch_return_value_as_value (ri->gdbarch, ri->function, ri->value_type, - get_current_regcache (), + get_thread_regcache (inferior_thread ()), &retval, NULL); if (stack_temporaries && class_or_union_p (ri->value_type)) { @@ -1068,7 +1068,7 @@ call_function_by_hand_dummy (struct value *function, sp = push_dummy_code (gdbarch, sp, funaddr, args, target_values_type, &real_pc, &bp_addr, - get_current_regcache ()); + get_thread_regcache (inferior_thread ())); /* Write a legitimate instruction at the point where the infcall breakpoint is going to be inserted. While this instruction @@ -1270,7 +1270,8 @@ call_function_by_hand_dummy (struct value *function, /* Create the dummy stack frame. Pass in the call dummy address as, presumably, the ABI code knows where, in the call dummy, the return address should be pointed. */ - sp = gdbarch_push_dummy_call (gdbarch, function, get_current_regcache (), + sp = gdbarch_push_dummy_call (gdbarch, function, + get_thread_regcache (inferior_thread ()), bp_addr, args.size (), args.data (), sp, return_method, struct_addr); diff --git a/gdb/infcmd.c b/gdb/infcmd.c index cf8cd527955..8890a16eade 100644 --- a/gdb/infcmd.c +++ b/gdb/infcmd.c @@ -496,7 +496,8 @@ run_command_1 (const char *args, int from_tty, enum run_how run_how) /* Start the target running. Do not use -1 continuation as it would skip breakpoint right at the entry point. */ - proceed (regcache_read_pc (get_current_regcache ()), GDB_SIGNAL_0); + proceed (regcache_read_pc (get_thread_regcache (inferior_thread ())), + GDB_SIGNAL_0); /* Since there was no error, there's no need to finish the thread states here. */ @@ -1466,7 +1467,7 @@ advance_command (const char *arg, int from_tty) struct value * get_return_value (struct symbol *func_symbol, struct value *function) { - regcache *stop_regs = get_current_regcache (); + regcache *stop_regs = get_thread_regcache (inferior_thread ()); struct gdbarch *gdbarch = stop_regs->arch (); struct value *value; diff --git a/gdb/infrun.c b/gdb/infrun.c index 785a4e198ec..4138d00b0f4 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -2621,9 +2621,9 @@ do_target_resume (ptid_t resume_ptid, bool step, enum gdb_signal sig) static void resume_1 (enum gdb_signal sig) { - struct regcache *regcache = get_current_regcache (); - struct gdbarch *gdbarch = regcache->arch (); struct thread_info *tp = inferior_thread (); + regcache *regcache = get_thread_regcache (tp); + struct gdbarch *gdbarch = regcache->arch (); ptid_t resume_ptid; /* This represents the user's step vs continue request. When deciding whether "set scheduler-locking step" applies, it's the @@ -3566,7 +3566,6 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal) { INFRUN_SCOPED_DEBUG_ENTER_EXIT; - struct regcache *regcache; struct gdbarch *gdbarch; CORE_ADDR pc; @@ -3587,15 +3586,13 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal) /* We'll update this if & when we switch to a new thread. */ update_previous_thread (); - regcache = get_current_regcache (); - gdbarch = regcache->arch (); - - pc = regcache_read_pc_protected (regcache); - thread_info *cur_thr = inferior_thread (); - infrun_debug_printf ("cur_thr = %s", cur_thr->ptid.to_string ().c_str ()); + regcache *regcache = get_thread_regcache (cur_thr); + gdbarch = regcache->arch (); + pc = regcache_read_pc_protected (regcache); + /* Fill in with reasonable starting values. */ init_thread_stepping_state (cur_thr); @@ -8894,7 +8891,7 @@ keep_going_pass_signal (struct execution_control_state *ecs) } else { - struct regcache *regcache = get_current_regcache (); + regcache *regcache = get_thread_regcache (ecs->event_thread); int remove_bp; int remove_wps; step_over_what step_what; @@ -9112,7 +9109,7 @@ print_signal_received_reason (struct ui_out *uiout, enum gdb_signal siggnal) annotate_signal_string (); uiout->field_string ("signal-meaning", gdb_signal_to_string (siggnal)); - struct regcache *regcache = get_current_regcache (); + regcache *regcache = get_thread_regcache (thr); struct gdbarch *gdbarch = regcache->arch (); if (gdbarch_report_signal_info_p (gdbarch)) gdbarch_report_signal_info (gdbarch, uiout, siggnal); @@ -10026,7 +10023,7 @@ infcall_suspend_state_up save_infcall_suspend_state () { struct thread_info *tp = inferior_thread (); - struct regcache *regcache = get_current_regcache (); + regcache *regcache = get_thread_regcache (tp); struct gdbarch *gdbarch = regcache->arch (); infcall_suspend_state_up inf_state @@ -10047,7 +10044,7 @@ void restore_infcall_suspend_state (struct infcall_suspend_state *inf_state) { struct thread_info *tp = inferior_thread (); - struct regcache *regcache = get_current_regcache (); + regcache *regcache = get_thread_regcache (inferior_thread ()); struct gdbarch *gdbarch = regcache->arch (); inf_state->restore (gdbarch, tp, regcache); diff --git a/gdb/linux-fork.c b/gdb/linux-fork.c index 52e385411c7..39c3a6b3448 100644 --- a/gdb/linux-fork.c +++ b/gdb/linux-fork.c @@ -219,12 +219,13 @@ fork_load_infrun_state (struct fork_info *fp) linux_nat_switch_fork (fp->ptid); if (fp->savedregs) - get_current_regcache ()->restore (fp->savedregs); + get_thread_regcache (inferior_thread ())->restore (fp->savedregs); registers_changed (); reinit_frame_cache (); - inferior_thread ()->set_stop_pc (regcache_read_pc (get_current_regcache ())); + inferior_thread ()->set_stop_pc + (regcache_read_pc (get_thread_regcache (inferior_thread ()))); nullify_last_target_wait_ptid (); /* Now restore the file positions of open file descriptors. */ @@ -251,8 +252,9 @@ fork_save_infrun_state (struct fork_info *fp) if (fp->savedregs) delete fp->savedregs; - fp->savedregs = new readonly_detached_regcache (*get_current_regcache ()); - fp->pc = regcache_read_pc (get_current_regcache ()); + fp->savedregs = new readonly_detached_regcache + (*get_thread_regcache (inferior_thread ())); + fp->pc = regcache_read_pc (get_thread_regcache (inferior_thread ())); /* Now save the 'state' (file position) of all open file descriptors. Unfortunately fork does not take care of that for us... */ diff --git a/gdb/m32c-tdep.c b/gdb/m32c-tdep.c index e06dbbe12bf..a0f1779c41b 100644 --- a/gdb/m32c-tdep.c +++ b/gdb/m32c-tdep.c @@ -2556,7 +2556,7 @@ m32c_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR func_addr, func_end; struct m32c_prologue p; - struct regcache *regcache = get_current_regcache (); + regcache *regcache = get_thread_regcache (inferior_thread ()); m32c_gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (!find_pc_partial_function (pc, &name, &func_addr, &func_end)) diff --git a/gdb/mep-tdep.c b/gdb/mep-tdep.c index a84df4e1f53..6210b929f9d 100644 --- a/gdb/mep-tdep.c +++ b/gdb/mep-tdep.c @@ -852,7 +852,7 @@ current_me_module (void) if (target_has_registers ()) { ULONGEST regval; - regcache_cooked_read_unsigned (get_current_regcache (), + regcache_cooked_read_unsigned (get_thread_regcache (inferior_thread ()), MEP_MODULE_REGNUM, ®val); return (CONFIG_ATTR) regval; } @@ -879,7 +879,7 @@ current_options (void) if (target_has_registers ()) { ULONGEST regval; - regcache_cooked_read_unsigned (get_current_regcache (), + regcache_cooked_read_unsigned (get_thread_regcache (inferior_thread ()), MEP_OPT_REGNUM, ®val); return regval; } diff --git a/gdb/mi/mi-main.c b/gdb/mi/mi-main.c index 944c9116731..abcd0d392ba 100644 --- a/gdb/mi/mi-main.c +++ b/gdb/mi/mi-main.c @@ -1132,7 +1132,6 @@ void mi_cmd_data_write_register_values (const char *command, const char *const *argv, int argc) { - struct regcache *regcache; struct gdbarch *gdbarch; int numregs, i; @@ -1143,7 +1142,7 @@ mi_cmd_data_write_register_values (const char *command, will change depending upon the particular processor being debugged. */ - regcache = get_current_regcache (); + regcache *regcache = get_thread_regcache (inferior_thread ()); gdbarch = regcache->arch (); numregs = gdbarch_num_cooked_regs (gdbarch); diff --git a/gdb/or1k-tdep.c b/gdb/or1k-tdep.c index a472a766959..74d56d9a8bd 100644 --- a/gdb/or1k-tdep.c +++ b/gdb/or1k-tdep.c @@ -383,7 +383,7 @@ or1k_single_step_through_delay (struct gdbarch *gdbarch, ULONGEST val; CORE_ADDR ppc; CORE_ADDR npc; - struct regcache *regcache = get_current_regcache (); + regcache *regcache = get_thread_regcache (inferior_thread ()); /* Get the previous and current instruction addresses. If they are not adjacent, we cannot be in a delay slot. */ diff --git a/gdb/procfs.c b/gdb/procfs.c index 0e8a08f99d3..3a5d173ee42 100644 --- a/gdb/procfs.c +++ b/gdb/procfs.c @@ -3605,7 +3605,7 @@ procfs_target::make_corefile_notes (bfd *obfd, int *note_size) stop_signal = find_stop_signal (); - fill_gregset (get_current_regcache (), &gregs, -1); + fill_gregset (get_thread_regcache (inferior_thread ()), &gregs, -1); note_data.reset (elfcore_write_pstatus (obfd, note_data.release (), note_size, inferior_ptid.pid (), stop_signal, &gregs)); diff --git a/gdb/record-btrace.c b/gdb/record-btrace.c index abab79f3132..f0e190f9bf7 100644 --- a/gdb/record-btrace.c +++ b/gdb/record-btrace.c @@ -2782,7 +2782,7 @@ record_btrace_set_replay (struct thread_info *tp, /* Start anew from the new replay position. */ record_btrace_clear_histories (btinfo); - inferior_thread ()->set_stop_pc (regcache_read_pc (get_current_regcache ())); + tp->set_stop_pc (regcache_read_pc (get_thread_regcache (tp))); print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1); } diff --git a/gdb/record-full.c b/gdb/record-full.c index 1cea869e88b..0ce6862f819 100644 --- a/gdb/record-full.c +++ b/gdb/record-full.c @@ -913,7 +913,7 @@ record_full_async_inferior_event_handler (gdb_client_data data) static void record_full_core_open_1 (const char *name, int from_tty) { - struct regcache *regcache = get_current_regcache (); + regcache *regcache = get_thread_regcache (inferior_thread ()); int regnum = gdbarch_num_regs (regcache->arch ()); int i; @@ -1069,7 +1069,7 @@ record_full_target::resume (ptid_t ptid, int step, enum gdb_signal signal) { struct gdbarch *gdbarch = target_thread_architecture (ptid); - record_full_message (get_current_regcache (), signal); + record_full_message (get_thread_regcache (inferior_thread ()), signal); if (!step) { @@ -1216,7 +1216,7 @@ record_full_wait_1 (struct target_ops *ops, registers_changed (); switch_to_thread (current_inferior ()->process_target (), ret); - regcache = get_current_regcache (); + regcache = get_thread_regcache (inferior_thread ()); tmp_pc = regcache_read_pc (regcache); const address_space *aspace = current_inferior ()->aspace; @@ -1286,7 +1286,7 @@ record_full_wait_1 (struct target_ops *ops, { switch_to_thread (current_inferior ()->process_target (), record_full_resume_ptid); - struct regcache *regcache = get_current_regcache (); + regcache *regcache = get_thread_regcache (inferior_thread ()); struct gdbarch *gdbarch = regcache->arch (); const address_space *aspace = current_inferior ()->aspace; int continue_flag = 1; @@ -2001,7 +2001,9 @@ record_full_goto_entry (struct record_full_entry *p) registers_changed (); reinit_frame_cache (); - inferior_thread ()->set_stop_pc (regcache_read_pc (get_current_regcache ())); + + thread_info *thr = inferior_thread (); + thr->set_stop_pc (regcache_read_pc (get_thread_regcache (thr))); print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1); } @@ -2322,7 +2324,6 @@ record_full_restore (void) asection *osec; uint32_t osec_size; int bfd_offset = 0; - struct regcache *regcache; /* We restore the execution log from the open core bfd, if there is one. */ @@ -2365,7 +2366,7 @@ record_full_restore (void) try { - regcache = get_current_regcache (); + regcache *regcache = get_thread_regcache (inferior_thread ()); while (1) { @@ -2525,7 +2526,6 @@ record_full_base_target::save_record (const char *recfilename) { struct record_full_entry *cur_record_full_list; uint32_t magic; - struct regcache *regcache; struct gdbarch *gdbarch; int save_size = 0; asection *osec = NULL; @@ -2546,7 +2546,7 @@ record_full_base_target::save_record (const char *recfilename) cur_record_full_list = record_full_list; /* Get the values of regcache and gdbarch. */ - regcache = get_current_regcache (); + regcache *regcache = get_thread_regcache (inferior_thread ()); gdbarch = regcache->arch (); /* Disable the GDB operation record. */ @@ -2731,7 +2731,7 @@ record_full_goto_insn (struct record_full_entry *entry, { scoped_restore restore_operation_disable = record_full_gdb_operation_disable_set (); - struct regcache *regcache = get_current_regcache (); + regcache *regcache = get_thread_regcache (inferior_thread ()); struct gdbarch *gdbarch = regcache->arch (); /* Assume everything is valid: we will hit the entry, diff --git a/gdb/regcache-dump.c b/gdb/regcache-dump.c index 585e02eefed..4b9be859157 100644 --- a/gdb/regcache-dump.c +++ b/gdb/regcache-dump.c @@ -233,7 +233,7 @@ regcache_print (const char *args, enum regcache_dump_what what_to_dump) gdbarch *gdbarch; if (target_has_registers ()) - gdbarch = get_current_regcache ()->arch (); + gdbarch = get_thread_regcache (inferior_thread ())->arch (); else gdbarch = current_inferior ()->arch (); @@ -254,7 +254,8 @@ regcache_print (const char *args, enum regcache_dump_what what_to_dump) auto dump_pseudo = (what_to_dump == regcache_dump_cooked); if (target_has_registers ()) - dump.reset (new register_dump_regcache (get_current_regcache (), + dump.reset (new register_dump_regcache (get_thread_regcache + (inferior_thread ()), dump_pseudo)); else { diff --git a/gdb/regcache.c b/gdb/regcache.c index 48a926ed448..48d7db47c06 100644 --- a/gdb/regcache.c +++ b/gdb/regcache.c @@ -415,12 +415,6 @@ get_thread_regcache (thread_info *thread) thread->ptid); } -struct regcache * -get_current_regcache (void) -{ - return get_thread_regcache (inferior_thread ()); -} - /* See gdbsupport/common-regcache.h. */ struct regcache * diff --git a/gdb/regcache.h b/gdb/regcache.h index f73f08a44ab..7922a5c5ae2 100644 --- a/gdb/regcache.h +++ b/gdb/regcache.h @@ -30,7 +30,6 @@ class thread_info; struct process_stratum_target; struct inferior; -extern struct regcache *get_current_regcache (void); extern struct regcache *get_thread_regcache (process_stratum_target *target, ptid_t ptid); diff --git a/gdb/reverse.c b/gdb/reverse.c index 0a9cc298aeb..30d621f25a0 100644 --- a/gdb/reverse.c +++ b/gdb/reverse.c @@ -113,7 +113,8 @@ save_bookmark_command (const char *args, int from_tty) { /* Get target's idea of a bookmark. */ gdb_byte *bookmark_id = target_get_bookmark (args, from_tty); - struct gdbarch *gdbarch = get_current_regcache ()->arch (); + regcache *regcache = get_thread_regcache (inferior_thread ()); + gdbarch *gdbarch = regcache->arch (); /* CR should not cause another identical bookmark. */ dont_repeat (); @@ -125,7 +126,7 @@ save_bookmark_command (const char *args, int from_tty) all_bookmarks.emplace_back (); bookmark &b = all_bookmarks.back (); b.number = ++bookmark_count; - b.pc = regcache_read_pc (get_current_regcache ()); + b.pc = regcache_read_pc (regcache); b.sal = find_pc_line (b.pc, 0); b.sal.pspace = get_frame_program_space (get_current_frame ()); b.opaque_data.reset (bookmark_id); @@ -237,7 +238,7 @@ goto_bookmark_command (const char *args, int from_tty) static int bookmark_1 (int bnum) { - struct gdbarch *gdbarch = get_current_regcache ()->arch (); + gdbarch *gdbarch = get_thread_regcache (inferior_thread ())->arch (); int matched = 0; for (const bookmark &iter : all_bookmarks) diff --git a/gdb/solib-darwin.c b/gdb/solib-darwin.c index 4f9ba9945ce..c18791cd7c2 100644 --- a/gdb/solib-darwin.c +++ b/gdb/solib-darwin.c @@ -362,7 +362,7 @@ darwin_read_exec_load_addr_at_init (struct darwin_info *info) gdb_byte buf[8]; /* Get SP. */ - if (regcache_cooked_read_unsigned (get_current_regcache (), + if (regcache_cooked_read_unsigned (get_thread_regcache (inferior_thread ()), gdbarch_sp_regnum (gdbarch), &load_ptr_addr) != REG_VALID) return 0; @@ -450,7 +450,7 @@ darwin_solib_get_all_image_info_addr_at_init (struct darwin_info *info) /* We find the dynamic linker's base address by examining the current pc (which should point at the entry point for the dynamic linker) and subtracting the offset of the entry point. */ - load_addr = (regcache_read_pc (get_current_regcache ()) + load_addr = (regcache_read_pc (get_thread_regcache (inferior_thread ())) - bfd_get_start_address (dyld_bfd.get ())); /* Now try to set a breakpoint in the dynamic linker. */ @@ -574,7 +574,7 @@ darwin_solib_create_inferior_hook (int from_tty) for the dynamic linker) and subtracting the offset of the entry point. */ - pc = regcache_read_pc (get_current_regcache ()); + pc = regcache_read_pc (get_thread_regcache (inferior_thread ())); dyld_relocated_base_address = pc - dyld_bfd_start_address; /* We get the proper notifier relocated address by diff --git a/gdb/solib-svr4.c b/gdb/solib-svr4.c index b02e8094ac6..8a5ad590f6f 100644 --- a/gdb/solib-svr4.c +++ b/gdb/solib-svr4.c @@ -1867,7 +1867,7 @@ svr4_handle_solib_event (void) if (info->probes_table == NULL) return; - pc = regcache_read_pc (get_current_regcache ()); + pc = regcache_read_pc (get_thread_regcache (inferior_thread ())); pa = solib_event_probe_at (info, pc); if (pa == nullptr) { diff --git a/gdb/stack.c b/gdb/stack.c index 39dcefa87b8..ef565445c16 100644 --- a/gdb/stack.c +++ b/gdb/stack.c @@ -2798,13 +2798,13 @@ return_command (const char *retval_exp, int from_tty) if (return_value != NULL) { struct type *return_type = return_value->type (); - struct gdbarch *cache_arch = get_current_regcache ()->arch (); + regcache *regcache = get_thread_regcache (inferior_thread ()); + struct gdbarch *cache_arch = regcache->arch (); gdb_assert (rv_conv != RETURN_VALUE_STRUCT_CONVENTION && rv_conv != RETURN_VALUE_ABI_RETURNS_ADDRESS); gdbarch_return_value_as_value - (cache_arch, function, return_type, - get_current_regcache (), NULL /*read*/, + (cache_arch, function, return_type, regcache, NULL /*read*/, return_value->contents ().data () /*write*/); } diff --git a/gdb/symfile.c b/gdb/symfile.c index eebc5ea44b9..7f7ac337806 100644 --- a/gdb/symfile.c +++ b/gdb/symfile.c @@ -2098,7 +2098,7 @@ generic_load (const char *args, int from_tty) uiout->text (", load size "); uiout->field_unsigned ("load-size", total_progress.data_count); uiout->text ("\n"); - regcache_write_pc (get_current_regcache (), entry); + regcache_write_pc (get_thread_regcache (inferior_thread ()), entry); /* Reset breakpoints, now that we have changed the load image. For instance, breakpoints may have been set (or reset, by diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c index 2c548688570..d5f29eb8b10 100644 --- a/gdb/tracepoint.c +++ b/gdb/tracepoint.c @@ -2283,7 +2283,7 @@ tfind_pc_command (const char *args, int from_tty) check_trace_running (current_trace_status ()); if (args == 0 || *args == 0) - pc = regcache_read_pc (get_current_regcache ()); + pc = regcache_read_pc (get_thread_regcache (inferior_thread ())); else pc = parse_and_eval_address (args); @@ -2731,7 +2731,7 @@ get_traceframe_location (int *stepping_frame_p) /* The current frame is a trap frame if the frame PC is equal to the tracepoint PC. If not, then the current frame was collected during single-stepping. */ - regcache = get_current_regcache (); + regcache = get_thread_regcache (inferior_thread ()); /* If the traceframe's address matches any of the tracepoint's locations, assume it is a direct hit rather than a while-stepping diff --git a/gdb/windows-nat.c b/gdb/windows-nat.c index b98efe8afa7..205bf01174f 100644 --- a/gdb/windows-nat.c +++ b/gdb/windows-nat.c @@ -1441,7 +1441,7 @@ windows_nat_target::resume (ptid_t ptid, int step, enum gdb_signal sig) if (step) { /* Single step by setting t bit. */ - struct regcache *regcache = get_current_regcache (); + regcache *regcache = get_thread_regcache (inferior_thread ()); struct gdbarch *gdbarch = regcache->arch (); fetch_registers (regcache, gdbarch_ps_regnum (gdbarch)); th->wow64_context.EFlags |= FLAG_TRACE_BIT; @@ -1469,7 +1469,7 @@ windows_nat_target::resume (ptid_t ptid, int step, enum gdb_signal sig) if (step) { /* Single step by setting t bit. */ - struct regcache *regcache = get_current_regcache (); + regcache *regcache = get_thread_regcache (inferior_thread ()); struct gdbarch *gdbarch = regcache->arch (); fetch_registers (regcache, gdbarch_ps_regnum (gdbarch)); th->context.EFlags |= FLAG_TRACE_BIT; diff --git a/gdb/xtensa-tdep.c b/gdb/xtensa-tdep.c index c9935d15264..9e7bfde193f 100644 --- a/gdb/xtensa-tdep.c +++ b/gdb/xtensa-tdep.c @@ -161,7 +161,8 @@ xtensa_read_register (int regnum) { ULONGEST value; - regcache_raw_read_unsigned (get_current_regcache (), regnum, &value); + regcache_raw_read_unsigned (get_thread_regcache (inferior_thread ()), regnum, + &value); return (unsigned long) value; } @@ -169,7 +170,8 @@ xtensa_read_register (int regnum) static void xtensa_write_register (int regnum, ULONGEST value) { - regcache_raw_write_unsigned (get_current_regcache (), regnum, value); + regcache_raw_write_unsigned (get_thread_regcache (inferior_thread ()), regnum, + value); } /* Return the window size of the previous call to the function from which we