#include "value.h"
#include "target.h"
#include "language.h"
+#include "gdb_string.h"
/* readline include files */
#include "readline.h"
#endif
extern int info_verbose;
+extern void (*readline_begin_hook) PARAMS ((char *, ...));
+extern char * (*readline_hook) PARAMS ((char *));
+extern void (*readline_end_hook) PARAMS ((void));
+extern void x_command PARAMS ((char *, int));
/* If this definition isn't overridden by the header files, assume
that isatty and fileno exist on this system. */
#define ISATTY(FP) (isatty (fileno (FP)))
#endif
+/*
+ Tracepoint.c:
+
+ This module defines the following debugger commands:
+ trace : set a tracepoint on a function, line, or address.
+ info trace : list all debugger-defined tracepoints.
+ delete trace : delete one or more tracepoints.
+ enable trace : enable one or more tracepoints.
+ disable trace : disable one or more tracepoints.
+ actions : specify actions to be taken at a tracepoint.
+ passcount : specify a pass count for a tracepoint.
+ tstart : start a trace experiment.
+ tstop : stop a trace experiment.
+ tstatus : query the status of a trace experiment.
+ tfind : find a trace frame in the trace buffer.
+ tdump : print everything collected at the current tracepoint.
+ save-tracepoints : write tracepoint setup into a file.
+
+ This module defines the following user-visible debugger variables:
+ $trace_frame : sequence number of trace frame currently being debugged.
+ $trace_line : source line of trace frame currently being debugged.
+ $trace_file : source file of trace frame currently being debugged.
+ $tracepoint : tracepoint number of trace frame currently being debugged.
+ */
+
+
+/* ======= Important global variables: ======= */
+
/* Chain of all tracepoints defined. */
struct tracepoint *tracepoint_chain;
/* Number of last traceframe collected. */
static int traceframe_number;
+/* Tracepoint for last traceframe collected. */
+static int tracepoint_number;
+
+/* Symbol for function for last traceframe collected */
+static struct symbol *traceframe_fun;
+
+/* Symtab and line for last traceframe collected */
+static struct symtab_and_line traceframe_sal;
+
+/* Tracing command lists */
+static struct cmd_list_element *tfindlist;
+
+/* ======= Important command functions: ======= */
+static void trace_command PARAMS ((char *, int));
+static void tracepoints_info PARAMS ((char *, int));
+static void delete_trace_command PARAMS ((char *, int));
+static void enable_trace_command PARAMS ((char *, int));
+static void disable_trace_command PARAMS ((char *, int));
+static void trace_pass_command PARAMS ((char *, int));
+static void trace_actions_command PARAMS ((char *, int));
+static void trace_start_command PARAMS ((char *, int));
+static void trace_stop_command PARAMS ((char *, int));
+static void trace_status_command PARAMS ((char *, int));
+static void trace_find_command PARAMS ((char *, int));
+static void trace_find_pc_command PARAMS ((char *, int));
+static void trace_find_tracepoint_command PARAMS ((char *, int));
+static void trace_find_line_command PARAMS ((char *, int));
+static void trace_find_range_command PARAMS ((char *, int));
+static void trace_find_outside_command PARAMS ((char *, int));
+static void tracepoint_save_command PARAMS ((char *, int));
+static void trace_dump_command PARAMS ((char *, int));
+
+
/* Utility: returns true if "target remote" */
static int
target_is_remote ()
{
case '1': /* malformed packet error */
if (*++buf == '0') /* general case: */
- error ("tracepoint.c: badly formed packet.");
+ error ("tracepoint.c: error in outgoing packet.");
else
- error ("tracepoint.c: badly formed packet at field #%d.",
- *buf - '0');
+ error ("tracepoint.c: error in outgoing packet at field #%d.",
+ strtol (buf, NULL, 16));
case '2':
- error ("trace API error '%s'.", buf);
+ error ("trace API error 0x%s.", ++buf);
default:
error ("Target returns error code '%s'.", buf);
}
}
-/* Obsolete: collect regs from a trace frame */
-static void
-trace_receive_regs (buf)
- char *buf;
-{
- long regno, i;
- char regbuf[MAX_REGISTER_RAW_SIZE], *tmp, *p = buf;
-
- while (*p)
- {
- regno = strtol (p, &tmp, 16);
- if (p == tmp || *tmp++ != ':')
- error ("tracepoint.c: malformed 'R' packet");
- else p = tmp;
-
- for (i = 0; i < REGISTER_RAW_SIZE (regno); i++)
- {
- if (p[0] == 0 || p[1] == 0)
- warning ("Remote reply is too short: %s", buf);
- regbuf[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
- p += 2;
- }
-
- if (*p++ != ';')
- error ("tracepoint.c: malformed 'R' packet");
-
- supply_register (regno, regbuf);
- }
-}
-
/* Utility: wait for reply from stub, while accepting "O" packets */
-static void
+static char *
remote_get_noisy_reply (buf)
char *buf;
{
error ("Target does not support this command.");
else if (buf[0] == 'E')
trace_error (buf);
- else if (buf[0] == 'R')
- {
- flush_cached_frames ();
- registers_changed ();
- select_frame (get_current_frame (), 0);
- trace_receive_regs (buf);
- }
else if (buf[0] == 'O' &&
buf[1] != 'K')
remote_console_output (buf + 1); /* 'O' message from stub */
else
- return; /* here's the actual reply */
+ return buf; /* here's the actual reply */
} while (1);
}
value_from_longest (builtin_type_int, (LONGEST) num));
}
+/* Set tracepoint number to NUM. */
+static void
+set_tracepoint_num (num)
+ int num;
+{
+ tracepoint_number = num;
+ set_internalvar (lookup_internalvar ("tracepoint"),
+ value_from_longest (builtin_type_int, (LONGEST) num));
+}
+
+/* Set externally visible debug variables for querying/printing
+ the traceframe context (line, function, file) */
+
+static void
+set_traceframe_context (trace_pc)
+ CORE_ADDR trace_pc;
+{
+ static struct type *func_string, *file_string;
+ static struct type *func_range, *file_range;
+ static value_ptr func_val, file_val;
+ static struct type *charstar;
+ int len;
+
+ if (charstar == (struct type *) NULL)
+ charstar = lookup_pointer_type (builtin_type_char);
+
+ if (trace_pc == -1) /* cease debugging any trace buffers */
+ {
+ traceframe_fun = 0;
+ traceframe_sal.pc = traceframe_sal.line = 0;
+ traceframe_sal.symtab = NULL;
+ set_internalvar (lookup_internalvar ("trace_func"),
+ value_from_longest (charstar, (LONGEST) 0));
+ set_internalvar (lookup_internalvar ("trace_file"),
+ value_from_longest (charstar, (LONGEST) 0));
+ set_internalvar (lookup_internalvar ("trace_line"),
+ value_from_longest (builtin_type_int, (LONGEST) -1));
+ return;
+ }
+
+ /* save as globals for internal use */
+ traceframe_sal = find_pc_line (trace_pc, 0);
+ traceframe_fun = find_pc_function (trace_pc);
+
+ /* save linenumber as "$trace_line", a debugger variable visible to users */
+ set_internalvar (lookup_internalvar ("trace_line"),
+ value_from_longest (builtin_type_int,
+ (LONGEST) traceframe_sal.line));
+
+ /* save func name as "$trace_func", a debugger variable visible to users */
+ if (traceframe_fun == NULL ||
+ SYMBOL_NAME (traceframe_fun) == NULL)
+ set_internalvar (lookup_internalvar ("trace_func"),
+ value_from_longest (charstar, (LONGEST) 0));
+ else
+ {
+ len = strlen (SYMBOL_NAME (traceframe_fun));
+ func_range = create_range_type (func_range,
+ builtin_type_int, 0, len - 1);
+ func_string = create_array_type (func_string,
+ builtin_type_char, func_range);
+ func_val = allocate_value (func_string);
+ VALUE_TYPE (func_val) = func_string;
+ memcpy (VALUE_CONTENTS_RAW (func_val),
+ SYMBOL_NAME (traceframe_fun),
+ len);
+ func_val->modifiable = 0;
+ set_internalvar (lookup_internalvar ("trace_func"), func_val);
+ }
+
+ /* save file name as "$trace_file", a debugger variable visible to users */
+ if (traceframe_sal.symtab == NULL ||
+ traceframe_sal.symtab->filename == NULL)
+ set_internalvar (lookup_internalvar ("trace_file"),
+ value_from_longest (charstar, (LONGEST) 0));
+ else
+ {
+ len = strlen (traceframe_sal.symtab->filename);
+ file_range = create_range_type (file_range,
+ builtin_type_int, 0, len - 1);
+ file_string = create_array_type (file_string,
+ builtin_type_char, file_range);
+ file_val = allocate_value (file_string);
+ VALUE_TYPE (file_val) = file_string;
+ memcpy (VALUE_CONTENTS_RAW (file_val),
+ traceframe_sal.symtab->filename,
+ len);
+ file_val->modifiable = 0;
+ set_internalvar (lookup_internalvar ("trace_file"), file_val);
+ }
+}
+
/* Low level routine to set a tracepoint.
Returns the tracepoint object so caller can set other things.
Does not set the tracepoint number!
t->source_file = NULL;
else
{
+ char *p;
+
t->source_file = (char *) xmalloc (strlen (sal.symtab->filename) +
- strlen (sal.symtab->dirname) + 1);
+ strlen (sal.symtab->dirname) + 2);
strcpy (t->source_file, sal.symtab->dirname);
+ p = t->source_file;
+ while (*p)
+ p++;
+ if (*(--p) != '/') /* Will this work on Windows? */
+ strcat (t->source_file, "/");
strcat (t->source_file, sal.symtab->filename);
}
t->language = current_language->la_language;
t->input_radix = input_radix;
t->line_number = sal.line;
- t->enabled = enabled;
- t->next = 0;
- t->step_count = 0;
- t->pass_count = 0;
+ t->enabled = enabled;
+ t->next = 0;
+ t->step_count = 0;
+ t->pass_count = 0;
+ t->addr_string = NULL;
/* Add this tracepoint to the end of the chain
so that a list of tracepoints will come out in order
return t;
}
+/* Set a tracepoint according to ARG (function, linenum or *address) */
static void
trace_command (arg, from_tty)
char *arg;
struct symtabs_and_lines sals;
struct symtab_and_line sal;
struct tracepoint *t;
- char *addr_start = 0, *addr_end = 0, *cond_start = 0, *cond_end = 0;
+ char *addr_start = 0, *addr_end = 0;
int i;
if (!arg || !*arg)
t->number = tracepoint_count;
/* If a canonical line spec is needed use that instead of the
- command string. */
+ command string. */
if (canonical != (char **)NULL && canonical[i] != NULL)
- t->addr_string = canonical[i];
+ t->addr_string = canonical[i];
else if (addr_start)
- t->addr_string = savestring (addr_start, addr_end - addr_start);
- if (cond_start)
- t->cond_string = savestring (cond_start, cond_end - cond_start);
+ t->addr_string = savestring (addr_start, addr_end - addr_start);
/* Let the UI know of any additions */
if (create_tracepoint_hook)
- create_tracepoint_hook (t);
+ create_tracepoint_hook (t);
}
if (sals.nelts > 1)
{
printf_filtered ("Multiple tracepoints were set.\n");
- printf_filtered ("Use the \"delete\" command to delete unwanted tracepoints.\n");
+ printf_filtered ("Use 'delete trace' to delete unwanted tracepoints.\n");
}
}
+/* Print information on tracepoint number TPNUM_EXP, or all if omitted. */
+
static void
tracepoints_info (tpnum_exp, from_tty)
char *tpnum_exp;
extern int addressprint; /* print machine addresses? */
if (!found_a_tracepoint++)
- printf_filtered (" *** [info tracepoints header line] ***\n");
-
+ {
+ printf_filtered ("Num Enb ");
+ if (addressprint)
+ printf_filtered ("Address ");
+ printf_filtered ("PassC StepC What\n");
+ }
strcpy (wrap_indent, " ");
if (addressprint)
strcat (wrap_indent, " ");
- printf_filtered ("%-3d %-10s ", t->number,
- t->enabled == enabled ? "enabled" : "disabled");
+ printf_filtered ("%-3d %-3s ", t->number,
+ t->enabled == enabled ? "y" : "n");
if (addressprint)
- { /* FIXME-32x64: need a print_address_numeric with field width */
- printf_filtered ("%s ", local_hex_string_custom ((unsigned long) t->address, "08l"));
- }
+ printf_filtered ("%s ",
+ local_hex_string_custom ((unsigned long) t->address,
+ "08l"));
+ printf_filtered ("%-5d %-5d ", t->pass_count, t->step_count);
+
if (t->source_file)
{
sym = find_pc_function (t->address);
else
print_address_symbolic (t->address, gdb_stdout, demangle, " ");
- if (t->pass_count != 0)
- printf_filtered (" passcount = %d", t->pass_count);
printf_filtered ("\n");
if (t->actions)
{
enum tracepoint_opcode opcode;
{
struct tracepoint *t2;
- struct action_line *action, *next;
switch (opcode) {
case enable:
t->enabled = enabled;
+ if (modify_tracepoint_hook)
+ modify_tracepoint_hook (t);
break;
case disable:
t->enabled = disabled;
+ if (modify_tracepoint_hook)
+ modify_tracepoint_hook (t);
break;
case delete:
if (tracepoint_chain == t)
if (delete_tracepoint_hook)
delete_tracepoint_hook (t);
- if (t->cond_string)
- free (t->cond_string);
if (t->addr_string)
free (t->addr_string);
if (t->source_file)
free (t->source_file);
- for (action = t->actions; action; action = next)
- {
- next = action->next;
- if (action->action)
- free (action->action);
- free (action);
- }
+ if (t->actions)
+ free_actions (t);
+
free (t);
break;
}
char **arg;
{
struct tracepoint *t;
- char *cp;
+ char *end, *copy;
value_ptr val;
int tpnum;
tpnum = tracepoint_count;
else if (**arg == '$') /* handle convenience variable */
{
- cp = *arg + 1;
- /* find end of convenience variable name */
- while (**arg && **arg != ' ' && **arg != '\t')
- *arg++;
- /* null-terminate if necessary */
- if (**arg != 0)
- *(*arg++) = 0;
- val = value_of_internalvar (lookup_internalvar (cp));
+ /* Make a copy of the name, so we can null-terminate it
+ to pass to lookup_internalvar(). */
+ end = *arg + 1;
+ while (isalnum(*end) || *end == '_')
+ end++;
+ copy = (char *) alloca (end - *arg);
+ strncpy (copy, *arg + 1, (end - *arg - 1));
+ copy[end - *arg - 1] = '\0';
+ *arg = end;
+
+ val = value_of_internalvar (lookup_internalvar (copy));
if (TYPE_CODE( VALUE_TYPE (val)) != TYPE_CODE_INT)
error ("Convenience variable must have integral type.");
tpnum = (int) value_as_long (val);
int from_tty;
enum tracepoint_opcode opcode;
{
- struct tracepoint *t;
+ struct tracepoint *t, *tmp;
int tpnum;
char *cp;
if (args == 0 || *args == 0) /* do them all */
- ALL_TRACEPOINTS (t)
+ ALL_TRACEPOINTS_SAFE (t, tmp)
tracepoint_operation (t, from_tty, opcode);
else
while (*args)
}
}
+/* The 'enable trace' command enables tracepoints. Not supported by all targets. */
static void
enable_trace_command (args, from_tty)
char *args;
map_args_over_tracepoints (args, from_tty, enable);
}
+/* The 'disable trace' command enables tracepoints. Not supported by all targets. */
static void
disable_trace_command (args, from_tty)
char *args;
map_args_over_tracepoints (args, from_tty, disable);
}
+/* Remove a tracepoint (or all if no argument) */
static void
delete_trace_command (args, from_tty)
char *args;
map_args_over_tracepoints (args, from_tty, delete);
}
+/* Set passcount for tracepoint.
+
+ First command argument is passcount, second is tracepoint number.
+ If tracepoint number omitted, apply to most recently defined.
+ Also accepts special argument "all". */
+
static void
trace_pass_command (args, from_tty)
char *args;
if (t1 == (struct tracepoint *) -1 || t1 == t2)
{
t2->pass_count = count;
+ if (modify_tracepoint_hook)
+ modify_tracepoint_hook (t2);
if (from_tty)
printf_filtered ("Setting tracepoint %d's passcount to %d\n",
t2->number, count);
}
}
-/* ACTIONS ACTIONS ACTIONS */
+/* ACTIONS functions: */
+
+/* Prototypes for action-parsing utility commands */
+static void read_actions PARAMS((struct tracepoint *));
+static char *parse_and_eval_memrange PARAMS ((char *,
+ CORE_ADDR,
+ long *,
+ bfd_signed_vma *,
+ long *));
+
+/* The three functions:
+ collect_pseudocommand,
+ while_stepping_pseudocommand, and
+ end_actions_pseudocommand
+ are placeholders for "commands" that are actually ONLY to be used
+ within a tracepoint action list. If the actual function is ever called,
+ it means that somebody issued the "command" at the top level,
+ which is always an error. */
-static void read_actions PARAMS((struct tracepoint *));
-static void free_actions PARAMS((struct tracepoint *));
-static int validate_actionline PARAMS((char *, struct tracepoint *));
+static void
+end_actions_pseudocommand (args, from_tty)
+ char *args;
+ int from_tty;
+{
+ error ("This command cannot be used at the top level.");
+}
+static void
+while_stepping_pseudocommand (args, from_tty)
+ char *args;
+ int from_tty;
+{
+ error ("This command can only be used in a tracepoint actions list.");
+}
+
+static void
+collect_pseudocommand (args, from_tty)
+ char *args;
+ int from_tty;
+{
+ error ("This command can only be used in a tracepoint actions list.");
+}
+
+/* Enter a list of actions for a tracepoint. */
static void
trace_actions_command (args, from_tty)
char *args;
{
struct tracepoint *t;
char *actions;
+ char tmpbuf[128];
+ char *end_msg = "End with a line saying just \"end\".";
if (t = get_tracepoint_by_number (&args))
{
+ sprintf (tmpbuf, "Enter actions for tracepoint %d, one per line.",
+ t->number);
+
if (from_tty)
- printf_filtered ("Enter actions for tracepoint %d, one per line.\n",
- t->number);
+ {
+ if (readline_begin_hook)
+ (*readline_begin_hook) ("%s %s\n", tmpbuf, end_msg);
+ else if (input_from_terminal_p ())
+ printf_filtered ("%s\n%s\n", tmpbuf, end_msg);
+ }
+
free_actions (t);
read_actions (t);
+
+ if (readline_end_hook)
+ (*readline_end_hook) ();
+
/* tracepoints_changed () */
}
/* else error, just return; */
STEPPING = 2,
};
+static enum actionline_type validate_actionline PARAMS((char **,
+ struct tracepoint *));
+
+/* worker function */
static void
read_actions (t)
struct tracepoint *t;
wrap_here ("");
gdb_flush (gdb_stdout);
gdb_flush (gdb_stderr);
- if (instream == stdin && ISATTY (instream))
- line = readline (prompt);
+
+ if (readline_hook && instream == NULL)
+ line = (*readline_hook) (prompt);
+ else if (instream == stdin && ISATTY (instream))
+ {
+ line = readline (prompt);
+ if (line && *line) /* add it to command history */
+ add_history (line);
+ }
else
line = gdb_readline (0);
- linetype = validate_actionline (line, t);
+ linetype = validate_actionline (&line, t);
if (linetype == BADLINE)
continue; /* already warned -- collect another line */
- temp = xmalloc (sizeof (struct action_line));
+ temp = (struct action_line *) xmalloc (sizeof (struct action_line));
temp->next = NULL;
temp->action = line;
discard_cleanups (old_chain);
}
+/* worker function */
static enum actionline_type
validate_actionline (line, t)
- char *line;
+ char **line;
struct tracepoint *t;
{
- char *p;
+ struct cmd_list_element *c;
struct expression *exp;
value_ptr temp, temp2;
+ char *p;
- for (p = line; isspace (*p); )
+ for (p = *line; isspace (*p); )
p++;
/* symbol lookup etc. */
if (*p == '\0') /* empty line: just prompt for another line. */
return BADLINE;
- else if (0 == strncasecmp (p, "collect", 7))
+
+ if (*p == '#') /* comment line */
+ return GENERIC;
+
+ c = lookup_cmd (&p, cmdlist, "", -1, 1);
+ if (c == 0)
+ {
+ warning ("'%s' is not an action that I know, or is ambiguous.", p);
+ return BADLINE;
+ }
+
+ if (c->function.cfunc == collect_pseudocommand)
{
- p += 7;
do { /* repeat over a comma-separated list */
while (isspace (*p))
p++;
- if (*p == '$' && /* look for special pseudo-symbols */
- ((0 == strncasecmp ("reg", p + 1, 3)) ||
- (0 == strncasecmp ("arg", p + 1, 3)) ||
- (0 == strncasecmp ("loc", p + 1, 3))))
- p = (char *) strchr (p, ',');
+ if (*p == '$') /* look for special pseudo-symbols */
+ {
+ long typecode, size;
+ bfd_signed_vma offset;
+
+ if ((0 == strncasecmp ("reg", p + 1, 3)) ||
+ (0 == strncasecmp ("arg", p + 1, 3)) ||
+ (0 == strncasecmp ("loc", p + 1, 3)))
+ p = strchr (p, ',');
+
+ else if (p[1] == '(') /* literal memrange */
+ {
+ char *temp, *newline;
+
+ newline = malloc (strlen (*line) + 32);
+ strcpy (newline, *line);
+ newline[p - *line] = '\0';
+ /* newline is now a copy of line, up to "p" (the memrange) */
+ temp = parse_and_eval_memrange (p, t->address,
+ &typecode, &offset, &size) + 1;
+ /* now compose the memrange as a literal value */
+ if (typecode == -1)
+ sprintf (newline + strlen (newline),
+ "$(0x%x, %d)",
+ offset, size);
+ else
+ sprintf (newline + strlen (newline),
+ "$($%s, 0x%x, %d)",
+ reg_names[typecode], offset, size);
+ /* now add the remainder of the old line to the new one */
+ p = newline + strlen (newline);
+ if (temp && *temp)
+ strcat (newline, temp);
+ free (*line);
+ *line = newline;
+ }
+ }
else
{
exp = parse_exp_1 (&p, block_for_pc (t->address), 1);
+
if (exp->elts[0].opcode != OP_VAR_VALUE &&
+ exp->elts[0].opcode != UNOP_MEMVAL &&
/*exp->elts[0].opcode != OP_LONG && */
/*exp->elts[0].opcode != UNOP_CAST && */
exp->elts[0].opcode != OP_REGISTER)
{
- warning ("collect: enter variable name or register.\n");
+ warning ("collect requires a variable or register name.\n");
return BADLINE;
}
if (exp->elts[0].opcode == OP_VAR_VALUE)
} while (p && *p++ == ',');
return GENERIC;
}
- else if (0 == strncasecmp (p, "while-stepping", 14))
+ else if (c->function.cfunc == while_stepping_pseudocommand)
{
char *steparg; /* in case warning is necessary */
- p += 14;
while (isspace (*p))
p++;
steparg = p;
t->step_count = -1;
return STEPPING;
}
- else if (0 == strncasecmp (p, "end", 3))
+ else if (c->function.cfunc == end_actions_pseudocommand)
return END;
else
{
- warning ("'%s' is not a supported tracepoint action.", p);
+ warning ("'%s' is not a supported tracepoint action.", *line);
return BADLINE;
}
}
-static void
+/* worker function */
+void
free_actions (t)
struct tracepoint *t;
{
for (line = t->actions; line; line = next)
{
next = line->next;
+ if (line->action)
+ free (line->action);
free (line);
}
t->actions = NULL;
struct memrange *list;
} tracepoint_list, stepping_list;
+/* MEMRANGE functions: */
+
+/* parse a memrange spec from command input */
+static char *
+parse_and_eval_memrange (arg, addr, typecode, offset, size)
+ char *arg;
+ CORE_ADDR addr;
+ long *typecode, *size;
+ bfd_signed_vma *offset;
+{
+ char *start = arg;
+ struct expression *exp;
+ value_ptr val;
+
+ if (*arg++ != '$' || *arg++ != '(')
+ error ("Internal: bad argument to parse_and_eval_memrange: %s", start);
+
+ if (*arg == '$') /* register for relative memrange? */
+ {
+ exp = parse_exp_1 (&arg, block_for_pc (addr), 1);
+ if (exp->elts[0].opcode != OP_REGISTER)
+ error ("Bad register operand for memrange: %s", start);
+ if (*arg++ != ',')
+ error ("missing comma for memrange: %s", start);
+ *typecode = exp->elts[1].longconst;
+ }
+ else
+ *typecode = -1; /* absolute memrange; */
+
+ exp = parse_exp_1 (&arg, 0, 1);
+ *offset = value_as_pointer (evaluate_expression (exp));
+
+ /* now parse the size */
+ if (*arg++ != ',')
+ error ("missing comma for memrange: %s", start);
+
+ exp = parse_exp_1 (&arg, 0, 0);
+ *size = value_as_long (evaluate_expression (exp));
+
+ if (info_verbose)
+ printf_filtered ("Collecting memrange: (0x%x,0x%x,0x%x)\n",
+ *typecode, *offset, *size);
+
+ return arg;
+}
+
+/* compare memranges for qsort */
static int
-memrange_cmp (a, b)
- struct memrange *a, *b;
+memrange_cmp (voidpa, voidpb)
+ void *voidpa, *voidpb;
{
+ struct memrange *a, *b;
+
+ a = (struct memrange *) voidpa;
+ b = (struct memrange *) voidpb;
+
if (a->type < b->type) return -1;
if (a->type > b->type) return 1;
if (a->type == 0)
return 0;
}
+/* Sort the memrange list using qsort, and merge adjacent memranges */
static void
memrange_sortmerge (memranges)
struct collection_list *memranges;
memranges->list[b].start - memranges->list[a].end <=
MAX_REGISTER_VIRTUAL_SIZE)
{
- memranges->list[a].end = memranges->list[b].end;
+ /* memrange b starts before memrange a ends; merge them. */
+ if (memranges->list[b].end > memranges->list[a].end)
+ memranges->list[a].end = memranges->list[b].end;
continue; /* next b, same a */
}
a++; /* next a */
}
}
+/* Add a register to a collection list */
void
add_register (collection, regno)
struct collection_list *collection;
collection->regs_mask [regno / 8] |= 1 << (regno % 8);
}
+/* Add a memrange to a collection list */
static void
add_memrange (memranges, type, base, len)
struct collection_list *memranges;
if (memranges->next_memrange >= memranges->listsize)
{
memranges->listsize *= 2;
- memranges->list = xrealloc (memranges->list,
+ memranges->list = (struct memrange *) xrealloc (memranges->list,
memranges->listsize);
}
- if (type != 0) /* better collect the base register! */
+ if (type != -1) /* better collect the base register! */
add_register (memranges, type);
}
+/* Add a symbol to a collection list */
static void
collect_symbol (collect, sym)
struct collection_list *collect;
case LOC_STATIC:
offset = SYMBOL_VALUE_ADDRESS (sym);
if (info_verbose)
- printf_filtered ("LOC_STATIC %s: collect %d bytes "
- "at 0x%08x\n",
+ printf_filtered ("LOC_STATIC %s: collect %d bytes at 0x%08x\n",
SYMBOL_NAME (sym), len, offset);
- add_memrange (collect, 0, offset, len); /* 0 == memory */
+ add_memrange (collect, -1, offset, len); /* 0 == memory */
break;
case LOC_REGISTER:
case LOC_REGPARM:
}
}
+/* Add all locals (or args) symbols to collection list */
static void
add_local_symbols (collect, pc, type)
struct collection_list *collect;
warning ("No %s found in scope.", type == 'L' ? "locals" : "args");
}
+/* worker function */
static void
clear_collection_list (list)
struct collection_list *list;
memset (list->regs_mask, 0, sizeof (list->regs_mask));
}
+/* reduce a collection list to string form (for gdb protocol) */
static char *
stringify_collection_list (list, string)
struct collection_list *list;
return string;
}
+/* render all actions into gdb protocol */
static void
encode_actions (t, tdp_actions, step_count, stepping_actions)
struct tracepoint *t;
unsigned long *step_count;
char **stepping_actions;
{
- struct expression *exp;
static char tdp_buff[2048], step_buff[2048];
- struct action_line *action;
char *action_exp;
+ struct expression *exp;
+ struct action_line *action;
bfd_signed_vma offset;
long i;
- struct collection_list *collect;
+ value_ptr tempval;
+ struct collection_list *collect;
+ struct cmd_list_element *cmd;
clear_collection_list (&tracepoint_list);
clear_collection_list (&stepping_list);
while (isspace (*action_exp))
action_exp++;
- if (0 == strncasecmp (action_exp, "collect", 7))
+ if (*action_exp == '#') /* comment line */
+ return;
+
+ cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
+ if (cmd == 0)
+ error ("Bad action list item: %s", action_exp);
+
+ if (cmd->function.cfunc == collect_pseudocommand)
{
- action_exp = action_exp + 7;
do { /* repeat over a comma-separated list */
while (isspace (*action_exp))
action_exp++;
{
for (i = 0; i < NUM_REGS; i++)
add_register (collect, i);
- action_exp = (char *) strchr (action_exp, ','); /* more? */
+ action_exp = strchr (action_exp, ','); /* more? */
}
else if (0 == strncasecmp ("$arg", action_exp, 4))
{
add_local_symbols (collect, t->address, 'A');
- action_exp = (char *) strchr (action_exp, ','); /* more? */
+ action_exp = strchr (action_exp, ','); /* more? */
}
else if (0 == strncasecmp ("$loc", action_exp, 4))
{
add_local_symbols (collect, t->address, 'L');
- action_exp = (char *) strchr (action_exp, ','); /* more? */
+ action_exp = strchr (action_exp, ','); /* more? */
+ }
+ else if (action_exp[0] == '$' &&
+ action_exp[1] == '(') /* literal memrange */
+ {
+ long typecode, size;
+ bfd_signed_vma offset;
+
+ action_exp = parse_and_eval_memrange (action_exp,
+ t->address,
+ &typecode,
+ &offset,
+ &size);
+ add_memrange (collect, typecode, offset, size);
}
else
{
printf_filtered ("OP_REGISTER: ");
add_register (collect, i);
break;
+
+ case UNOP_MEMVAL:
+ /* safe because we know it's a simple expression */
+ tempval = evaluate_expression (exp);
+ addr = VALUE_ADDRESS (tempval) + VALUE_OFFSET (tempval);
+ len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
+ add_memrange (collect, -1, addr, len);
+ break;
+
case OP_VAR_VALUE:
collect_symbol (collect, exp->elts[2].symbol);
break;
else
len = 4;
- add_memrange (collect, 0, addr, len);
+ add_memrange (collect, -1, addr, len);
break;
#endif
}
}
} while (action_exp && *action_exp++ == ',');
}
- else if (0 == strncasecmp (action_exp, "while-stepping", 14))
+ else if (cmd->function.cfunc == while_stepping_pseudocommand)
{
collect = &stepping_list;
}
- else if (0 == strncasecmp (action_exp, "end", 3))
+ else if (cmd->function.cfunc == end_actions_pseudocommand)
{
if (collect == &stepping_list) /* end stepping actions */
collect = &tracepoint_list;
memrange_sortmerge (&tracepoint_list);
memrange_sortmerge (&stepping_list);
- *tdp_actions = stringify_collection_list (&tracepoint_list, &tdp_buff);
- *stepping_actions = stringify_collection_list (&stepping_list, &step_buff);
+ *tdp_actions = stringify_collection_list (&tracepoint_list, tdp_buff);
+ *stepping_actions = stringify_collection_list (&stepping_list, step_buff);
}
static char target_buf[2048];
+/* tstart command:
+
+ Tell target to lear any previous trace experiment.
+ Walk the list of tracepoints, and send them (and their actions)
+ to the target. If no errors,
+ Tell target to start a new trace experiment. */
+
static void
trace_start_command (args, from_tty)
char *args;
if (tdp_actions)
{
if (strlen (buf) + strlen (tdp_actions) >= sizeof (buf))
- error ("Actions for tracepoint %d too complex; "
- "please simplify.", t->number);
+ error ("Actions for tracepoint %d too complex; please simplify.",
+ t->number);
strcat (buf, tdp_actions);
}
if (stepping_actions)
{
strcat (buf, "S");
if (strlen (buf) + strlen (stepping_actions) >= sizeof (buf))
- error ("Actions for tracepoint %d too complex; "
- "please simplify.", t->number);
+ error ("Actions for tracepoint %d too complex; please simplify.",
+ t->number);
strcat (buf, stepping_actions);
}
}
remote_get_noisy_reply (target_buf);
if (strcmp (target_buf, "OK"))
error ("Bogus reply from target: %s", target_buf);
+ set_traceframe_num (-1); /* all old traceframes invalidated */
+ set_tracepoint_num (-1);
+ set_traceframe_context(-1);
+ trace_running_p = 1;
}
else
printf_filtered ("Trace can only be run on remote targets.\n");
}
+/* tstop command */
static void
trace_stop_command (args, from_tty)
char *args;
remote_get_noisy_reply (target_buf);
if (strcmp (target_buf, "OK"))
error ("Bogus reply from target: %s", target_buf);
+ trace_running_p = 0;
}
else
error ("Trace can only be run on remote targets.");
}
+unsigned long trace_running_p;
+
+/* tstatus command */
static void
trace_status_command (args, from_tty)
char *args;
{
putpkt ("qTStatus");
remote_get_noisy_reply (target_buf);
- if (strcmp (target_buf, "OK"))
- error ("Bogus reply from target: %s", target_buf);
+
+ if (target_buf[0] != 'T' ||
+ (target_buf[1] != '0' && target_buf[1] != '1'))
+ error ("Bogus reply from target: %s", target_buf);
+
+ /* exported for use by the GUI */
+ trace_running_p = (target_buf[1] == '1');
}
else
error ("Trace can only be run on remote targets.");
}
+/* Worker function for the various flavors of the tfind command */
static void
-trace_buff_command (args, from_tty)
- char *args;
+finish_tfind_command (msg, from_tty)
+ char *msg;
int from_tty;
-{ /* STUB_COMM NOT_IMPLEMENTED */
- if (args == 0 || *args == 0)
- printf_filtered ("TBUFFER command requires argument (on or off)\n");
- else if (strcasecmp (args, "on") == 0)
- printf_filtered ("tbuffer overflow on.\n");
- else if (strcasecmp (args, "off") == 0)
- printf_filtered ("tbuffer overflow off.\n");
+{
+ int target_frameno = -1, target_tracept = -1;
+ CORE_ADDR old_frame_addr;
+ struct symbol *old_func;
+ char *reply;
+
+ old_frame_addr = FRAME_FP (get_current_frame ());
+ old_func = find_pc_function (read_pc ());
+
+ putpkt (msg);
+ reply = remote_get_noisy_reply (msg);
+
+ while (reply && *reply)
+ switch (*reply) {
+ case 'F':
+ if ((target_frameno = strtol (++reply, &reply, 16)) == -1)
+ {
+ /* A request for a non-existant trace frame has failed.
+ Our response will be different, depending on FROM_TTY:
+
+ If FROM_TTY is true, meaning that this command was
+ typed interactively by the user, then give an error
+ and DO NOT change the state of traceframe_number etc.
+
+ However if FROM_TTY is false, meaning that we're either
+ in a script, a loop, or a user-defined command, then
+ 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
+ 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
+ loop, then you need a way to detect that the command
+ failed WITHOUT aborting. This allows you to write
+ scripts that search thru the trace buffer until the end,
+ and then continue on to do something else. */
+
+ if (from_tty)
+ error ("Target failed to find requested trace frame.");
+ else
+ {
+ if (info_verbose)
+ printf_filtered ("End of trace buffer.\n");
+ /* The following will not recurse, since it's special-cased */
+ trace_find_command ("-1", from_tty);
+ reply = NULL; /* break out of loop,
+ (avoid recursive nonsense) */
+ }
+ }
+ break;
+ case 'T':
+ if ((target_tracept = strtol (++reply, &reply, 16)) == -1)
+ error ("Target failed to find requested trace frame.");
+ break;
+ case 'O': /* "OK"? */
+ if (reply[1] == 'K' && reply[2] == '\0')
+ reply += 2;
+ else
+ error ("Bogus reply from target: %s", reply);
+ break;
+ default:
+ error ("Bogus reply from target: %s", reply);
+ }
+
+ flush_cached_frames ();
+ registers_changed ();
+ select_frame (get_current_frame (), 0);
+ set_traceframe_num (target_frameno);
+ set_tracepoint_num (target_tracept);
+ if (target_frameno == -1)
+ set_traceframe_context (-1);
else
- printf_filtered ("TBUFFER: unknown argument (use on or off)\n");
-}
+ set_traceframe_context (read_pc ());
-static void
-trace_limit_command (args, from_tty)
- char *args;
- int from_tty;
-{ /* STUB_COMM NOT_IMPLEMENTED */
- printf_filtered ("Limit it to what?\n");
+ if (from_tty)
+ {
+ int source_only;
+
+ /* NOTE: in immitation of the step command, try to determine
+ whether we have made a transition from one function to another.
+ If so, we'll print the "stack frame" (ie. the new function and
+ it's arguments) -- otherwise we'll just show the new source line.
+
+ This determination is made by checking (1) whether the current
+ function has changed, and (2) whether the current FP has changed.
+ Hack: if the FP wasn't collected, either at the current or the
+ previous frame, assume that the FP has NOT changed. */
+
+ if (old_func == find_pc_function (read_pc ()) &&
+ (old_frame_addr == 0 ||
+ FRAME_FP (get_current_frame ()) == 0 ||
+ old_frame_addr == FRAME_FP (get_current_frame ())))
+ source_only = -1;
+ else
+ source_only = 1;
+
+ print_stack_frame (selected_frame, selected_frame_level, source_only);
+ do_displays ();
+ }
}
+/* trace_find_command takes a trace frame number n,
+ sends "QTFrame:<n>" to the target,
+ and accepts a reply that may contain several optional pieces
+ of information: a frame number, a tracepoint number, and an
+ indication of whether this is a trap frame or a stepping frame.
+
+ The minimal response is just "OK" (which indicates that the
+ target does not give us a frame number or a tracepoint number).
+ Instead of that, the target may send us a string containing
+ any combination of:
+ F<hexnum> (gives the selected frame number)
+ T<hexnum> (gives the selected tracepoint number)
+ */
+
+/* tfind command */
static void
trace_find_command (args, from_tty)
char *args;
int from_tty;
{ /* STUB_COMM PART_IMPLEMENTED */
/* this should only be called with a numeric argument */
- int frameno, target_frameno;
- char buf[40], *tmp;
-
+ int frameno = -1;
+ int target_frameno = -1, target_tracept = -1, target_stepfrm = 0;
+ char *tmp;
+
if (target_is_remote ())
{
if (args == 0 || *args == 0)
- frameno = traceframe_number + 1;
- else if (*args != '-' && !isdigit(*args))
- error ("tfind requires a literal (for now): %s rejected.", args);
+ { /* TFIND with no args means find NEXT trace frame. */
+ if (traceframe_number == -1)
+ frameno = 0; /* "next" is first one */
+ else
+ frameno = traceframe_number + 1;
+ }
+ else if (0 == strcmp (args, "-"))
+ {
+ if (traceframe_number == -1)
+ error ("not debugging trace buffer");
+ else if (from_tty && traceframe_number == 0)
+ error ("already at start of trace buffer");
+
+ frameno = traceframe_number - 1;
+ }
else
- frameno = strtol (args, 0, 0); /* for now, literals only */
+ frameno = parse_and_eval_address (args);
- sprintf (buf, "QTFrame:%x", frameno);
- putpkt (buf);
- remote_get_noisy_reply (target_buf);
+ sprintf (target_buf, "QTFrame:%x", frameno);
+#if 0
+ putpkt (target_buf);
+ tmp = remote_get_noisy_reply (target_buf);
- if (target_buf[0] != 'F')
- error ("Bogus reply from target: %s", target_buf);
- target_frameno = strtol (&target_buf[1], &tmp, 16);
- if (tmp == &target_buf[1])
- error ("Bogus reply from target: %s", target_buf);
- if (target_frameno != frameno)
- warning ("Target replied with different framenumber, %s != %x",
- target_buf, frameno);
-
- set_traceframe_num (target_frameno);
- flush_cached_frames ();
- registers_changed ();
- select_frame (get_current_frame (), 0);
+ if (frameno == -1) /* end trace debugging */
+ { /* hopefully the stub has complied! */
+ if (0 != strcmp (tmp, "OK"))
+ error ("Bogus response from target: %s", tmp);
+
+ finish_tfind_command (NULL, from_tty);
+ }
+ else
+ finish_tfind_command (tmp, from_tty);
+#else
+ finish_tfind_command (target_buf, from_tty);
+#endif
}
else
error ("Trace can only be run on remote targets.");
}
+/* tfind end */
+static void
+trace_find_end_command (args, from_tty)
+ char *args;
+ int from_tty;
+{
+ trace_find_command ("-1", from_tty);
+}
+
+/* tfind none */
+static void
+trace_find_none_command (args, from_tty)
+ char *args;
+ int from_tty;
+{
+ trace_find_command ("-1", from_tty);
+}
+
+/* tfind start */
+static void
+trace_find_start_command (args, from_tty)
+ char *args;
+ int from_tty;
+{
+ trace_find_command ("0", from_tty);
+}
+
+/* tfind pc command */
static void
trace_find_pc_command (args, from_tty)
char *args;
{ /* STUB_COMM PART_IMPLEMENTED */
CORE_ADDR pc;
int target_frameno;
- char buf[40], *tmp;
+ char *tmp;
if (target_is_remote ())
{
if (args == 0 || *args == 0)
- { /* TFIND PC <no args> is the same as TFIND <no args> */
- trace_find_command (args, from_tty);
- return;
- }
- if (!isdigit(*args))
- error ("tfind pc requires a literal argument (for now): %s rejected.",
- args);
-
- pc = strtol (args, 0, 0); /* for now, literals only */
- sprintf (buf, "QTFrame:pc:%x", pc);
- putpkt (buf);
- remote_get_noisy_reply (target_buf);
+ pc = read_pc (); /* default is current pc */
+ else
+ pc = parse_and_eval_address (args);
- if (target_buf[0] != 'F')
- error ("Bogus reply from target: %s", target_buf);
- target_frameno = strtol (&target_buf[1], &tmp, 16);
- if (tmp == &target_buf[1])
- error ("Bogus reply from target: %s", target_buf);
+ sprintf (target_buf, "QTFrame:pc:%x", pc);
+#if 0
+ putpkt (target_buf);
+ tmp = remote_get_noisy_reply (target_buf);
- set_traceframe_num (target_frameno);
- flush_cached_frames ();
- registers_changed ();
- select_frame (get_current_frame (), 0);
+ finish_tfind_command (tmp, from_tty);
+#else
+ finish_tfind_command (target_buf, from_tty);
+#endif
}
else
error ("Trace can only be run on remote targets.");
}
+/* tfind tracepoint command */
static void
-trace_find_tdp_command (args, from_tty)
+trace_find_tracepoint_command (args, from_tty)
char *args;
int from_tty;
{ /* STUB_COMM PART_IMPLEMENTED */
if (target_is_remote ())
{
if (args == 0 || *args == 0)
- { /* TFIND TDP <no args> is the same as TFIND <no args> */
- trace_find_command (args, from_tty);
- return;
- }
- if (!isdigit(*args))
- error ("tfind tdp command requires a literal argument (for now): %s",
- args);
-
- tdp = strtol (args, 0, 0); /* for now, literals only */
- sprintf (buf, "QTFrame:tdp:%x", tdp);
- putpkt (buf);
- remote_get_noisy_reply (target_buf);
+ if (tracepoint_number == -1)
+ error ("No current tracepoint -- please supply an argument.");
+ else
+ tdp = tracepoint_number; /* default is current TDP */
+ else
+ tdp = parse_and_eval_address (args);
- if (target_buf[0] != 'F')
- error ("Bogus reply from target: %s", target_buf);
- target_frameno = strtol (&target_buf[1], &tmp, 16);
- if (tmp == &target_buf[1])
- error ("Bogus reply from target: %s", target_buf);
+ sprintf (target_buf, "QTFrame:tdp:%x", tdp);
+#if 0
+ putpkt (target_buf);
+ tmp = remote_get_noisy_reply (target_buf);
- set_traceframe_num (target_frameno);
- flush_cached_frames ();
- registers_changed ();
- select_frame (get_current_frame (), 0);
+ finish_tfind_command (tmp, from_tty);
+#else
+ finish_tfind_command (target_buf, from_tty);
+#endif
}
else
error ("Trace can only be run on remote targets.");
}
+/* TFIND LINE command:
+
+ This command will take a sourceline for argument, just like BREAK
+ or TRACE (ie. anything that "decode_line_1" can handle).
+
+ With no argument, this command will find the next trace frame
+ corresponding to a source line OTHER THAN THE CURRENT ONE. */
+
static void
-trace_find_range_command (args, from_tty)
+trace_find_line_command (args, from_tty)
char *args;
int from_tty;
{ /* STUB_COMM PART_IMPLEMENTED */
- static CORE_ADDR start, stop;
+ static CORE_ADDR start_pc, end_pc;
+ struct symtabs_and_lines sals;
+ struct symtab_and_line sal;
int target_frameno;
- char buf[50], *tmp;
+ char *tmp;
+ struct cleanup *old_chain;
if (target_is_remote ())
{
- if (args == 0 || *args == 0 || !isdigit(*args))
- { /* XXX FIXME: what should default behavior be? */
- printf_filtered ("Usage: tfind range <address> <address>\n");
- return;
+ if (args == 0 || *args == 0)
+ {
+ sal = find_pc_line ((get_current_frame ())->pc, 0);
+ sals.nelts = 1;
+ sals.sals = (struct symtab_and_line *)
+ xmalloc (sizeof (struct symtab_and_line));
+ sals.sals[0] = sal;
}
-
- start = strtol (args, &args, 0); /* for now, literals only */
- while (args && *args && isspace (*args))
- args++;
-
- if (args == 0 || *args == 0 || !isdigit(*args))
+ else
{
- printf_filtered ("Usage: tfind range <address> <address>\n");
- return;
+ sals = decode_line_spec (args, 1);
+ sal = sals.sals[0];
}
- stop = strtol (args, &args, 0); /* for now, literals only */
-
- sprintf (buf, "QTFrame:range:%x:%x", start, stop);
- putpkt (buf);
- remote_get_noisy_reply (target_buf);
-
- if (target_buf[0] != 'F')
- error ("Bogus reply from target: %s", target_buf);
- target_frameno = strtol (&target_buf[1], &tmp, 16);
- if (tmp == &target_buf[1])
- error ("Bogus reply from target: %s", target_buf);
+ old_chain = make_cleanup (free, sals.sals);
+ if (sal.symtab == 0)
+ {
+ printf_filtered ("TFIND: No line number information available");
+ if (sal.pc != 0)
+ {
+ /* This is useful for "info line *0x7f34". If we can't tell the
+ user about a source line, at least let them have the symbolic
+ address. */
+ printf_filtered (" for address ");
+ wrap_here (" ");
+ print_address (sal.pc, gdb_stdout);
+ printf_filtered (";\n -- will attempt to find by PC. \n");
+ }
+ else
+ {
+ printf_filtered (".\n");
+ return; /* no line, no PC; what can we do? */
+ }
+ }
+ else if (sal.line > 0
+ && find_line_pc_range (sal, &start_pc, &end_pc))
+ {
+ if (start_pc == end_pc)
+ {
+ printf_filtered ("Line %d of \"%s\"",
+ sal.line, sal.symtab->filename);
+ wrap_here (" ");
+ printf_filtered (" is at address ");
+ print_address (start_pc, gdb_stdout);
+ wrap_here (" ");
+ printf_filtered (" but contains no code.\n");
+ sal = find_pc_line (start_pc, 0);
+ if (sal.line > 0 &&
+ find_line_pc_range (sal, &start_pc, &end_pc) &&
+ start_pc != end_pc)
+ printf_filtered ("Attempting to find line %d instead.\n",
+ sal.line);
+ else
+ error ("Cannot find a good line.");
+ }
+ }
+ else
+ /* Is there any case in which we get here, and have an address
+ which the user would want to see? If we have debugging symbols
+ and no line numbers? */
+ error ("Line number %d is out of range for \"%s\".\n",
+ sal.line, sal.symtab->filename);
+
+ if (args && *args) /* find within range of stated line */
+ sprintf (target_buf, "QTFrame:range:%x:%x", start_pc, end_pc - 1);
+ else /* find OUTSIDE OF range of CURRENT line */
+ sprintf (target_buf, "QTFrame:outside:%x:%x", start_pc, end_pc - 1);
+#if 0
+ putpkt (target_buf);
+ tmp = remote_get_noisy_reply (target_buf);
- set_traceframe_num (target_frameno);
- flush_cached_frames ();
- registers_changed ();
- select_frame (get_current_frame (), 0);
+ finish_tfind_command (tmp, from_tty);
+#else
+ finish_tfind_command (target_buf, from_tty);
+#endif
+ do_cleanups (old_chain);
}
else
error ("Trace can only be run on remote targets.");
}
+/* tfind range command */
static void
-trace_find_outside_command (args, from_tty)
+trace_find_range_command (args, from_tty)
char *args;
int from_tty;
{ /* STUB_COMM PART_IMPLEMENTED */
- CORE_ADDR start, stop;
+ static CORE_ADDR start, stop;
int target_frameno;
- char buf[50], *tmp;
+ char *tmp;
if (target_is_remote ())
{
- if (args == 0 || *args == 0 || !isdigit(*args))
+ if (args == 0 || *args == 0)
{ /* XXX FIXME: what should default behavior be? */
- printf_filtered ("Usage: tfind outside <address> <address>\n");
+ printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
return;
}
- start = strtol (args, &args, 0);
- while (args && *args && isspace (*args))
- args++;
-
- if (args == 0 || *args == 0 || !isdigit(*args))
+ if (0 != (tmp = strchr (args, ',' )))
{
- printf_filtered ("Usage: tfind outside <address> <address>\n");
- return;
+ *tmp++ = '\0'; /* terminate start address */
+ while (isspace (*tmp))
+ tmp++;
+ start = parse_and_eval_address (args);
+ stop = parse_and_eval_address (tmp);
+ }
+ else
+ { /* no explicit end address? */
+ start = parse_and_eval_address (args);
+ stop = start + 1; /* ??? */
}
- stop = strtol (args, &args, 0);
-
- sprintf (buf, "QTFrame:outside:%x:%x", start, stop);
- putpkt (buf);
- remote_get_noisy_reply (target_buf);
-
- if (target_buf[0] != 'F')
- error ("Bogus reply from target: %s", target_buf);
- target_frameno = strtol (&target_buf[1], &tmp, 16);
- if (tmp == &target_buf[1])
- error ("Bogus reply from target: %s", target_buf);
+ sprintf (target_buf, "QTFrame:range:%x:%x", start, stop);
+#if 0
+ putpkt (target_buf);
+ tmp = remote_get_noisy_reply (target_buf);
- set_traceframe_num (target_frameno);
- flush_cached_frames ();
- registers_changed ();
- select_frame (get_current_frame (), 0);
+ finish_tfind_command (tmp, from_tty);
+#else
+ finish_tfind_command (target_buf, from_tty);
+#endif
}
else
error ("Trace can only be run on remote targets.");
}
+/* tfind outside command */
static void
-trace_display_command (args, from_tty)
+trace_find_outside_command (args, from_tty)
char *args;
int from_tty;
-{ /* STUB_COMM NOT_IMPLEMENTED */
- if (!target_is_remote ())
+{ /* STUB_COMM PART_IMPLEMENTED */
+ CORE_ADDR start, stop;
+ int target_frameno;
+ char *tmp;
+
+ if (target_is_remote ())
{
- printf_filtered ("Trace can only be run on remote targets.\n");
- return;
- }
+ if (args == 0 || *args == 0)
+ { /* XXX FIXME: what should default behavior be? */
+ printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
+ return;
+ }
- if (args && *args)
- printf_filtered ("Displaying trace as %s.\n", args);
+ if (0 != (tmp = strchr (args, ',' )))
+ {
+ *tmp++ = '\0'; /* terminate start address */
+ while (isspace (*tmp))
+ tmp++;
+ start = parse_and_eval_address (args);
+ stop = parse_and_eval_address (tmp);
+ }
+ else
+ { /* no explicit end address? */
+ start = parse_and_eval_address (args);
+ stop = start + 1; /* ??? */
+ }
+
+ sprintf (target_buf, "QTFrame:outside:%x:%x", start, stop);
+#if 0
+ putpkt (target_buf);
+ tmp = remote_get_noisy_reply (target_buf);
+
+ finish_tfind_command (tmp, from_tty);
+#else
+ finish_tfind_command (target_buf, from_tty);
+#endif
+ }
else
- printf_filtered ("Displaying trace.\n");
+ error ("Trace can only be run on remote targets.");
}
+/* save-tracepoints command */
static void
tracepoint_save_command (args, from_tty)
char *args;
indent = i1;
for (line = tp->actions; line; line = line->next)
{
+ struct cmd_list_element *cmd;
+
actionline = line->action;
while (isspace(*actionline))
actionline++;
fprintf (fp, "%s%s\n", indent, actionline);
- if (0 == strncasecmp (actionline, "while-stepping", 14))
- indent = i2;
- else if (0 == strncasecmp (actionline, "end", 3))
- indent = i1;
+ if (*actionline != '#') /* skip for comment lines */
+ {
+ cmd = lookup_cmd (&actionline, cmdlist, "", -1, 1);
+ if (cmd == 0)
+ error ("Bad action list item: %s", actionline);
+ if (cmd->function.cfunc == while_stepping_pseudocommand)
+ indent = i2;
+ else if (cmd->function.cfunc == end_actions_pseudocommand)
+ indent = i1;
+ }
}
}
}
return;
}
+/* info scope command: list the locals for a scope. */
static void
scope_info (args, from_tty)
char *args;
struct symtab_and_line sal;
struct symtabs_and_lines sals;
struct symbol *sym;
+ struct minimal_symbol *msym;
struct block *block;
- char **canonical, *save_args = args, *symname;
+ char **canonical, *symname, *save_args = args;
int i, nsyms, count = 0;
- enum address_class aclass;
if (args == 0 || *args == 0)
error ("requires an argument (function, line or *addr) to define a scope");
if (sals.nelts == 0)
return; /* presumably decode_line_1 has already warned */
- printf_filtered ("Block for %s", save_args);
- /* Resolve all line numbers to PC's */
- for (i = 0; i < sals.nelts; i++)
- resolve_sal_pc (&sals.sals[i]);
-
+ /* Resolve line numbers to PC */
+ resolve_sal_pc (&sals.sals[0]);
block = block_for_pc (sals.sals[0].pc);
+
while (block != 0)
{
nsyms = BLOCK_NSYMS (block);
for (i = 0; i < nsyms; i++)
{
+ if (count == 0)
+ printf_filtered ("Scope for %s:\n", save_args);
count++;
sym = BLOCK_SYM (block, i);
+ symname = SYMBOL_NAME (sym);
+ if (symname == NULL || *symname == '\0')
+ continue; /* probably botched, certainly useless */
+
+ printf_filtered ("Symbol %s is ", symname);
switch (SYMBOL_CLASS (sym)) {
default:
case LOC_UNDEF: /* messed up symbol? */
- symname = SYMBOL_NAME (sym);
- if (symname && *symname) /* guard against messed up name */
- printf_filtered ("Bogus symbol %s, class %d\n",
- symname, SYMBOL_CLASS (sym));
- else
- printf_filtered ("Completely bogus symbol, class %d.\n",
- SYMBOL_CLASS (sym));
+ printf_filtered ("a bogus symbol, class %d.\n",
+ SYMBOL_CLASS (sym));
count--; /* don't count this one */
continue;
- case LOC_CONST: printf_filtered ("\nConstant "); break;
- case LOC_STATIC: printf_filtered ("\nStatic "); break;
- case LOC_REGISTER: printf_filtered ("\nRegister "); break;
- case LOC_ARG: printf_filtered ("\nArg "); break;
- case LOC_REF_ARG: printf_filtered ("\nReference Arg "); break;
- case LOC_REGPARM: printf_filtered ("\nRegister Arg "); break;
+ case LOC_CONST:
+ printf_filtered ("a constant with value %d (0x%x)",
+ SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
+ break;
+ case LOC_CONST_BYTES:
+ printf_filtered ("constant bytes: ");
+ if (SYMBOL_TYPE (sym))
+ for (i = 0; i < TYPE_LENGTH (SYMBOL_TYPE (sym)); i++)
+ fprintf_filtered (gdb_stdout, " %02x",
+ (unsigned) SYMBOL_VALUE_BYTES (sym) [i]);
+ break;
+ case LOC_STATIC:
+ printf_filtered ("in static storage at address ");
+ print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
+ break;
+ case LOC_REGISTER:
+ printf_filtered ("a local variable in register $%s",
+ reg_names [SYMBOL_VALUE (sym)]);
+ break;
+ case LOC_ARG:
+ case LOC_LOCAL_ARG:
+ printf_filtered ("an argument at stack/frame offset %ld",
+ SYMBOL_VALUE (sym));
+ break;
+ case LOC_LOCAL:
+ printf_filtered ("a local variable at frame offset %ld",
+ SYMBOL_VALUE (sym));
+ break;
+ case LOC_REF_ARG:
+ printf_filtered ("a reference argument at offset %ld",
+ SYMBOL_VALUE (sym));
+ break;
+ case LOC_REGPARM:
+ printf_filtered ("an argument in register $%s",
+ reg_names[SYMBOL_VALUE (sym)]);
+ break;
case LOC_REGPARM_ADDR:
- printf_filtered ("\nIndirect Register Arg "); break;
- case LOC_LOCAL: printf_filtered ("\nStack Local "); break;
- case LOC_TYPEDEF: printf_filtered ("\nLocal Typedef "); break;
- case LOC_LABEL: printf_filtered ("\nLocal Label "); break;
- case LOC_BLOCK: printf_filtered ("\nLocal Function "); break;
- case LOC_CONST_BYTES: printf_filtered ("\nLoc. Byte Seq. "); break;
- case LOC_LOCAL_ARG: printf_filtered ("\nStack Arg "); break;
- case LOC_BASEREG: printf_filtered ("\nBasereg Local "); break;
- case LOC_BASEREG_ARG: printf_filtered ("\nBasereg Arg "); break;
+ printf_filtered ("the address of an argument, in register $%s",
+ reg_names[SYMBOL_VALUE (sym)]);
+ break;
+ case LOC_TYPEDEF:
+ printf_filtered ("a typedef.\n");
+ continue;
+ case LOC_LABEL:
+ printf_filtered ("a label at address ");
+ print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
+ break;
+ case LOC_BLOCK:
+ printf_filtered ("a function at address ");
+ print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)), 1,
+ gdb_stdout);
+ break;
+ case LOC_BASEREG:
+ printf_filtered ("a variable at offset %d from register $%s",
+ SYMBOL_VALUE (sym),
+ reg_names [SYMBOL_BASEREG (sym)]);
+ break;
+ case LOC_BASEREG_ARG:
+ printf_filtered ("an argument at offset %d from register $%s",
+ SYMBOL_VALUE (sym),
+ reg_names [SYMBOL_BASEREG (sym)]);
+ break;
case LOC_UNRESOLVED:
- printf_filtered ("\nUnresolved Static "); break;
- case LOC_OPTIMIZED_OUT: printf_filtered ("\nOptimized-Out "); break;
+ msym = lookup_minimal_symbol (SYMBOL_NAME (sym), NULL, NULL);
+ if (msym == NULL)
+ printf_filtered ("Unresolved Static");
+ else
+ {
+ printf_filtered ("static storage at address ");
+ print_address_numeric (SYMBOL_VALUE_ADDRESS (msym), 1,
+ gdb_stdout);
+ }
+ break;
+ case LOC_OPTIMIZED_OUT:
+ printf_filtered ("optimized out.\n");
+ continue;
}
- type_print (SYMBOL_TYPE (sym), SYMBOL_NAME (sym), gdb_stdout, -1);
+ if (SYMBOL_TYPE (sym))
+ printf_filtered (", length %d.\n",
+ TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
}
if (BLOCK_FUNCTION (block))
break;
block = BLOCK_SUPERBLOCK (block);
}
if (count <= 0)
- printf_filtered (" contains no locals or arguments.");
- printf_filtered ("\n");
+ printf_filtered ("Scope for %s contains no locals or arguments.\n",
+ save_args);
}
-static struct cmd_list_element *tfindlist;
-static struct cmd_list_element *tracelist;
+/* worker function (cleanup) */
+static void
+replace_comma (comma)
+ char *comma;
+{
+ *comma = ',';
+}
+
+/* tdump command */
+static void
+trace_dump_command (args, from_tty)
+ char *args;
+ int from_tty;
+{
+ struct tracepoint *t;
+ struct action_line *action;
+ char *action_exp, *next_comma;
+ struct cleanup *old_cleanups;
+ int stepping_actions = 0;
+ int stepping_frame = 0;
+
+ if (tracepoint_number == -1)
+ {
+ warning ("No current trace frame.");
+ return;
+ }
+
+ ALL_TRACEPOINTS (t)
+ if (t->number == tracepoint_number)
+ break;
+
+ if (t == NULL)
+ error ("No known tracepoint matches 'current' tracepoint #%d.",
+ tracepoint_number);
+
+ old_cleanups = make_cleanup (null_cleanup, NULL);
+
+ printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
+ tracepoint_number, traceframe_number);
+
+ /* 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. */
+
+ stepping_frame = (t->address != read_pc());
+
+ for (action = t->actions; action; action = action->next)
+ {
+ struct cmd_list_element *cmd;
+
+ action_exp = action->action;
+ while (isspace (*action_exp))
+ action_exp++;
+
+ /* The collection actions to be done while stepping are
+ bracketed by the commands "while-stepping" and "end". */
+
+ if (*action_exp == '#') /* comment line */
+ continue;
+
+ cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
+ if (cmd == 0)
+ error ("Bad action list item: %s", action_exp);
+
+ if (cmd->function.cfunc == while_stepping_pseudocommand)
+ stepping_actions = 1;
+ else if (cmd->function.cfunc == end_actions_pseudocommand)
+ stepping_actions = 0;
+ else if (cmd->function.cfunc == collect_pseudocommand)
+ {
+ /* Display the collected data.
+ For the trap frame, display only what was collected at the trap.
+ Likewise for stepping frames, display only what was collected
+ while stepping. This means that the two boolean variables,
+ STEPPING_FRAME and STEPPING_ACTIONS should be equal. */
+ if (stepping_frame == stepping_actions)
+ {
+ do { /* repeat over a comma-separated list */
+ QUIT;
+ if (*action_exp == ',')
+ action_exp++;
+ while (isspace (*action_exp))
+ action_exp++;
+
+ next_comma = strchr (action_exp, ',');
+
+ if (0 == strncasecmp (action_exp, "$reg", 4))
+ registers_info (NULL, from_tty);
+ else if (0 == strncasecmp (action_exp, "$loc", 4))
+ locals_info (NULL, from_tty);
+ else if (0 == strncasecmp (action_exp, "$arg", 4))
+ args_info (NULL, from_tty);
+ else if (action_exp[0] == '$' && action_exp[1] == '(')
+ { /* memrange */
+ long typecode, size;
+ bfd_signed_vma offset;
+ char fmt[40];
+
+ action_exp = parse_and_eval_memrange (action_exp,
+ read_pc (),
+ &typecode,
+ &offset,
+ &size);
+ if (typecode != 0 && typecode != -1)
+ offset += read_register (typecode);
+ sprintf (fmt, "/%dxb 0x%x", size, offset);
+ x_command (fmt, from_tty);
+ next_comma = strchr (action_exp, ',');
+ }
+ else
+ { /* variable */
+ if (next_comma)
+ {
+ make_cleanup (replace_comma, next_comma);
+ *next_comma = '\0';
+ }
+ printf_filtered ("%s = ", action_exp);
+ output_command (action_exp, from_tty);
+ printf_filtered ("\n");
+ }
+ if (next_comma)
+ *next_comma = ',';
+ action_exp = next_comma;
+ } while (action_exp && *action_exp == ',');
+ }
+ }
+ }
+ discard_cleanups (old_cleanups);
+}
+/* module initialization */
void
_initialize_tracepoint ()
{
tracepoint_chain = 0;
tracepoint_count = 0;
- traceframe_number = 0;
+ traceframe_number = -1;
+ tracepoint_number = -1;
set_internalvar (lookup_internalvar ("tpnum"),
value_from_longest (builtin_type_int, (LONGEST) 0));
if (tracepoint_list.list == NULL)
{
tracepoint_list.listsize = 128;
- tracepoint_list.list = xmalloc
+ tracepoint_list.list = (struct memrange *) xmalloc
(tracepoint_list.listsize * sizeof (struct memrange));
}
if (stepping_list.list == NULL)
{
stepping_list.listsize = 128;
- stepping_list.list = xmalloc
+ stepping_list.list = (struct memrange *) xmalloc
(stepping_list.listsize * sizeof (struct memrange));
}
add_info ("scope", scope_info,
"List the variables local to a scope");
-#if 1
add_cmd ("tracepoints", class_trace, NO_FUNCTION,
- "Tracing program execution without stopping the program.",
+ "Tracing of program execution without stopping the program.",
&cmdlist);
add_info ("tracepoints", tracepoints_info,
- "Display tracepoints, or tracepoint number NUMBER.\n"
- "Convenience variable \"$tpnum\" contains the number of the\n"
- "last tracepoint set.");
+ "Status of tracepoints, or tracepoint number NUMBER.\n\
+Convenience variable \"$tpnum\" contains the number of the\n\
+last tracepoint set.");
add_info_alias ("tp", "tracepoints", 1);
add_com ("save-tracepoints", class_trace, tracepoint_save_command,
- "Save current tracepoint definitions as a script.\n"
- "Use the SOURCE command in another debug session to restore them.");
-
- add_com ("tlimit", class_trace, trace_limit_command,
- "Not sure what this should do yet....");
+ "Save current tracepoint definitions as a script.\n\
+Use the 'source' command in another debug session to restore them.");
- add_com ("tbuffer", class_trace, trace_buff_command,
- "See also 'set trace buffer overflow'.");
+ add_com ("tdump", class_trace, trace_dump_command,
+ "Print everything collected at the current tracepoint.");
- add_prefix_cmd ("tfind", class_trace,
- trace_find_command,
- "Select a trace frame (default by frame number).",
+ add_prefix_cmd ("tfind", class_trace, trace_find_command,
+ "Select a trace frame;\n\
+No argument means forward by one frame; '-' meand backward by one frame.",
&tfindlist, "tfind ", 1, &cmdlist);
add_cmd ("outside", class_trace, trace_find_outside_command,
- "Select a trace frame by falling outside of a PC range",
+ "Select a trace frame whose PC is outside the given \
+range.\nUsage: tfind outside addr1, addr2",
&tfindlist);
add_cmd ("range", class_trace, trace_find_range_command,
- "Select a trace frame by PC range", &tfindlist);
+ "Select a trace frame whose PC is in the given range.\n\
+Usage: tfind range addr1,addr2",
+ &tfindlist);
- add_cmd ("tdp", class_trace, trace_find_tdp_command,
- "Select a trace frame by TDP", &tfindlist);
+ add_cmd ("line", class_trace, trace_find_line_command,
+ "Select a trace frame by source line.\n\
+Argument can be a line number (with optional source file), \n\
+a function name, or '*' followed by an address.\n\
+Default argument is 'the next source line that was traced'.",
+ &tfindlist);
+
+ add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command,
+ "Select a trace frame by tracepoint number.\n\
+Default is the tracepoint for the current trace frame.",
+ &tfindlist);
add_cmd ("pc", class_trace, trace_find_pc_command,
- "Select a trace frame by PC", &tfindlist);
+ "Select a trace frame by PC.\n\
+Default is the current PC, or the PC of the current trace frame.",
+ &tfindlist);
- add_com ("tdisplay", class_trace, trace_display_command,
- "Display the results of a trace");
+ add_cmd ("end", class_trace, trace_find_end_command,
+ "Synonym for 'none'.\n\
+De-select any trace frame and resume 'live' debugging.",
+ &tfindlist);
+
+ add_cmd ("none", class_trace, trace_find_none_command,
+ "De-select any trace frame and resume 'live' debugging.",
+ &tfindlist);
+
+ add_cmd ("start", class_trace, trace_find_start_command,
+ "Select the first trace frame in the trace buffer.",
+ &tfindlist);
add_com ("tstatus", class_trace, trace_status_command,
- "Inquire about trace data collection status.");
+ "Display the status of the current trace data collection.");
add_com ("tstop", class_trace, trace_stop_command,
"Stop trace data collection.");
"Start trace data collection.");
add_com ("passcount", class_trace, trace_pass_command,
- "Set the passcount for a tracepoint.\n"
- "The trace will end when the tracepoint has been passed "
- "'count' times.\n"
- "Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\",\n"
- "or if omitted refers to the last tracepoint defined.");
+ "Set the passcount for a tracepoint.\n\
+The trace will end when the tracepoint has been passed 'count' times.\n\
+Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
+if TPNUM is omitted, passcount refers to the last tracepoint defined.");
+
+ add_com ("end", class_trace, end_actions_pseudocommand,
+ "Ends a list of commands or actions.\n\
+Several GDB commands allow you to enter a list of commands or actions.\n\
+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,
+ "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\
+one or more \"collect\" commands, to specify what to collect\n\
+while single-stepping.\n\n\
+Note: this command can only be used in a tracepoint \"actions\" list.");
+
+ add_com_alias ("ws", "while-stepping", class_alias, 0);
+ add_com_alias ("stepping", "while-stepping", class_alias, 0);
+
+ add_com ("collect", class_trace, collect_pseudocommand,
+ "Specify one or more data items to be collected at a tracepoint.\n\
+Accepts a comma-separated list of (one or more) arguments.\n\
+Things that may be collected include registers, variables, plus\n\
+the following special arguments:\n\
+ $regs -- all registers.\n\
+ $args -- all function arguments.\n\
+ $locals -- all variables local to the block/function scope.\n\
+ $(addr,len) -- a literal memory range.\n\
+ $($reg,addr,len) -- a register-relative literal memory range.\n\n\
+Note: this command can only be used in a tracepoint \"actions\" list.");
add_com ("actions", class_trace, trace_actions_command,
- "Specify the actions to be taken at a tracepoint.\n"
- "Actions can include collection of data, enabling or \n"
- "disabling other tracepoints, or ending the trace.");
+ "Specify the actions to be taken at a tracepoint.\n\
+Tracepoint actions may include collecting of specified data, \n\
+single-stepping, or enabling/disabling other tracepoints, \n\
+depending on target's capabilities.");
add_cmd ("tracepoints", class_trace, delete_trace_command,
- "Delete specified tracepoints; or with no argument, delete all.",
+ "Delete specified tracepoints.\n\
+Arguments are tracepoint numbers, separated by spaces.\n\
+No argument means delete all tracepoints.",
&deletelist);
add_cmd ("tracepoints", class_trace, disable_trace_command,
- "Disable specified tracepoints; or with no argument, disable all.",
+ "Disable specified tracepoints.\n\
+Arguments are tracepoint numbers, separated by spaces.\n\
+No argument means disable all tracepoints.",
&disablelist);
add_cmd ("tracepoints", class_trace, enable_trace_command,
- "Enable specified tracepoints; or with no argument, enable all.",
+ "Enable specified tracepoints.\n\
+Arguments are tracepoint numbers, separated by spaces.\n\
+No argument means enable all tracepoints.",
&enablelist);
add_com ("trace", class_trace, trace_command,
- "Set a tracepoint at a specified line, function, or address.\n"
- "Argument may be a line number, function name, or "
- "'*' plus an address.\n"
- "For a line number or function, trace at the start of its code.\n"
- "If an address is specified, trace at that exact address.");
+ "Set a tracepoint at a specified line or function or address.\n\
+Argument may be a line number, function name, or '*' plus an address.\n\
+For a line number or function, trace at the start of its code.\n\
+If an address is specified, trace at that exact address.\n\n\
+Do \"help tracepoints\" for info on other tracepoint commands.");
add_com_alias ("tp", "trace", class_alias, 0);
add_com_alias ("tr", "trace", class_alias, 1);
add_com_alias ("tra", "trace", class_alias, 1);
add_com_alias ("trac", "trace", class_alias, 1);
-
-
-#else /* command set based on TRACE as a prefix (incomplete) */
- add_cmd ("tracepoints", class_trace, NO_FUNCTION,
- "Tracing program execution without stopping the program.",
- &cmdlist);
-
- add_prefix_cmd ("trace", class_trace, trace_command,
- "prefix for tracing commands",
- &tracelist, "trace ", 1, &cmdlist);
-
- add_cmd ("limit", class_trace, trace_limit_command,
- "Not sure what the hell this does....", &tracelist);
-
- add_cmd ("buffer", class_trace, trace_buff_command,
- "See also 'set trace buffer overflow'.", &tracelist);
-
- add_prefix_cmd ("find", class_trace, trace_find_command,
- "Select a trace frame (default by frame number).",
- &tfindlist, "trace find ", 1, &tracelist);
-
- add_cmd ("outside", class_trace, trace_find_outside_command,
- "Select a tracepoint by falling outside of a PC range.",
- &tfindlist);
-
- add_cmd ("range", class_trace, trace_find_range_command,
- "Select a tracepoint by PC range.",
- &tfindlist);
-
- add_cmd ("pc", class_trace, trace_find_pc_command,
- "Select a tracepoint by PC.",
- &tfindlist);
-
- add_cmd ("display", class_trace, trace_display_command,
- "Display the results of a trace.", &tracelist);
-
- add_cmd ("delete", class_trace, delete_trace_command,
- "Delete some tracepoints; no argument means all.", &tracelist);
-
- add_cmd ("disable", class_trace, disable_trace_command,
- "Disable some tracepoints; no argument means all.", &tracelist);
-
- add_cmd ("enable", class_trace, enable_trace_command,
- "Enable some tracepoints; no argument means all.", &tracelist);
-
- add_cmd ("tracepoints", class_trace, delete_trace_command,
- "Delete some tracepoints; no argument means all.",
- &deletelist);
-
- add_cmd ("tracepoints", class_trace, disable_trace_command,
- "Disable some tracepoints; no argument means all.",
- &disablelist);
-
- add_cmd ("tracepoints", class_trace, enable_trace_command,
- "Enable some tracepoints; no argument means all.",
- &enablelist);
-
- add_cmd ("at", class_trace, trace_command,
- "Set a tracepoint at a specified line or function.\n"
- "Argument may be a line number, function name, or "
- "'*' and an address.\n"
- "For a line number or function, trace from the start of "
- "its code.\n"
- "If an address is specified, trace at that exact address.\n"
- "With no arg, uses current execution address of "
- "selected stack frame.\n"
- "This is useful for breaking on return to a stack frame.",
- &tracelist);
-
- add_cmd ("status", class_trace, trace_status_command,
- "Inquire about trace data collection status.", &tracelist);
-
- add_cmd ("stop", class_trace, trace_stop_command,
- "Stop trace data collection.", &tracelist);
-
- add_cmd ("start", class_trace, trace_start_command,
- "Start trace data collection.", &tracelist);
-
- add_cmd ("info", class_info, tracepoints_info,
- "Status of tracepoints, or tracepoint number NUMBER.\n"
- "The \"Address\" and \"What\" columns indicate the\n"
- "address and file/line number respectively.\n\n"
- "Convenience variable \"$tpnum\" contains the number of the\n"
- "last tracepoint set.",
- &tracelist);
-
- add_info ("tracepoints", tracepoints_info,
- "Status of tracepoints, or tracepoint number NUMBER.\n"
- "The \"Address\" and \"What\" columns indicate the\n"
- "address and file/line number respectively.\n\n"
- "Convenience variable \"$tpnum\" contains the number of the\n"
- "last tracepoint set.");
-
- add_info_alias ("tp", "tracepoints", 1);
-
-#endif
}
+