X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Frecord-btrace.c;h=3f8a69dd04f5cd4b9ddc1f713168d1b617afead2;hb=c76d61da4a65eaadca861bf6c77d579a5cc3f422;hp=9b04d060149c41edbf0d5c030d1a05d96da00bce;hpb=1a476b6d68f338e6daa0345501c0cf0fe97dd8f3;p=binutils-gdb.git diff --git a/gdb/record-btrace.c b/gdb/record-btrace.c index 9b04d060149..3f8a69dd04f 100644 --- a/gdb/record-btrace.c +++ b/gdb/record-btrace.c @@ -1,6 +1,6 @@ /* Branch trace support for GDB, the GNU debugger. - Copyright (C) 2013-2020 Free Software Foundation, Inc. + Copyright (C) 2013-2022 Free Software Foundation, Inc. Contributed by Intel Corp. @@ -43,6 +43,7 @@ #include "gdbarch.h" #include "cli/cli-style.h" #include "async-event.h" +#include static const target_info record_btrace_target_info = { "record-btrace", @@ -115,9 +116,8 @@ public: const struct frame_unwind *get_tailcall_unwinder () override; - void commit_resume () override; void resume (ptid_t, int, enum gdb_signal) override; - ptid_t wait (ptid_t, struct target_waitstatus *, int) override; + ptid_t wait (ptid_t, struct target_waitstatus *, target_wait_flags) override; void stop (ptid_t) override; void update_thread_list () override; @@ -211,8 +211,8 @@ static struct cmd_list_element *set_record_btrace_cpu_cmdlist; do \ { \ if (record_debug != 0) \ - fprintf_unfiltered (gdb_stdlog, \ - "[record-btrace] " msg "\n", ##args); \ + gdb_printf (gdb_stdlog, \ + "[record-btrace] " msg "\n", ##args); \ } \ while (0) @@ -279,11 +279,16 @@ require_btrace (void) return &tp->btrace; } -/* Enable branch tracing for one thread. Warn on errors. */ +/* The new thread observer. */ static void -record_btrace_enable_warn (struct thread_info *tp) +record_btrace_on_new_thread (struct thread_info *tp) { + /* Ignore this thread if its inferior is not recorded by us. */ + target_ops *rec = tp->inf->target_at (record_stratum); + if (rec != &record_btrace_ops) + return; + try { btrace_enable (tp, &record_btrace_conf); @@ -301,8 +306,9 @@ record_btrace_auto_enable (void) { DEBUG ("attach thread observer"); - gdb::observers::new_thread.attach (record_btrace_enable_warn, - record_btrace_thread_observer_token); + gdb::observers::new_thread.attach (record_btrace_on_new_thread, + record_btrace_thread_observer_token, + "record-btrace"); } /* Disable automatic tracing of new threads. */ @@ -320,7 +326,7 @@ record_btrace_auto_disable (void) static void record_btrace_handle_async_inferior_event (gdb_client_data data) { - inferior_event_handler (INF_REG_EVENT, NULL); + inferior_event_handler (INF_REG_EVENT); } /* See record-btrace.h. */ @@ -332,11 +338,11 @@ record_btrace_push_target (void) record_btrace_auto_enable (); - push_target (&record_btrace_ops); + current_inferior ()->push_target (&record_btrace_ops); record_btrace_async_inferior_event_handler = create_async_event_handler (record_btrace_handle_async_inferior_event, - NULL); + NULL, "record-btrace"); record_btrace_generating_corefile = 0; format = btrace_format_short_string (record_btrace_conf.format); @@ -384,10 +390,10 @@ record_btrace_target_open (const char *args, int from_tty) record_preopen (); - if (!target_has_execution) + if (!target_has_execution ()) error (_("The program is not being run.")); - for (thread_info *tp : all_non_exited_threads ()) + for (thread_info *tp : current_inferior ()->non_exited_threads ()) if (args == NULL || *args == 0 || number_is_in_list (args, tp->global_num)) { btrace_enable (tp, &record_btrace_conf); @@ -409,7 +415,7 @@ record_btrace_target::stop_recording () record_btrace_auto_disable (); - for (thread_info *tp : all_non_exited_threads ()) + for (thread_info *tp : current_inferior ()->non_exited_threads ()) if (tp->btrace.target != NULL) btrace_disable (tp); } @@ -423,7 +429,7 @@ record_btrace_target::disconnect (const char *args, struct target_ops *beneath = this->beneath (); /* Do not stop recording, just clean up GDB side. */ - unpush_target (this); + current_inferior ()->unpush_target (this); /* Forward disconnect. */ beneath->disconnect (args, from_tty); @@ -443,7 +449,7 @@ record_btrace_target::close () /* We should have already stopped recording. Tear down btrace in case we have not. */ - for (thread_info *tp : all_non_exited_threads ()) + for (thread_info *tp : current_inferior ()->non_exited_threads ()) btrace_teardown (tp); } @@ -500,7 +506,7 @@ record_btrace_print_bts_conf (const struct btrace_config_bts *conf) if (size > 0) { suffix = record_btrace_adjust_size (&size); - printf_unfiltered (_("Buffer size: %u%s.\n"), size, suffix); + gdb_printf (_("Buffer size: %u%s.\n"), size, suffix); } } @@ -516,7 +522,7 @@ record_btrace_print_pt_conf (const struct btrace_config_pt *conf) if (size > 0) { suffix = record_btrace_adjust_size (&size); - printf_unfiltered (_("Buffer size: %u%s.\n"), size, suffix); + gdb_printf (_("Buffer size: %u%s.\n"), size, suffix); } } @@ -525,8 +531,8 @@ record_btrace_print_pt_conf (const struct btrace_config_pt *conf) static void record_btrace_print_conf (const struct btrace_config *conf) { - printf_unfiltered (_("Recording format: %s.\n"), - btrace_format_string (conf->format)); + gdb_printf (_("Recording format: %s.\n"), + btrace_format_string (conf->format)); switch (conf->format) { @@ -596,14 +602,14 @@ record_btrace_target::info_record () gaps = btinfo->ngaps; } - printf_unfiltered (_("Recorded %u instructions in %u functions (%u gaps) " - "for thread %s (%s).\n"), insns, calls, gaps, - print_thread_id (tp), - target_pid_to_str (tp->ptid).c_str ()); + gdb_printf (_("Recorded %u instructions in %u functions (%u gaps) " + "for thread %s (%s).\n"), insns, calls, gaps, + print_thread_id (tp), + target_pid_to_str (tp->ptid).c_str ()); if (btrace_is_replaying (tp)) - printf_unfiltered (_("Replay in progress. At instruction %u.\n"), - btrace_insn_number (btinfo->replay)); + gdb_printf (_("Replay in progress. At instruction %u.\n"), + btrace_insn_number (btinfo->replay)); } /* Print a decode error. */ @@ -707,7 +713,7 @@ btrace_find_line_range (CORE_ADDR pc) if (symtab == NULL) return btrace_mk_line_range (NULL, 0, 0); - ltable = SYMTAB_LINETABLE (symtab); + ltable = symtab->linetable (); if (ltable == NULL) return btrace_mk_line_range (symtab, 0, 0); @@ -792,7 +798,7 @@ btrace_insn_history (struct ui_out *uiout, gdb_pretty_print_disassembler disasm (gdbarch, uiout); for (btrace_insn_iterator it = *begin; btrace_insn_cmp (&it, end) != 0; - btrace_insn_next (&it, 1)) + btrace_insn_next (&it, 1)) { const struct btrace_insn *insn; @@ -932,9 +938,9 @@ record_btrace_target::insn_history (int size, gdb_disassembly_flags flags) else { if (size < 0) - printf_unfiltered (_("At the start of the branch trace record.\n")); + gdb_printf (_("At the start of the branch trace record.\n")); else - printf_unfiltered (_("At the end of the branch trace record.\n")); + gdb_printf (_("At the end of the branch trace record.\n")); } btrace_set_insn_history (btinfo, &begin, &end); @@ -1061,7 +1067,7 @@ btrace_compute_src_line_range (const struct btrace_function *bfun, if (sym == NULL) goto out; - symtab = symbol_symtab (sym); + symtab = sym->symtab (); for (const btrace_insn &insn : bfun->insn) { @@ -1094,7 +1100,7 @@ btrace_call_history_src_line (struct ui_out *uiout, return; uiout->field_string ("file", - symtab_to_filename_for_display (symbol_symtab (sym)), + symtab_to_filename_for_display (sym->symtab ()), file_name_style.style ()); btrace_compute_src_line_range (bfun, &begin, &end); @@ -1289,9 +1295,9 @@ record_btrace_target::call_history (int size, record_print_flags flags) else { if (size < 0) - printf_unfiltered (_("At the start of the branch trace record.\n")); + gdb_printf (_("At the start of the branch trace record.\n")); else - printf_unfiltered (_("At the end of the branch trace record.\n")); + gdb_printf (_("At the end of the branch trace record.\n")); } btrace_set_call_history (btinfo, &begin, &end); @@ -1434,7 +1440,7 @@ record_btrace_target::xfer_partial (enum target_object object, { case TARGET_OBJECT_MEMORY: { - struct target_section *section; + const struct target_section *section; /* We do not allow writing memory in general. */ if (writebuf != NULL) @@ -1883,6 +1889,7 @@ record_btrace_frame_dealloc_cache (struct frame_info *self, void *this_cache) const struct frame_unwind record_btrace_frame_unwind = { + "record-btrace", NORMAL_FRAME, record_btrace_frame_unwind_stop_reason, record_btrace_frame_this_id, @@ -1894,6 +1901,7 @@ const struct frame_unwind record_btrace_frame_unwind = const struct frame_unwind record_btrace_tailcall_frame_unwind = { + "record-btrace tailcall", TAILCALL_FRAME, record_btrace_frame_unwind_stop_reason, record_btrace_frame_this_id, @@ -1922,7 +1930,7 @@ record_btrace_target::get_tailcall_unwinder () /* Return a human-readable string for FLAG. */ static const char * -btrace_thread_flag_to_str (enum btrace_thread_flag flag) +btrace_thread_flag_to_str (btrace_thread_flags flag) { switch (flag) { @@ -1954,7 +1962,7 @@ record_btrace_resume_thread (struct thread_info *tp, struct btrace_thread_info *btinfo; DEBUG ("resuming thread %s (%s): %x (%s)", print_thread_id (tp), - target_pid_to_str (tp->ptid).c_str (), flag, + tp->ptid.to_string ().c_str (), flag, btrace_thread_flag_to_str (flag)); btinfo = &tp->btrace; @@ -1972,9 +1980,6 @@ record_btrace_resume_thread (struct thread_info *tp, static struct frame_id get_thread_current_frame_id (struct thread_info *tp) { - struct frame_id id; - bool executing; - /* Set current thread, which is implicitly used by get_current_frame. */ scoped_restore_current_thread restore_thread; @@ -1990,26 +1995,13 @@ get_thread_current_frame_id (struct thread_info *tp) For the former, EXECUTING is true and we're in wait, about to move the thread. Since we need to recompute the stack, we temporarily set EXECUTING to false. */ - executing = tp->executing; + bool executing = tp->executing (); set_executing (proc_target, inferior_ptid, false); - - id = null_frame_id; - try + SCOPE_EXIT { - id = get_frame_id (get_current_frame ()); - } - catch (const gdb_exception &except) - { - /* Restore the previous execution state. */ set_executing (proc_target, inferior_ptid, executing); - - throw; - } - - /* Restore the previous execution state. */ - set_executing (proc_target, inferior_ptid, executing); - - return id; + }; + return get_frame_id (get_current_frame ()); } /* Start replaying a thread. */ @@ -2025,7 +2017,7 @@ record_btrace_start_replaying (struct thread_info *tp) /* We can't start replaying without trace. */ if (btinfo->functions.empty ()) - return NULL; + error (_("No trace.")); /* GDB stores the current frame_id when stepping in order to detects steps into subroutines. @@ -2133,7 +2125,7 @@ record_btrace_target::resume (ptid_t ptid, int step, enum gdb_signal signal) { enum btrace_thread_flag flag, cflag; - DEBUG ("resume %s: %s%s", target_pid_to_str (ptid).c_str (), + DEBUG ("resume %s: %s%s", ptid.to_string ().c_str (), ::execution_direction == EXEC_REVERSE ? "reverse-" : "", step ? "step" : "cont"); @@ -2200,22 +2192,12 @@ record_btrace_target::resume (ptid_t ptid, int step, enum gdb_signal signal) } } -/* The commit_resume method of target record-btrace. */ - -void -record_btrace_target::commit_resume () -{ - if ((::execution_direction != EXEC_REVERSE) - && !record_is_replaying (minus_one_ptid)) - beneath ()->commit_resume (); -} - /* Cancel resuming TP. */ static void record_btrace_cancel_resume (struct thread_info *tp) { - enum btrace_thread_flag flags; + btrace_thread_flags flags; flags = tp->btrace.flags & (BTHR_MOVE | BTHR_STOP); if (flags == 0) @@ -2223,7 +2205,7 @@ record_btrace_cancel_resume (struct thread_info *tp) DEBUG ("cancel resume thread %s (%s): %x (%s)", print_thread_id (tp), - target_pid_to_str (tp->ptid).c_str (), flags, + tp->ptid.to_string ().c_str (), flags.raw (), btrace_thread_flag_to_str (flags)); tp->btrace.flags &= ~(BTHR_MOVE | BTHR_STOP); @@ -2237,7 +2219,7 @@ btrace_step_no_history (void) { struct target_waitstatus status; - status.kind = TARGET_WAITKIND_NO_HISTORY; + status.set_no_history (); return status; } @@ -2249,8 +2231,7 @@ btrace_step_stopped (void) { struct target_waitstatus status; - status.kind = TARGET_WAITKIND_STOPPED; - status.value.sig = GDB_SIGNAL_TRAP; + status.set_stopped (GDB_SIGNAL_TRAP); return status; } @@ -2263,8 +2244,7 @@ btrace_step_stopped_on_request (void) { struct target_waitstatus status; - status.kind = TARGET_WAITKIND_STOPPED; - status.value.sig = GDB_SIGNAL_0; + status.set_stopped (GDB_SIGNAL_0); return status; } @@ -2276,7 +2256,7 @@ btrace_step_spurious (void) { struct target_waitstatus status; - status.kind = TARGET_WAITKIND_SPURIOUS; + status.set_spurious (); return status; } @@ -2288,7 +2268,7 @@ btrace_step_no_resumed (void) { struct target_waitstatus status; - status.kind = TARGET_WAITKIND_NO_RESUMED; + status.set_no_resumed (); return status; } @@ -2300,7 +2280,7 @@ btrace_step_again (void) { struct target_waitstatus status; - status.kind = TARGET_WAITKIND_IGNORE; + status.set_ignore (); return status; } @@ -2443,7 +2423,7 @@ record_btrace_step_thread (struct thread_info *tp) { struct btrace_thread_info *btinfo; struct target_waitstatus status; - enum btrace_thread_flag flags; + btrace_thread_flags flags; btinfo = &tp->btrace; @@ -2451,7 +2431,7 @@ record_btrace_step_thread (struct thread_info *tp) btinfo->flags &= ~(BTHR_MOVE | BTHR_STOP); DEBUG ("stepping thread %s (%s): %x (%s)", print_thread_id (tp), - target_pid_to_str (tp->ptid).c_str (), flags, + tp->ptid.to_string ().c_str (), flags.raw (), btrace_thread_flag_to_str (flags)); /* We can't step without an execution history. */ @@ -2468,21 +2448,21 @@ record_btrace_step_thread (struct thread_info *tp) case BTHR_STEP: status = record_btrace_single_step_forward (tp); - if (status.kind != TARGET_WAITKIND_SPURIOUS) + if (status.kind () != TARGET_WAITKIND_SPURIOUS) break; return btrace_step_stopped (); case BTHR_RSTEP: status = record_btrace_single_step_backward (tp); - if (status.kind != TARGET_WAITKIND_SPURIOUS) + if (status.kind () != TARGET_WAITKIND_SPURIOUS) break; return btrace_step_stopped (); case BTHR_CONT: status = record_btrace_single_step_forward (tp); - if (status.kind != TARGET_WAITKIND_SPURIOUS) + if (status.kind () != TARGET_WAITKIND_SPURIOUS) break; btinfo->flags |= flags; @@ -2490,7 +2470,7 @@ record_btrace_step_thread (struct thread_info *tp) case BTHR_RCONT: status = record_btrace_single_step_backward (tp); - if (status.kind != TARGET_WAITKIND_SPURIOUS) + if (status.kind () != TARGET_WAITKIND_SPURIOUS) break; btinfo->flags |= flags; @@ -2499,7 +2479,7 @@ record_btrace_step_thread (struct thread_info *tp) /* We keep threads moving at the end of their execution history. The wait method will stop the thread for whom the event is reported. */ - if (status.kind == TARGET_WAITKIND_NO_HISTORY) + if (status.kind () == TARGET_WAITKIND_NO_HISTORY) btinfo->flags |= flags; return status; @@ -2531,12 +2511,16 @@ record_btrace_maybe_mark_async_event ptid_t record_btrace_target::wait (ptid_t ptid, struct target_waitstatus *status, - int options) + target_wait_flags options) { std::vector moving; std::vector no_history; - DEBUG ("wait %s (0x%x)", target_pid_to_str (ptid).c_str (), options); + /* Clear this, if needed we'll re-mark it below. */ + clear_async_event_handler (record_btrace_async_inferior_event_handler); + + DEBUG ("wait %s (0x%x)", ptid.to_string ().c_str (), + (unsigned) options); /* As long as we're not replaying, just forward the request. */ if ((::execution_direction != EXEC_REVERSE) @@ -2555,8 +2539,8 @@ record_btrace_target::wait (ptid_t ptid, struct target_waitstatus *status, { *status = btrace_step_no_resumed (); - DEBUG ("wait ended by %s: %s", target_pid_to_str (null_ptid).c_str (), - target_waitstatus_to_string (status).c_str ()); + DEBUG ("wait ended by %s: %s", null_ptid.to_string ().c_str (), + status->to_string ().c_str ()); return null_ptid; } @@ -2587,7 +2571,7 @@ record_btrace_target::wait (ptid_t ptid, struct target_waitstatus *status, *status = record_btrace_step_thread (tp); - switch (status->kind) + switch (status->kind ()) { case TARGET_WAITKIND_IGNORE: ix++; @@ -2630,7 +2614,7 @@ record_btrace_target::wait (ptid_t ptid, struct target_waitstatus *status, /* Stop all other threads. */ if (!target_is_non_stop_p ()) { - for (thread_info *tp : all_non_exited_threads ()) + for (thread_info *tp : current_inferior ()->non_exited_threads ()) record_btrace_cancel_resume (tp); } @@ -2646,8 +2630,8 @@ record_btrace_target::wait (ptid_t ptid, struct target_waitstatus *status, DEBUG ("wait ended by thread %s (%s): %s", print_thread_id (eventing), - target_pid_to_str (eventing->ptid).c_str (), - target_waitstatus_to_string (status).c_str ()); + eventing->ptid.to_string ().c_str (), + status->to_string ().c_str ()); return eventing->ptid; } @@ -2657,7 +2641,7 @@ record_btrace_target::wait (ptid_t ptid, struct target_waitstatus *status, void record_btrace_target::stop (ptid_t ptid) { - DEBUG ("stop %s", target_pid_to_str (ptid).c_str ()); + DEBUG ("stop %s", ptid.to_string ().c_str ()); /* As long as we're not replaying, just forward the request. */ if ((::execution_direction != EXEC_REVERSE) @@ -2793,8 +2777,7 @@ record_btrace_set_replay (struct thread_info *tp, /* Start anew from the new replay position. */ record_btrace_clear_histories (btinfo); - inferior_thread ()->suspend.stop_pc - = regcache_read_pc (get_current_regcache ()); + inferior_thread ()->set_stop_pc (regcache_read_pc (get_current_regcache ())); print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1); } @@ -2867,7 +2850,7 @@ record_btrace_target::goto_record (ULONGEST insn) void record_btrace_target::record_stop_replaying () { - for (thread_info *tp : all_non_exited_threads ()) + for (thread_info *tp : current_inferior ()->non_exited_threads ()) record_btrace_stop_replaying (tp); } @@ -2973,8 +2956,8 @@ static void cmd_show_replay_memory_access (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { - fprintf_filtered (gdb_stdout, _("Replay memory access is %s.\n"), - replay_memory_access); + gdb_printf (file, _("Replay memory access is %s.\n"), + replay_memory_access); } /* The "set record btrace cpu none" command. */ @@ -3054,11 +3037,11 @@ cmd_show_record_btrace_cpu (const char *args, int from_tty) switch (record_btrace_cpu_state) { case CS_AUTO: - printf_unfiltered (_("btrace cpu is 'auto'.\n")); + gdb_printf (_("btrace cpu is 'auto'.\n")); return; case CS_NONE: - printf_unfiltered (_("btrace cpu is 'none'.\n")); + gdb_printf (_("btrace cpu is 'none'.\n")); return; case CS_CPU: @@ -3066,14 +3049,14 @@ cmd_show_record_btrace_cpu (const char *args, int from_tty) { case CV_INTEL: if (record_btrace_cpu.stepping == 0) - printf_unfiltered (_("btrace cpu is 'intel: %u/%u'.\n"), - record_btrace_cpu.family, - record_btrace_cpu.model); + gdb_printf (_("btrace cpu is 'intel: %u/%u'.\n"), + record_btrace_cpu.family, + record_btrace_cpu.model); else - printf_unfiltered (_("btrace cpu is 'intel: %u/%u/%u'.\n"), - record_btrace_cpu.family, - record_btrace_cpu.model, - record_btrace_cpu.stepping); + gdb_printf (_("btrace cpu is 'intel: %u/%u/%u'.\n"), + record_btrace_cpu.family, + record_btrace_cpu.model, + record_btrace_cpu.stepping); return; } } @@ -3088,8 +3071,8 @@ show_record_bts_buffer_size_value (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { - fprintf_filtered (file, _("The record/replay bts buffer size is %s.\n"), - value); + gdb_printf (file, _("The record/replay bts buffer size is %s.\n"), + value); } /* The "record pt buffer-size" show value function. */ @@ -3099,8 +3082,8 @@ show_record_pt_buffer_size_value (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { - fprintf_filtered (file, _("The record/replay pt buffer size is %s.\n"), - value); + gdb_printf (file, _("The record/replay pt buffer size is %s.\n"), + value); } /* Initialize btrace commands. */ @@ -3109,33 +3092,36 @@ void _initialize_record_btrace (); void _initialize_record_btrace () { - add_prefix_cmd ("btrace", class_obscure, cmd_record_btrace_start, - _("Start branch trace recording."), &record_btrace_cmdlist, - "record btrace ", 0, &record_cmdlist); - add_alias_cmd ("b", "btrace", class_obscure, 1, &record_cmdlist); + cmd_list_element *record_btrace_cmd + = add_prefix_cmd ("btrace", class_obscure, cmd_record_btrace_start, + _("Start branch trace recording."), + &record_btrace_cmdlist, 0, &record_cmdlist); + add_alias_cmd ("b", record_btrace_cmd, class_obscure, 1, &record_cmdlist); - add_cmd ("bts", class_obscure, cmd_record_btrace_bts_start, - _("\ + cmd_list_element *record_btrace_bts_cmd + = add_cmd ("bts", class_obscure, cmd_record_btrace_bts_start, + _("\ Start branch trace recording in Branch Trace Store (BTS) format.\n\n\ The processor stores a from/to record for each branch into a cyclic buffer.\n\ This format may not be available on all processors."), - &record_btrace_cmdlist); - add_alias_cmd ("bts", "btrace bts", class_obscure, 1, &record_cmdlist); + &record_btrace_cmdlist); + add_alias_cmd ("bts", record_btrace_bts_cmd, class_obscure, 1, + &record_cmdlist); - add_cmd ("pt", class_obscure, cmd_record_btrace_pt_start, - _("\ + cmd_list_element *record_btrace_pt_cmd + = add_cmd ("pt", class_obscure, cmd_record_btrace_pt_start, + _("\ Start branch trace recording in Intel Processor Trace format.\n\n\ This format may not be available on all processors."), - &record_btrace_cmdlist); - add_alias_cmd ("pt", "btrace pt", class_obscure, 1, &record_cmdlist); - - add_basic_prefix_cmd ("btrace", class_support, - _("Set record options."), &set_record_btrace_cmdlist, - "set record btrace ", 0, &set_record_cmdlist); + &record_btrace_cmdlist); + add_alias_cmd ("pt", record_btrace_pt_cmd, class_obscure, 1, &record_cmdlist); - add_show_prefix_cmd ("btrace", class_support, - _("Show record options."), &show_record_btrace_cmdlist, - "show record btrace ", 0, &show_record_cmdlist); + add_setshow_prefix_cmd ("btrace", class_support, + _("Set record options."), + _("Show record options."), + &set_record_btrace_cmdlist, + &show_record_btrace_cmdlist, + &set_record_cmdlist, &show_record_cmdlist); add_setshow_enum_cmd ("replay-memory-access", no_class, replay_memory_access_types, &replay_memory_access, _("\ @@ -3163,7 +3149,7 @@ When GDB does not support that cpu, this option can be used to enable\n\ workarounds for a similar cpu that GDB supports.\n\n\ When set to \"none\", errata workarounds are disabled."), &set_record_btrace_cpu_cmdlist, - "set record btrace cpu ", 1, + 1, &set_record_btrace_cmdlist); add_cmd ("auto", class_support, cmd_set_record_btrace_cpu_auto, _("\ @@ -3178,17 +3164,13 @@ Do not enable errata workarounds for trace decode."), Show the cpu to be used for trace decode."), &show_record_btrace_cmdlist); - add_basic_prefix_cmd ("bts", class_support, - _("Set record btrace bts options."), - &set_record_btrace_bts_cmdlist, - "set record btrace bts ", 0, - &set_record_btrace_cmdlist); - - add_show_prefix_cmd ("bts", class_support, - _("Show record btrace bts options."), - &show_record_btrace_bts_cmdlist, - "show record btrace bts ", 0, - &show_record_btrace_cmdlist); + add_setshow_prefix_cmd ("bts", class_support, + _("Set record btrace bts options."), + _("Show record btrace bts options."), + &set_record_btrace_bts_cmdlist, + &show_record_btrace_bts_cmdlist, + &set_record_btrace_cmdlist, + &show_record_btrace_cmdlist); add_setshow_uinteger_cmd ("buffer-size", no_class, &record_btrace_conf.bts.size, @@ -3204,17 +3186,13 @@ The trace buffer size may not be changed while recording."), NULL, &set_record_btrace_bts_cmdlist, &show_record_btrace_bts_cmdlist); - add_basic_prefix_cmd ("pt", class_support, - _("Set record btrace pt options."), - &set_record_btrace_pt_cmdlist, - "set record btrace pt ", 0, - &set_record_btrace_cmdlist); - - add_show_prefix_cmd ("pt", class_support, - _("Show record btrace pt options."), - &show_record_btrace_pt_cmdlist, - "show record btrace pt ", 0, - &show_record_btrace_cmdlist); + add_setshow_prefix_cmd ("pt", class_support, + _("Set record btrace pt options."), + _("Show record btrace pt options."), + &set_record_btrace_pt_cmdlist, + &show_record_btrace_pt_cmdlist, + &set_record_btrace_cmdlist, + &show_record_btrace_cmdlist); add_setshow_uinteger_cmd ("buffer-size", no_class, &record_btrace_conf.pt.size,