X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Ftracepoint.c;h=a934e56d3b97d59997bb7c15be3b0e0713c8bd6f;hb=8380882108b7c11864212eab15eeb5d4c9a3b138;hp=55ab13f9525c08bfaa6980117714c70458a4df9a;hpb=4277c4b87addb5354cc47b98d7a73e44cfaf22c2;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c index 55ab13f952..a934e56d3b 100644 --- a/gdb/tracepoint.c +++ b/gdb/tracepoint.c @@ -1,6 +1,6 @@ /* Tracing functionality for remote targets in custom GDB protocol - Copyright (C) 1997-2018 Free Software Foundation, Inc. + Copyright (C) 1997-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -51,19 +51,12 @@ #include "memrange.h" #include "cli/cli-utils.h" #include "probe.h" -#include "ctf.h" -#include "filestuff.h" -#include "rsp-low.h" +#include "gdbsupport/filestuff.h" +#include "gdbsupport/rsp-low.h" #include "tracefile.h" #include "location.h" #include - -/* readline include files */ -#include "readline/readline.h" -#include "readline/history.h" - -/* readline defines this. */ -#undef savestring +#include "cli/cli-style.h" #include @@ -138,12 +131,12 @@ static struct cmd_list_element *tfindlist; /* List of expressions to collect by default at each tracepoint hit. */ char *default_collect; -static int disconnected_tracing; +static bool disconnected_tracing; /* This variable controls whether we ask the target for a linear or circular trace buffer. */ -static int circular_trace_buffer; +static bool circular_trace_buffer; /* This variable is the requested trace buffer size, or -1 to indicate that we don't care and leave it up to the target to set a size. */ @@ -243,11 +236,11 @@ set_traceframe_context (struct frame_info *trace_frame) /* Save func name as "$trace_func", a debugger variable visible to users. */ if (traceframe_fun == NULL - || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL) + || traceframe_fun->linkage_name () == NULL) clear_internalvar (lookup_internalvar ("trace_func")); else set_internalvar_string (lookup_internalvar ("trace_func"), - SYMBOL_LINKAGE_NAME (traceframe_fun)); + traceframe_fun->linkage_name ()); /* Save file name as "$trace_file", a debugger variable visible to users. */ @@ -442,6 +435,7 @@ tvariables_info_1 (void) uiout->field_string ("name", std::string ("$") + tsv.name); uiout->field_string ("initial", plongest (tsv.initial_value)); + ui_file_style style; if (tsv.value_known) c = plongest (tsv.value); else if (uiout->is_mi_like_p ()) @@ -450,13 +444,19 @@ tvariables_info_1 (void) undefined does not seem important enough to represent. */ c = NULL; else if (current_trace_status ()->running || traceframe_number >= 0) - /* The value is/was defined, but we don't have it. */ - c = ""; + { + /* The value is/was defined, but we don't have it. */ + c = ""; + style = metadata_style.style (); + } else - /* It is not meaningful to ask about the value. */ - c = ""; + { + /* It is not meaningful to ask about the value. */ + c = ""; + style = metadata_style.style (); + } if (c) - uiout->field_string ("current", c); + uiout->field_string ("current", c, style); uiout->text ("\n"); } } @@ -693,7 +693,7 @@ validate_actionline (const char *line, struct breakpoint *b) { error (_("constant `%s' (value %s) " "will not be collected."), - SYMBOL_PRINT_NAME (exp->elts[2].symbol), + exp->elts[2].symbol->print_name (), plongest (SYMBOL_VALUE (exp->elts[2].symbol))); } else if (SYMBOL_CLASS (exp->elts[2].symbol) @@ -701,7 +701,7 @@ validate_actionline (const char *line, struct breakpoint *b) { error (_("`%s' is optimized away " "and cannot be collected."), - SYMBOL_PRINT_NAME (exp->elts[2].symbol)); + exp->elts[2].symbol->print_name ()); } } @@ -822,10 +822,8 @@ collection_list::add_remote_register (unsigned int regno) { if (info_verbose) printf_filtered ("collect register %d\n", regno); - if (regno >= (8 * sizeof (m_regs_mask))) - error (_("Internal: register number %d too large for tracepoint"), - regno); - m_regs_mask[regno / 8] |= 1 << (regno % 8); + + m_regs_mask.at (regno / 8) |= 1 << (regno % 8); } /* Add all the registers from the mask in AEXPR to the mask in the @@ -928,19 +926,18 @@ collection_list::collect_symbol (struct symbol *sym, { default: printf_filtered ("%s: don't know symbol class %d\n", - SYMBOL_PRINT_NAME (sym), - SYMBOL_CLASS (sym)); + sym->print_name (), SYMBOL_CLASS (sym)); break; case LOC_CONST: printf_filtered ("constant %s (value %s) will not be collected.\n", - SYMBOL_PRINT_NAME (sym), plongest (SYMBOL_VALUE (sym))); + sym->print_name (), plongest (SYMBOL_VALUE (sym))); break; case LOC_STATIC: offset = SYMBOL_VALUE_ADDRESS (sym); if (info_verbose) { printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n", - SYMBOL_PRINT_NAME (sym), len, + sym->print_name (), len, paddress (gdbarch, offset)); } /* A struct may be a C++ class with static fields, go to general @@ -953,8 +950,7 @@ collection_list::collect_symbol (struct symbol *sym, case LOC_REGISTER: reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch); if (info_verbose) - printf_filtered ("LOC_REG[parm] %s: ", - SYMBOL_PRINT_NAME (sym)); + printf_filtered ("LOC_REG[parm] %s: ", sym->print_name ()); add_local_register (gdbarch, reg, scope); /* Check for doubles stored in two registers. */ /* FIXME: how about larger types stored in 3 or more regs? */ @@ -964,8 +960,7 @@ collection_list::collect_symbol (struct symbol *sym, break; case LOC_REF_ARG: printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n"); - printf_filtered (" (will not collect %s)\n", - SYMBOL_PRINT_NAME (sym)); + printf_filtered (" (will not collect %s)\n", sym->print_name ()); break; case LOC_ARG: reg = frame_regno; @@ -973,8 +968,7 @@ collection_list::collect_symbol (struct symbol *sym, if (info_verbose) { printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s" - " from frame ptr reg %d\n", - SYMBOL_PRINT_NAME (sym), len, + " from frame ptr reg %d\n", sym->print_name (), len, paddress (gdbarch, offset), reg); } add_memrange (gdbarch, reg, offset, len, scope); @@ -985,8 +979,7 @@ collection_list::collect_symbol (struct symbol *sym, if (info_verbose) { printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset %s" - " from reg %d\n", - SYMBOL_PRINT_NAME (sym), len, + " from reg %d\n", sym->print_name (), len, paddress (gdbarch, offset), reg); } add_memrange (gdbarch, reg, offset, len, scope); @@ -997,8 +990,7 @@ collection_list::collect_symbol (struct symbol *sym, if (info_verbose) { printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s" - " from frame ptr reg %d\n", - SYMBOL_PRINT_NAME (sym), len, + " from frame ptr reg %d\n", sym->print_name (), len, paddress (gdbarch, offset), reg); } add_memrange (gdbarch, reg, offset, len, scope); @@ -1010,7 +1002,7 @@ collection_list::collect_symbol (struct symbol *sym, case LOC_OPTIMIZED_OUT: printf_filtered ("%s has been optimized out of existence.\n", - SYMBOL_PRINT_NAME (sym)); + sym->print_name ()); break; case LOC_COMPUTED: @@ -1030,7 +1022,7 @@ collection_list::collect_symbol (struct symbol *sym, if (!aexpr) { printf_filtered ("%s has been optimized out of existence.\n", - SYMBOL_PRINT_NAME (sym)); + sym->print_name ()); return; } @@ -1136,9 +1128,20 @@ collection_list::add_static_trace_data () } collection_list::collection_list () - : m_regs_mask (), - m_strace_data (false) + : m_strace_data (false) { + int max_remote_regno = 0; + for (int i = 0; i < gdbarch_num_regs (target_gdbarch ()); i++) + { + int remote_regno = (gdbarch_remote_register_number + (target_gdbarch (), i)); + + if (remote_regno >= 0 && remote_regno > max_remote_regno) + max_remote_regno = remote_regno; + } + + m_regs_mask.resize ((max_remote_regno / 8) + 1); + m_memranges.reserve (128); m_aexprs.reserve (128); } @@ -1148,7 +1151,8 @@ collection_list::collection_list () std::vector collection_list::stringify () { - char temp_buf[2048]; + gdb::char_vector temp_buf (2048); + int count; char *end; long i; @@ -1158,35 +1162,45 @@ collection_list::stringify () { if (info_verbose) printf_filtered ("\nCollecting static trace data\n"); - end = temp_buf; + end = temp_buf.data (); *end++ = 'L'; - str_list.emplace_back (temp_buf, end - temp_buf); + str_list.emplace_back (temp_buf.data (), end - temp_buf.data ()); } - for (i = sizeof (m_regs_mask) - 1; i > 0; i--) + for (i = m_regs_mask.size () - 1; i > 0; i--) if (m_regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */ break; if (m_regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */ { if (info_verbose) printf_filtered ("\nCollecting registers (mask): 0x"); - end = temp_buf; + + /* One char for 'R', one for the null terminator and two per + mask byte. */ + std::size_t new_size = (i + 1) * 2 + 2; + if (new_size > temp_buf.size ()) + temp_buf.resize (new_size); + + end = temp_buf.data (); *end++ = 'R'; for (; i >= 0; i--) { QUIT; /* Allow user to bail out with ^C. */ if (info_verbose) printf_filtered ("%02X", m_regs_mask[i]); - sprintf (end, "%02X", m_regs_mask[i]); - end += 2; + + end = pack_hex_byte (end, m_regs_mask[i]); } - str_list.emplace_back (temp_buf); + *end = '\0'; + + str_list.emplace_back (temp_buf.data ()); } if (info_verbose) printf_filtered ("\n"); if (!m_memranges.empty () && info_verbose) printf_filtered ("Collecting memranges: \n"); - for (i = 0, count = 0, end = temp_buf; i < m_memranges.size (); i++) + for (i = 0, count = 0, end = temp_buf.data (); + i < m_memranges.size (); i++) { QUIT; /* Allow user to bail out with ^C. */ if (info_verbose) @@ -1200,9 +1214,9 @@ collection_list::stringify () } if (count + 27 > MAX_AGENT_EXPR_LEN) { - str_list.emplace_back (temp_buf, count); + str_list.emplace_back (temp_buf.data (), count); count = 0; - end = temp_buf; + end = temp_buf.data (); } { @@ -1222,7 +1236,7 @@ collection_list::stringify () } count += strlen (end); - end = temp_buf + count; + end = temp_buf.data () + count; } for (i = 0; i < m_aexprs.size (); i++) @@ -1230,9 +1244,9 @@ collection_list::stringify () QUIT; /* Allow user to bail out with ^C. */ if ((count + 10 + 2 * m_aexprs[i]->len) > MAX_AGENT_EXPR_LEN) { - str_list.emplace_back (temp_buf, count); + str_list.emplace_back (temp_buf.data (), count); count = 0; - end = temp_buf; + end = temp_buf.data (); } sprintf (end, "X%08X,", m_aexprs[i]->len); end += 10; /* 'X' + 8 hex digits + ',' */ @@ -1244,9 +1258,9 @@ collection_list::stringify () if (count != 0) { - str_list.emplace_back (temp_buf, count); + str_list.emplace_back (temp_buf.data (), count); count = 0; - end = temp_buf; + end = temp_buf.data (); } return str_list; @@ -1404,7 +1418,7 @@ encode_actions_1 (struct command_line *action, case OP_VAR_VALUE: { struct symbol *sym = exp->elts[2].symbol; - const char *name = SYMBOL_NATURAL_NAME (sym); + const char *name = sym->natural_name (); collect->collect_symbol (exp->elts[2].symbol, target_gdbarch (), @@ -1980,8 +1994,8 @@ trace_status_mi (int on_stop) { uiout->field_string ("stop-reason", stop_reason); if (stopping_tracepoint != -1) - uiout->field_int ("stopping-tracepoint", - stopping_tracepoint); + uiout->field_signed ("stopping-tracepoint", + stopping_tracepoint); if (ts->stop_reason == tracepoint_error) uiout->field_string ("error-description", ts->stop_desc); @@ -1990,16 +2004,16 @@ trace_status_mi (int on_stop) } if (ts->traceframe_count != -1) - uiout->field_int ("frames", ts->traceframe_count); + uiout->field_signed ("frames", ts->traceframe_count); if (ts->traceframes_created != -1) - uiout->field_int ("frames-created", ts->traceframes_created); + uiout->field_signed ("frames-created", ts->traceframes_created); if (ts->buffer_size != -1) - uiout->field_int ("buffer-size", ts->buffer_size); + uiout->field_signed ("buffer-size", ts->buffer_size); if (ts->buffer_free != -1) - uiout->field_int ("buffer-free", ts->buffer_free); + uiout->field_signed ("buffer-free", ts->buffer_free); - uiout->field_int ("disconnected", ts->disconnected_tracing); - uiout->field_int ("circular", ts->circular_buffer); + uiout->field_signed ("disconnected", ts->disconnected_tracing); + uiout->field_signed ("circular", ts->circular_buffer); uiout->field_string ("user-name", ts->user_name); uiout->field_string ("notes", ts->notes); @@ -2116,7 +2130,7 @@ tfind_1 (enum trace_find_type type, int num, DON'T give an error, but DO change the state of traceframe_number etc. to invalid. - The rationalle is that if you typed the command, you + The rationale is that if you typed the command, you might just have committed a typo or something, and you'd like to NOT lose your current debugging state. However if you're in a user-defined command or especially in a @@ -2163,8 +2177,8 @@ tfind_1 (enum trace_find_type type, int num, if (uiout->is_mi_like_p ()) { uiout->field_string ("found", "1"); - uiout->field_int ("tracepoint", tracepoint_number); - uiout->field_int ("traceframe", traceframe_number); + uiout->field_signed ("tracepoint", tracepoint_number); + uiout->field_signed ("traceframe", traceframe_number); } else { @@ -2407,7 +2421,7 @@ tfind_range_command (const char *args, int from_tty) if (args == 0 || *args == 0) { /* XXX FIXME: what should default behavior be? */ - printf_filtered ("Usage: tfind range ,\n"); + printf_filtered ("Usage: tfind range STARTADDR, ENDADDR\n"); return; } @@ -2441,7 +2455,7 @@ tfind_outside_command (const char *args, int from_tty) if (args == 0 || *args == 0) { /* XXX FIXME: what should default behavior be? */ - printf_filtered ("Usage: tfind outside ,\n"); + printf_filtered ("Usage: tfind outside STARTADDR, ENDADDR\n"); return; } @@ -2506,7 +2520,7 @@ info_scope_command (const char *args_in, int from_tty) printf_filtered ("Scope for %s:\n", save_args); count++; - symname = SYMBOL_PRINT_NAME (sym); + symname = sym->print_name (); if (symname == NULL || *symname == '\0') continue; /* Probably botched, certainly useless. */ @@ -2516,7 +2530,7 @@ info_scope_command (const char *args_in, int from_tty) if (SYMBOL_COMPUTED_OPS (sym) != NULL) SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, - BLOCK_START (block), + BLOCK_ENTRY_PC (block), gdb_stdout); else { @@ -2593,10 +2607,10 @@ info_scope_command (const char *args_in, int from_tty) case LOC_BLOCK: printf_filtered ("a function at address "); printf_filtered ("%s", - paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym)))); + paddress (gdbarch, BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym)))); break; case LOC_UNRESOLVED: - msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym), + msym = lookup_minimal_symbol (sym->linkage_name (), NULL, NULL); if (msym.minsym == NULL) printf_filtered ("Unresolved Static"); @@ -2616,8 +2630,11 @@ info_scope_command (const char *args_in, int from_tty) } } if (SYMBOL_TYPE (sym)) - printf_filtered (", length %d.\n", - TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)))); + { + struct type *t = check_typedef (SYMBOL_TYPE (sym)); + + printf_filtered (", length %s.\n", pulongest (TYPE_LENGTH (t))); + } } if (BLOCK_FUNCTION (block)) break; @@ -3063,7 +3080,8 @@ find_matching_tracepoint_location (struct uploaded_tp *utp) if (b->type == utp->type && t->step_count == utp->step && t->pass_count == utp->pass - && cond_string_is_same (t->cond_string, utp->cond_string) + && cond_string_is_same (t->cond_string, + utp->cond_string.get ()) /* FIXME also test actions. */ ) { @@ -3204,7 +3222,6 @@ void merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs) { struct uploaded_tsv *utsv; - struct trace_state_variable *tsv; int highest; /* Most likely some numbers will have to be reassigned as part of @@ -3214,7 +3231,7 @@ merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs) for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next) { - tsv = find_matching_tsv (utsv); + struct trace_state_variable *tsv = find_matching_tsv (utsv); if (tsv) { if (info_verbose) @@ -3443,7 +3460,7 @@ parse_tracepoint_definition (const char *line, struct uploaded_tp **utpp) int enabled, end; enum bptype type; const char *srctype; - char *cond, *buf; + char *buf; struct uploaded_tp *utp = NULL; p = line; @@ -3456,13 +3473,14 @@ parse_tracepoint_definition (const char *line, struct uploaded_tp **utpp) p++; /* skip a colon */ if (piece == 'T') { + gdb::unique_xmalloc_ptr cond; + enabled = (*p++ == 'E'); p++; /* skip a colon */ p = unpack_varlen_hex (p, &step); p++; /* skip a colon */ p = unpack_varlen_hex (p, &pass); type = bp_tracepoint; - cond = NULL; /* Thumb through optional fields. */ while (*p == ':') { @@ -3483,8 +3501,8 @@ parse_tracepoint_definition (const char *line, struct uploaded_tp **utpp) p++; p = unpack_varlen_hex (p, &xlen); p++; /* skip a comma */ - cond = (char *) xmalloc (2 * xlen + 1); - strncpy (cond, p, 2 * xlen); + cond.reset ((char *) xmalloc (2 * xlen + 1)); + strncpy (&cond[0], p, 2 * xlen); cond[2 * xlen] = '\0'; p += 2 * xlen; } @@ -3497,17 +3515,17 @@ parse_tracepoint_definition (const char *line, struct uploaded_tp **utpp) utp->enabled = enabled; utp->step = step; utp->pass = pass; - utp->cond = cond; + utp->cond = std::move (cond); } else if (piece == 'A') { utp = get_uploaded_tp (num, addr, utpp); - utp->actions.push_back (xstrdup (p)); + utp->actions.emplace_back (xstrdup (p)); } else if (piece == 'S') { utp = get_uploaded_tp (num, addr, utpp); - utp->step_actions.push_back (xstrdup (p)); + utp->step_actions.emplace_back (xstrdup (p)); } else if (piece == 'Z') { @@ -3527,11 +3545,11 @@ parse_tracepoint_definition (const char *line, struct uploaded_tp **utpp) buf[end] = '\0'; if (startswith (srctype, "at:")) - utp->at_string = xstrdup (buf); + utp->at_string.reset (xstrdup (buf)); else if (startswith (srctype, "cond:")) - utp->cond_string = xstrdup (buf); + utp->cond_string.reset (xstrdup (buf)); else if (startswith (srctype, "cmd:")) - utp->cmd_strings.push_back (xstrdup (buf)); + utp->cmd_strings.emplace_back (xstrdup (buf)); } else if (piece == 'V') { @@ -3641,7 +3659,7 @@ print_one_static_tracepoint_marker (int count, /* A counter field to help readability. This is not a stable identifier! */ - uiout->field_int ("count", count); + uiout->field_signed ("count", count); uiout->field_string ("marker-id", marker.str_id.c_str ()); @@ -3665,8 +3683,8 @@ print_one_static_tracepoint_marker (int count, if (sym) { uiout->text ("in "); - uiout->field_string ("func", - SYMBOL_PRINT_NAME (sym)); + uiout->field_string ("func", sym->print_name (), + function_name_style.style ()); uiout->wrap_hint (wrap_indent); uiout->text (" at "); } @@ -3676,7 +3694,8 @@ print_one_static_tracepoint_marker (int count, if (sal.symtab != NULL) { uiout->field_string ("file", - symtab_to_filename_for_display (sal.symtab)); + symtab_to_filename_for_display (sal.symtab), + file_name_style.style ()); uiout->text (":"); if (uiout->is_mi_like_p ()) @@ -3688,7 +3707,7 @@ print_one_static_tracepoint_marker (int count, else uiout->field_skip ("fullname"); - uiout->field_int ("line", sal.line); + uiout->field_signed ("line", sal.line); } else { @@ -3707,7 +3726,7 @@ print_one_static_tracepoint_marker (int count, int ix; { - ui_out_emit_tuple tuple_emitter (uiout, "tracepoints-at"); + ui_out_emit_tuple inner_tuple_emitter (uiout, "tracepoints-at"); uiout->text (extra_field_indent); uiout->text (_("Probed by static tracepoints: ")); @@ -3716,12 +3735,12 @@ print_one_static_tracepoint_marker (int count, if (ix > 0) uiout->text (", "); uiout->text ("#"); - uiout->field_int ("tracepoint-id", tracepoints[ix]->number); + uiout->field_signed ("tracepoint-id", tracepoints[ix]->number); } } if (uiout->is_mi_like_p ()) - uiout->field_int ("number-of-tracepoints", tracepoints.size ()); + uiout->field_signed ("number-of-tracepoints", tracepoints.size ()); else uiout->text ("\n"); } @@ -3957,6 +3976,9 @@ static const struct internalvar_funcs sdata_funcs = NULL }; +/* See tracepoint.h. */ +cmd_list_element *while_stepping_cmd_element = nullptr; + /* module initialization */ void _initialize_tracepoint (void) @@ -3973,7 +3995,7 @@ _initialize_tracepoint (void) tracepoint_number = -1; add_info ("scope", info_scope_command, - _("List the variables local to a scope")); + _("List the variables local to a scope.")); add_cmd ("tracepoints", class_trace, _("Tracing of program execution without stopping the program."), @@ -3996,27 +4018,25 @@ If no arguments are supplied, delete all variables."), &deletelist); /* FIXME add a trace variable completer. */ add_info ("tvariables", info_tvariables_command, _("\ -Status of trace state variables and their values.\n\ -")); +Status of trace state variables and their values.")); add_info ("static-tracepoint-markers", info_static_tracepoint_markers_command, _("\ -List target static tracepoints markers.\n\ -")); +List target static tracepoints markers.")); add_prefix_cmd ("tfind", class_trace, tfind_command, _("\ -Select a trace frame;\n\ +Select a trace frame.\n\ No argument means forward by one frame; '-' means backward by one frame."), &tfindlist, "tfind ", 1, &cmdlist); add_cmd ("outside", class_trace, tfind_outside_command, _("\ Select a trace frame whose PC is outside the given range (exclusive).\n\ -Usage: tfind outside addr1, addr2"), +Usage: tfind outside ADDR1, ADDR2"), &tfindlist); add_cmd ("range", class_trace, tfind_range_command, _("\ Select a trace frame whose PC is in the given range (inclusive).\n\ -Usage: tfind range addr1,addr2"), +Usage: tfind range ADDR1, ADDR2"), &tfindlist); add_cmd ("line", class_trace, tfind_line_command, _("\ @@ -4068,7 +4088,8 @@ Entering \"end\" on a line by itself is the normal way to terminate\n\ such a list.\n\n\ Note: the \"end\" command cannot be used at the gdb prompt.")); - add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\ + while_stepping_cmd_element = add_com ("while-stepping", class_trace, + while_stepping_pseudocommand, _("\ Specify single-stepping behavior at a tracepoint.\n\ Argument is number of instructions to trace in single-step mode\n\ following the tracepoint. This command is normally followed by\n\ @@ -4105,8 +4126,8 @@ depending on target's capabilities.")); default_collect = xstrdup (""); add_setshow_string_cmd ("default-collect", class_trace, &default_collect, _("\ -Set the list of expressions to collect by default"), _("\ -Show the list of expressions to collect by default"), NULL, +Set the list of expressions to collect by default."), _("\ +Show the list of expressions to collect by default."), NULL, NULL, NULL, &setlist, &showlist); @@ -4146,22 +4167,22 @@ disables any attempt to set the buffer size and lets the target choose."), add_setshow_string_cmd ("trace-user", class_trace, &trace_user, _("\ -Set the user name to use for current and future trace runs"), _("\ -Show the user name to use for current and future trace runs"), NULL, +Set the user name to use for current and future trace runs."), _("\ +Show the user name to use for current and future trace runs."), NULL, set_trace_user, NULL, &setlist, &showlist); add_setshow_string_cmd ("trace-notes", class_trace, &trace_notes, _("\ -Set notes string to use for current and future trace runs"), _("\ -Show the notes string to use for current and future trace runs"), NULL, +Set notes string to use for current and future trace runs."), _("\ +Show the notes string to use for current and future trace runs."), NULL, set_trace_notes, NULL, &setlist, &showlist); add_setshow_string_cmd ("trace-stop-notes", class_trace, &trace_stop_notes, _("\ -Set notes string to use for future tstop commands"), _("\ -Show the notes string to use for future tstop commands"), NULL, +Set notes string to use for future tstop commands."), _("\ +Show the notes string to use for future tstop commands."), NULL, set_trace_stop_notes, NULL, &setlist, &showlist); }