/* Tracing functionality for remote targets in custom GDB protocol
- Copyright 1997 Free Software Foundation, Inc.
+ Copyright 1997, 1998 Free Software Foundation, Inc.
This file is part of GDB.
#include "language.h"
#include "gdb_string.h"
+#include "ax.h"
+#include "ax-gdb.h"
+
/* readline include files */
-#include "readline.h"
-#include "history.h"
+#include <readline/readline.h>
+#include <readline/history.h>
/* readline defines this. */
#undef savestring
#include <unistd.h>
#endif
+/* maximum length of an agent aexpression.
+ this accounts for the fact that packets are limited to 400 bytes
+ (which includes everything -- including the checksum), and assumes
+ the worst case of maximum length for each of the pieces of a
+ continuation packet.
+
+ NOTE: expressions get mem2hex'ed otherwise this would be twice as
+ large. (400 - 31)/2 == 184 */
+#define MAX_AGENT_EXPR_LEN 184
+
+
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));
+extern int addressprint; /* Print machine addresses? */
/* 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;
/* 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));
+
+/* support routines */
+static void trace_mention PARAMS ((struct tracepoint *));
+
+struct collection_list;
+static void add_aexpr PARAMS ((struct collection_list *, struct agent_expr *));
+static unsigned char *mem2hex(unsigned char *, unsigned char *, int);
+
/* Utility: returns true if "target remote" */
static int
target_is_remote ()
}
}
-/* 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 char *
remote_get_noisy_reply (buf)
{
do /* loop on reply from remote stub */
{
+ QUIT; /* allow user to bail out with ^C */
getpkt (buf, 0);
if (buf[0] == 0)
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 */
if (sal.symtab == NULL)
t->source_file = NULL;
else
- {
- char *p;
+ t->source_file = savestring (sal.symtab->filename,
+ strlen (sal.symtab->filename));
- t->source_file = (char *) xmalloc (strlen (sal.symtab->filename) +
- strlen (sal.symtab->dirname) + 2);
-
- strcpy (t->source_file, sal.symtab->dirname);
- p = t->source_file;
- while (*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->section = sal.section;
+ 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)
if (from_tty && info_verbose)
printf_filtered ("TRACE %s\n", arg);
- if (arg[0] == '/')
- {
- return;
- }
-
addr_start = arg;
sals = decode_line_1 (&arg, 1, (struct symtab *)NULL, 0, &canonical);
addr_end = arg;
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);
+
+ trace_mention (t);
/* Let the UI know of any additions */
if (create_tracepoint_hook)
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");
}
}
+/* Tell the user we have just set a tracepoint TP. */
+
+static void
+trace_mention (tp)
+ struct tracepoint *tp;
+{
+ printf_filtered ("Tracepoint %d", tp->number);
+
+ if (addressprint || (tp->source_file == NULL))
+ {
+ printf_filtered (" at ");
+ print_address_numeric (tp->address, 1, gdb_stdout);
+ }
+ if (tp->source_file)
+ printf_filtered (": file %s, line %d.",
+ tp->source_file, tp->line_number);
+
+ printf_filtered ("\n");
+}
+
+/* Print information on tracepoint number TPNUM_EXP, or all if omitted. */
+
static void
tracepoints_info (tpnum_exp, from_tty)
char *tpnum_exp;
char wrap_indent[80];
struct symbol *sym;
int tpnum = -1;
-#if 0
- char *i1 = "\t", *i2 = "\t ";
- char *indent, *actionline;;
-#endif
if (tpnum_exp)
tpnum = parse_and_eval_address (tpnum_exp);
t->enabled == enabled ? "y" : "n");
if (addressprint)
printf_filtered ("%s ",
- local_hex_string_custom ((unsigned long) t->address,
+ 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);
+ sym = find_pc_sect_function (t->address, t->section);
if (sym)
{
fputs_filtered ("in ", gdb_stdout);
if (t->actions)
{
printf_filtered (" Actions for tracepoint %d: \n", t->number);
-/* indent = i1; */
for (action = t->actions; action; action = action->next)
{
-#if 0
- actionline = action->action;
- while (isspace(*actionline))
- actionline++;
-
- printf_filtered ("%s%s\n", indent, actionline);
- if (0 == strncasecmp (actionline, "while-stepping", 14))
- indent = i2;
- else if (0 == strncasecmp (actionline, "end", 3))
- indent = i1;
-#else
printf_filtered ("\t%s\n", action->action);
-#endif
}
}
}
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;
}
}
else /* handle tracepoint number */
{
- tpnum = strtol (*arg, arg, 10);
+ tpnum = strtol (*arg, arg, 0);
+ if (tpnum == 0) /* possible strtol failure */
+ while (**arg && !isspace (**arg))
+ (*arg)++; /* advance to next white space, if any */
}
ALL_TRACEPOINTS (t)
if (t->number == tpnum)
{
return t;
}
- warning ("No tracepoint number %d.\n", tpnum);
+ printf_unfiltered ("No tracepoint number %d.\n", tpnum);
return NULL;
}
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)
{
+ QUIT; /* give user option to bail out with ^C */
if (t = get_tracepoint_by_number (&args))
tracepoint_operation (t, from_tty, opcode);
while (*args == ' ' || *args == '\t')
}
}
+/* 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;
int from_tty;
{
dont_repeat ();
- if (!args || !*args)
- if (!query ("Delete all tracepoints? "))
- return;
+ if (!args || !*args) /* No args implies all tracepoints; */
+ if (from_tty) /* confirm only if from_tty... */
+ if (tracepoint_chain) /* and if there are tracepoints to delete! */
+ if (!query ("Delete all tracepoints? "))
+ return;
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;
else
t1 = get_tracepoint_by_number (&args);
+ if (*args)
+ error ("Junk at end of arguments.");
+
if (t1 == NULL)
return; /* error, bad tracepoint number */
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 */
-
-static void read_actions PARAMS((struct tracepoint *));
-static void free_actions PARAMS((struct tracepoint *));
-static int validate_actionline PARAMS((char *, struct tracepoint *));
+/* 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
-end_pseudocom (args, from_tty)
+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_pseudocom (args, from_tty)
+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_pseudocom (args, from_tty)
+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);
+ t->step_count = 0; /* read_actions may set this */
read_actions (t);
+
+ if (readline_end_hook)
+ (*readline_end_hook) ();
+
/* tracepoints_changed () */
}
/* else error, just return; */
}
-enum actionline_type
-{
- BADLINE = -1,
- GENERIC = 0,
- END = 1,
- STEPPING = 2,
-};
-
+/* worker function */
static void
read_actions (t)
struct tracepoint *t;
if (job_control)
signal (STOP_SIGNAL, stop_sig);
#endif
- old_chain = make_cleanup (free_actions, (void *) t);
+ old_chain = make_cleanup ((make_cleanup_func) free_actions, (void *) t);
while (1)
{
/* Make sure that all output has been output. Some machines may let
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 */
prompt = prompt2; /* change prompt for stepping actions */
else if (linetype == END)
if (prompt == prompt2)
- prompt = prompt1; /* end of single-stepping actions */
+ {
+ prompt = prompt1; /* end of single-stepping actions */
+ }
else
- break; /* end of actions */
+ { /* end of actions */
+ if (t->actions->next == NULL)
+ {
+ /* an "end" all by itself with no other actions means
+ this tracepoint has no actions. Discard empty list. */
+ free_actions (t);
+ }
+ break;
+ }
}
#ifdef STOP_SIGNAL
if (job_control)
discard_cleanups (old_chain);
}
-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;
-
- if (*arg++ != '$' || *arg++ != '(')
- error ("Internal: bad argument to validate_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 = 0;
-
-#if 0
- /* While attractive, this fails for a number of reasons:
- 1) parse_and_eval_address does not deal with trailing commas,
- close-parens etc.
- 2) There is no safeguard against the user trying to use
- an out-of-scope variable in an address expression (for instance).
- 2.5) If you are going to allow semi-arbitrary expressions, you
- would need to explain which expressions are allowed, and
- which are not (which would provoke endless questions).
- 3) If you are going to allow semi-arbitrary expressions in the
- offset and size fields, then the leading "$" of a register
- name no longer disambiguates the typecode field.
- */
-
- *offset = parse_and_eval_address (arg);
- if ((arg = strchr (arg, ',')) == NULL)
- error ("missing comma for memrange: %s", start);
- else
- arg++;
-
- *size = parse_and_eval_address (arg);
- if ((arg = strchr (arg, ')')) == NULL)
- error ("missing close-parenthesis for memrange: %s", start);
- else
- arg++;
-#else
-#if 0
- /* This, on the other hand, doesn't work because "-1" is an
- expression, not an OP_LONG! Fall back to using strtol for now. */
-
- exp = parse_exp_1 (&arg, block_for_pc (addr), 1);
- if (exp->elts[0].opcode != OP_LONG)
- error ("Bad offset operand for memrange: %s", start);
- *offset = exp->elts[2].longconst;
-
- if (*arg++ != ',')
- error ("missing comma for memrange: %s", start);
-
- exp = parse_exp_1 (&arg, block_for_pc (addr), 1);
- if (exp->elts[0].opcode != OP_LONG)
- error ("Bad size operand for memrange: %s", start);
- *size = exp->elts[2].longconst;
-
- if (*size <= 0)
- error ("invalid size in memrange: %s", start);
-
- if (*arg++ != ')')
- error ("missing close-parenthesis for memrange: %s", start);
-#else
- *offset = strtol (arg, &arg, 0);
- if (*arg++ != ',')
- error ("missing comma for memrange: %s", start);
- *size = strtol (arg, &arg, 0);
- if (*size <= 0)
- error ("invalid size in memrange: %s", start);
- if (*arg++ != ')')
- error ("missing close-parenthesis for memrange: %s", start);
-#endif
-#endif
- if (info_verbose)
- printf_filtered ("Collecting memrange: (0x%x,0x%x,0x%x)\n",
- *typecode, *offset, *size);
-
- return arg;
-}
-
-static enum actionline_type
+/* worker function */
+enum actionline_type
validate_actionline (line, t)
- char *line;
+ char **line;
struct tracepoint *t;
{
- char *p;
- struct expression *exp;
+ struct cmd_list_element *c;
+ struct expression *exp = NULL;
value_ptr temp, temp2;
+ struct cleanup *old_chain = NULL;
+ 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;
+ struct agent_expr *aexpr;
+ struct agent_reqs areqs;
+
do { /* repeat over a comma-separated list */
+ QUIT; /* allow user to bail out with ^C */
while (isspace (*p))
p++;
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 */
- p = parse_and_eval_memrange (p, t->address,
- &typecode, &offset, &size);
- }
- else
- {
- exp = parse_exp_1 (&p, block_for_pc (t->address), 1);
-
- if (exp->elts[0].opcode != OP_VAR_VALUE &&
- /*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");
- return BADLINE;
+ p = strchr (p, ',');
+ continue;
}
- if (exp->elts[0].opcode == OP_VAR_VALUE)
- if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
- {
- warning ("%s is constant (value %d): will not be collected.",
- SYMBOL_NAME (exp->elts[2].symbol),
- SYMBOL_VALUE (exp->elts[2].symbol));
- return BADLINE;
- }
- else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT)
- {
- warning ("%s is optimized away and cannot be collected.",
- SYMBOL_NAME (exp->elts[2].symbol));
- return BADLINE;
- }
+ /* else fall thru, treat p as an expression and parse it! */
}
+ exp = parse_exp_1 (&p, block_for_pc (t->address), 1);
+ old_chain = make_cleanup ((make_cleanup_func) free_current_contents,
+ &exp);
+
+ if (exp->elts[0].opcode == OP_VAR_VALUE)
+ if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
+ {
+ warning ("%s is constant (value %d): will not be collected.",
+ SYMBOL_NAME (exp->elts[2].symbol),
+ SYMBOL_VALUE (exp->elts[2].symbol));
+ return BADLINE;
+ }
+ else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT)
+ {
+ warning ("%s is optimized away and cannot be collected.",
+ SYMBOL_NAME (exp->elts[2].symbol));
+ return BADLINE;
+ }
+
+ /* we have something to collect, make sure that the expr to
+ bytecode translator can handle it and that it's not too long */
+ aexpr = gen_trace_for_expr (t->address, exp);
+ (void) make_cleanup ((make_cleanup_func) free_agent_expr, aexpr);
+
+ if (aexpr->len > MAX_AGENT_EXPR_LEN)
+ error ("expression too complicated, try simplifying");
+
+ ax_reqs(aexpr, &areqs);
+ (void) make_cleanup (free, areqs.reg_mask);
+
+ if (areqs.flaw != agent_flaw_none)
+ error ("malformed expression");
+
+ if (areqs.min_height < 0)
+ error ("gdb: Internal error: expression has min height < 0");
+
+ if (areqs.max_height > 20)
+ error ("expression too complicated, try simplifying");
+
+ do_cleanups (old_chain);
} 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;
- if (*p)
+ if (*p == '\0' ||
+ (t->step_count = strtol (p, &p, 0)) == 0)
{
- t->step_count = strtol (p, &p, 0);
- if (t->step_count == 0)
- {
- warning ("'%s' evaluates to zero -- command ignored.");
- return BADLINE;
- }
+ warning ("bad step-count: command ignored.", *line);
+ return BADLINE;
}
- else
- 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;
long listsize;
long next_memrange;
struct memrange *list;
+ long aexpr_listsize; /* size of array pointed to by expr_list elt */
+ long next_aexpr_elt;
+ struct agent_expr **aexpr_list;
+
} tracepoint_list, stepping_list;
+/* MEMRANGE functions: */
+
+static int memrange_cmp PARAMS ((const void *, const void *));
+
+/* compare memranges for qsort */
static int
-memrange_cmp (a, b)
- struct memrange *a, *b;
+memrange_cmp (va, vb)
+ const void *va;
+ const void *vb;
{
- if (a->type < b->type) return -1;
- if (a->type > b->type) return 1;
+ const struct memrange *a = va, *b = vb;
+
+ if (a->type < b->type)
+ return -1;
+ if (a->type > b->type)
+ return 1;
if (a->type == 0)
{
if ((bfd_vma) a->start < (bfd_vma) b->start) return -1;
}
else
{
- if (a->start < b->start) return -1;
- if (a->start > b->start) return 1;
+ if (a->start < b->start)
+ return -1;
+ if (a->start > b->start)
+ return 1;
}
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;
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)
+collect_symbol (collect, sym, frame_regno, frame_offset)
struct collection_list *collect;
struct symbol *sym;
+ long frame_regno;
+ long frame_offset;
{
unsigned long len;
unsigned long reg;
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:
if (info_verbose)
printf_filtered ("LOC_REG[parm] %s: ", SYMBOL_NAME (sym));
add_register (collect, reg);
+ /* check for doubles stored in two registers */
+ /* FIXME: how about larger types stored in 3 or more regs? */
+ if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
+ len > REGISTER_RAW_SIZE (reg))
+ add_register (collect, reg + 1);
break;
- case LOC_ARG:
case LOC_REF_ARG:
- printf_filtered ("Sorry, don't know how to do LOC_ARGs yet.\n");
+ printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
printf_filtered (" (will not collect %s)\n",
SYMBOL_NAME (sym));
break;
+ case LOC_ARG:
+ reg = frame_regno;
+ offset = frame_offset + SYMBOL_VALUE (sym);
+ if (info_verbose)
+ {
+ printf_filtered ("LOC_LOCAL %s: Collect %d bytes at offset",
+ SYMBOL_NAME (sym), len);
+ printf_filtered (" %d from frame ptr reg %d\n", offset, reg);
+ }
+ add_memrange (collect, reg, offset, len);
+ break;
case LOC_REGPARM_ADDR:
reg = SYMBOL_VALUE (sym);
offset = 0;
if (info_verbose)
{
- printf_filtered ("LOC_REGPARM_ADDR %s: Collect %d bytes at offset %d from reg %d\n",
- SYMBOL_NAME (sym), len, offset, reg);
+ printf_filtered ("LOC_REGPARM_ADDR %s: Collect %d bytes at offset",
+ SYMBOL_NAME (sym), len);
+ printf_filtered (" %d from reg %d\n", offset, reg);
}
add_memrange (collect, reg, offset, len);
break;
case LOC_LOCAL:
case LOC_LOCAL_ARG:
- offset = SYMBOL_VALUE (sym);
- reg = FP_REGNUM;
+ reg = frame_regno;
+ offset = frame_offset + SYMBOL_VALUE (sym);
if (info_verbose)
{
- printf_filtered ("LOC_LOCAL %s: Collect %d bytes at offset %d from frame ptr reg %d\n",
- SYMBOL_NAME (sym), len, offset, reg);
+ printf_filtered ("LOC_LOCAL %s: Collect %d bytes at offset",
+ SYMBOL_NAME (sym), len);
+ printf_filtered (" %d from frame ptr reg %d\n", offset, reg);
}
add_memrange (collect, reg, offset, len);
break;
}
}
+/* Add all locals (or args) symbols to collection list */
static void
-add_local_symbols (collect, pc, type)
+add_local_symbols (collect, pc, frame_regno, frame_offset, type)
struct collection_list *collect;
CORE_ADDR pc;
- char type;
+ long frame_regno;
+ long frame_offset;
+ int type;
{
struct symbol *sym;
struct block *block;
block = block_for_pc (pc);
while (block != 0)
{
+ QUIT; /* allow user to bail out with ^C */
nsyms = BLOCK_NSYMS (block);
for (i = 0; i < nsyms; i++)
{
if (type == 'L') /* collecting Locals */
{
count++;
- collect_symbol (collect, sym);
+ collect_symbol (collect, sym, frame_regno, frame_offset);
}
break;
case LOC_ARG:
if (type == 'A') /* collecting Arguments */
{
count++;
- collect_symbol (collect, sym);
+ collect_symbol (collect, sym, frame_regno, frame_offset);
}
}
}
warning ("No %s found in scope.", type == 'L' ? "locals" : "args");
}
+/* worker function */
static void
clear_collection_list (list)
struct collection_list *list;
{
+ int ndx;
+
list->next_memrange = 0;
+ for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
+ {
+ free_agent_expr(list->aexpr_list[ndx]);
+ list->aexpr_list[ndx] = NULL;
+ }
+ list->next_aexpr_elt = 0;
memset (list->regs_mask, 0, sizeof (list->regs_mask));
}
-static char *
+/* reduce a collection list to string form (for gdb protocol) */
+static char **
stringify_collection_list (list, string)
struct collection_list *list;
char *string;
{
- char *end = string;
+ char temp_buf[2048];
+ int count;
+ int ndx = 0;
+ char *(*str_list)[];
+ char *end;
long i;
+ count = 1 + list->next_memrange + list->next_aexpr_elt + 1;
+ str_list = (char *(*)[])xmalloc(count * sizeof (char *));
+
for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
if (list->regs_mask[i] != 0) /* skip leading zeroes in regs_mask */
break;
{
if (info_verbose)
printf_filtered ("\nCollecting registers (mask): 0x");
+ end = temp_buf;
*end++='R';
for (; i >= 0; i--)
{
+ QUIT; /* allow user to bail out with ^C */
if (info_verbose)
printf_filtered ("%02X", list->regs_mask[i]);
sprintf (end, "%02X", list->regs_mask[i]);
end += 2;
}
+ (*str_list)[ndx] = savestring(temp_buf, end - temp_buf);
+ ndx++;
}
if (info_verbose)
printf_filtered ("\n");
if (list->next_memrange > 0 && info_verbose)
printf_filtered ("Collecting memranges: \n");
- for (i = 0; i < list->next_memrange; i++)
+ for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
{
+ QUIT; /* allow user to bail out with ^C */
if (info_verbose)
printf_filtered ("(%d, 0x%x, %d)\n",
list->list[i].type,
list->list[i].start,
list->list[i].end - list->list[i].start);
+ if (count + 27 > MAX_AGENT_EXPR_LEN)
+ {
+ (*str_list)[ndx] = savestring(temp_buf, count);
+ ndx++;
+ count = 0;
+ end = temp_buf;
+ }
sprintf (end, "M%X,%X,%X",
list->list[i].type,
list->list[i].start,
list->list[i].end - list->list[i].start);
+ count += strlen (end);
end += strlen (end);
}
- if (end == string)
+
+ for (i = 0; i < list->next_aexpr_elt; i++)
+ {
+ QUIT; /* allow user to bail out with ^C */
+ if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
+ {
+ (*str_list)[ndx] = savestring(temp_buf, count);
+ ndx++;
+ count = 0;
+ end = temp_buf;
+ }
+ sprintf (end, "X%08X,", list->aexpr_list[i]->len);
+ end += 10; /* 'X' + 8 hex digits + ',' */
+ count += 10;
+
+ end = mem2hex(list->aexpr_list[i]->buf, end, list->aexpr_list[i]->len);
+ count += 2 * list->aexpr_list[i]->len;
+ }
+
+ if (count != 0)
+ {
+ (*str_list)[ndx] = savestring(temp_buf, count);
+ ndx++;
+ count = 0;
+ end = temp_buf;
+ }
+ (*str_list)[ndx] = NULL;
+
+ if (ndx == 0)
return NULL;
else
- return string;
+ return *str_list;
+}
+
+void
+free_actions_list(actions_list)
+ char **actions_list;
+{
+ int ndx;
+
+ if (actions_list == 0)
+ return;
+
+ for (ndx = 0; actions_list[ndx]; ndx++)
+ free(actions_list[ndx]);
+
+ free(actions_list);
}
+/* render all actions into gdb protocol */
static void
-encode_actions (t, tdp_actions, step_count, stepping_actions)
+encode_actions (t, tdp_actions, stepping_actions)
struct tracepoint *t;
- char **tdp_actions;
- unsigned long *step_count;
- char **stepping_actions;
+ char ***tdp_actions;
+ char ***stepping_actions;
{
- struct expression *exp;
static char tdp_buff[2048], step_buff[2048];
- struct action_line *action;
char *action_exp;
+ struct expression *exp = NULL;
+ 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;
+ struct agent_expr *aexpr;
+ long frame_reg, frame_offset;
+
clear_collection_list (&tracepoint_list);
clear_collection_list (&stepping_list);
*tdp_actions = NULL;
*stepping_actions = NULL;
+ TARGET_VIRTUAL_FRAME_POINTER (t->address, &frame_reg, &frame_offset);
+
for (action = t->actions; action; action = action->next)
{
+ QUIT; /* allow user to bail out with ^C */
action_exp = action->action;
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 */
+ QUIT; /* allow user to bail out with ^C */
while (isspace (*action_exp))
action_exp++;
}
else if (0 == strncasecmp ("$arg", action_exp, 4))
{
- add_local_symbols (collect, t->address, 'A');
+ add_local_symbols (collect,
+ t->address,
+ frame_reg,
+ frame_offset,
+ 'A');
action_exp = strchr (action_exp, ','); /* more? */
}
else if (0 == strncasecmp ("$loc", action_exp, 4))
{
- add_local_symbols (collect, t->address, 'L');
+ add_local_symbols (collect,
+ t->address,
+ frame_reg,
+ frame_offset,
+ 'L');
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
{
unsigned long addr, len;
+ struct cleanup *old_chain = NULL;
+ struct cleanup *old_chain1 = NULL;
+ struct agent_reqs areqs;
exp = parse_exp_1 (&action_exp, block_for_pc (t->address), 1);
+ old_chain = make_cleanup ((make_cleanup_func)
+ free_current_contents, &exp);
+
switch (exp->elts[0].opcode) {
case OP_REGISTER:
- i = exp->elts[1].longconst;
+ i = exp->elts[1].longconst;
if (info_verbose)
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);
+ collect_symbol (collect,
+ exp->elts[2].symbol,
+ frame_reg,
+ frame_offset);
break;
-#if 0
- case OP_LONG:
- addr = exp->elts[2].longconst;
- if (*action_exp == ':')
+
+ default: /* full-fledged expression */
+ aexpr = gen_trace_for_expr (t->address, exp);
+
+ old_chain1 = make_cleanup ((make_cleanup_func)
+ free_agent_expr, aexpr);
+
+ ax_reqs (aexpr, &areqs);
+ if (areqs.flaw != agent_flaw_none)
+ error ("malformed expression");
+
+ if (areqs.min_height < 0)
+ error ("gdb: Internal error: expression has min height < 0");
+ if (areqs.max_height > 20)
+ error ("expression too complicated, try simplifying");
+
+ discard_cleanups (old_chain1);
+ add_aexpr (collect, aexpr);
+
+ /* take care of the registers */
+ if (areqs.reg_mask_len > 0)
{
- exp = parse_exp_1 (&action_exp,
- block_for_pc (t->address),
- 1);
- if (exp->elts[0].opcode == OP_LONG)
- len = exp->elts[2].longconst;
- else
- error ("length field requires a literal long const");
+ int ndx1;
+ int ndx2;
+
+ for (ndx1 = 0; ndx1 < areqs.reg_mask_len; ndx1++)
+ {
+ QUIT; /* allow user to bail out with ^C */
+ if (areqs.reg_mask[ndx1] != 0)
+ {
+ /* assume chars have 8 bits */
+ for (ndx2 = 0; ndx2 < 8; ndx2++)
+ if (areqs.reg_mask[ndx1] & (1 << ndx2))
+ /* it's used -- record it */
+ add_register (collect, ndx1 * 8 + ndx2);
+ }
+ }
}
- else
- len = 4;
-
- add_memrange (collect, 0, addr, len);
break;
-#endif
- }
- }
+ } /* switch */
+ do_cleanups (old_chain);
+ } /* do */
} while (action_exp && *action_exp++ == ',');
- }
- else if (0 == strncasecmp (action_exp, "while-stepping", 14))
+ } /* if */
+ 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;
else
break; /* end tracepoint actions */
}
- }
+ } /* for */
memrange_sortmerge (&tracepoint_list);
memrange_sortmerge (&stepping_list);
*stepping_actions = stringify_collection_list (&stepping_list, &step_buff);
}
+static void
+add_aexpr(collect, aexpr)
+ struct collection_list *collect;
+ struct agent_expr *aexpr;
+{
+ if (collect->next_aexpr_elt >= collect->aexpr_listsize)
+ {
+ collect->aexpr_list =
+ xrealloc (collect->aexpr_list,
+ 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
+ collect->aexpr_listsize *= 2;
+ }
+ collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
+ collect->next_aexpr_elt++;
+}
+
static char target_buf[2048];
+/* Set "transparent" memory ranges
+
+ Allow trace mechanism to treat text-like sections
+ (and perhaps all read-only sections) transparently,
+ i.e. don't reject memory requests from these address ranges
+ just because they haven't been collected. */
+
+static void
+remote_set_transparent_ranges (void)
+{
+ extern bfd *exec_bfd;
+ asection *s;
+ bfd_size_type size;
+ bfd_vma lma;
+ int anysecs = 0;
+
+ if (!exec_bfd)
+ return; /* no information to give. */
+
+ strcpy (target_buf, "QTro");
+ for (s = exec_bfd->sections; s; s = s->next)
+ {
+ char tmp[40];
+
+ if ((s->flags & SEC_LOAD) == 0 ||
+ /* (s->flags & SEC_CODE) == 0 || */
+ (s->flags & SEC_READONLY) == 0)
+ continue;
+
+ anysecs = 1;
+ lma = s->lma;
+ size = bfd_get_section_size_before_reloc (s);
+ sprintf (tmp, ":%x,%x", lma, lma + size);
+ strcat (target_buf, tmp);
+ }
+ if (anysecs)
+ {
+ putpkt (target_buf);
+ getpkt (target_buf, 0);
+ }
+}
+
+/* tstart command:
+
+ Tell target to clear 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;
{ /* STUB_COMM MOSTLY_IMPLEMENTED */
struct tracepoint *t;
char buf[2048];
- char *tdp_actions;
- char *stepping_actions;
- unsigned long step_count;
+ char **tdp_actions;
+ char **stepping_actions;
+ int ndx;
+ struct cleanup *old_chain = NULL;
dont_repeat (); /* like "run", dangerous to repeat accidentally */
sprintf (buf, "QTDP:%x:%x:%c:%x:%x", t->number, t->address,
t->enabled == enabled ? 'E' : 'D',
t->step_count, t->pass_count);
+
+ if (t->actions)
+ strcat (buf, "-");
+ putpkt (buf);
+ remote_get_noisy_reply (target_buf);
+ if (strcmp (target_buf, "OK"))
+ error ("Target does not support tracepoints.");
+
if (t->actions)
{
- encode_actions (t, &tdp_actions, &step_count, &stepping_actions);
+ encode_actions (t, &tdp_actions, &stepping_actions);
+ old_chain = make_cleanup (free_actions_list, tdp_actions);
+ (void) make_cleanup (free_actions_list, stepping_actions);
+
/* do_single_steps (t); */
if (tdp_actions)
{
- if (strlen (buf) + strlen (tdp_actions) >= sizeof (buf))
- error ("Actions for tracepoint %d too complex; "
- "please simplify.", t->number);
- strcat (buf, tdp_actions);
+ for (ndx = 0; tdp_actions[ndx]; ndx++)
+ {
+ QUIT; /* allow user to bail out with ^C */
+ sprintf (buf, "QTDP:-%x:%x:%s%c",
+ t->number, t->address,
+ tdp_actions[ndx],
+ ((tdp_actions[ndx+1] || stepping_actions)
+ ? '-' : 0));
+ putpkt (buf);
+ remote_get_noisy_reply (target_buf);
+ if (strcmp (target_buf, "OK"))
+ error ("Error on target while setting tracepoints.");
+ }
}
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);
- strcat (buf, stepping_actions);
+ for (ndx = 0; stepping_actions[ndx]; ndx++)
+ {
+ QUIT; /* allow user to bail out with ^C */
+ sprintf (buf, "QTDP:-%x:%x:%s%s%s",
+ t->number, t->address,
+ ((ndx == 0) ? "S" : ""),
+ stepping_actions[ndx],
+ (stepping_actions[ndx+1] ? "-" : ""));
+ putpkt (buf);
+ remote_get_noisy_reply (target_buf);
+ if (strcmp (target_buf, "OK"))
+ error ("Error on target while setting tracepoints.");
+ }
}
+
+ do_cleanups (old_chain);
}
- putpkt (buf);
- remote_get_noisy_reply (target_buf);
- if (strcmp (target_buf, "OK"))
- error ("Target does not support tracepoints.");
}
+ /* Tell target to treat text-like sections as transparent */
+ remote_set_transparent_ranges ();
+ /* Now insert traps and begin collecting data */
putpkt ("QTStart");
remote_get_noisy_reply (target_buf);
if (strcmp (target_buf, "OK"))
set_traceframe_num (-1); /* all old traceframes invalidated */
set_tracepoint_num (-1);
set_traceframe_context(-1);
+ trace_running_p = 1;
+ if (trace_start_stop_hook)
+ trace_start_stop_hook(1, from_tty);
+
}
else
- printf_filtered ("Trace can only be run on remote targets.\n");
+ error ("Trace can only be run on remote targets.");
}
+/* 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;
+ if (trace_start_stop_hook)
+ trace_start_stop_hook(0, from_tty);
}
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"))
+
+ 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;
- 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");
- else
- printf_filtered ("TBUFFER: unknown argument (use on or off)\n");
-}
-
-static void
-trace_limit_command (args, from_tty)
- char *args;
- int from_tty;
-{ /* STUB_COMM NOT_IMPLEMENTED */
- printf_filtered ("Limit it to what?\n");
-}
-
-static void
-finish_tfind_command (reply, from_tty)
- char *reply;
+finish_tfind_command (msg, from_tty)
+ char *msg;
int from_tty;
{
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)
- error ("Target failed to find requested trace frame.");
+ if ((target_frameno = (int) 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)
+ if ((target_tracept = (int) strtol (++reply, &reply, 16)) == -1)
error ("Target failed to find requested trace frame.");
break;
case 'O': /* "OK"? */
select_frame (get_current_frame (), 0);
set_traceframe_num (target_frameno);
set_tracepoint_num (target_tracept);
- set_traceframe_context ((get_current_frame ())->pc);
+ if (target_frameno == -1)
+ set_traceframe_context (-1);
+ else
+ set_traceframe_context (read_pc ());
if (from_tty)
- print_stack_frame (selected_frame, selected_frame_level, 1);
+ {
+ 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,
T<hexnum> (gives the selected tracepoint number)
*/
+/* tfind command */
static void
trace_find_command (args, from_tty)
char *args;
{ /* STUB_COMM PART_IMPLEMENTED */
/* this should only be called with a numeric argument */
int frameno = -1;
- int target_frameno = -1, target_tracept = -1, target_stepfrm = 0;
char *tmp;
if (target_is_remote ())
{
+ if (trace_find_hook)
+ trace_find_hook (args, from_tty);
+
if (args == 0 || *args == 0)
{ /* TFIND with no args means find NEXT trace frame. */
if (traceframe_number == -1)
{
if (traceframe_number == -1)
error ("not debugging trace buffer");
- else if (traceframe_number == 0)
+ else if (from_tty && traceframe_number == 0)
error ("already at start of trace buffer");
frameno = traceframe_number - 1;
}
-#if 0
- else if (0 == strcasecmp (args, "start"))
- frameno = 0;
- else if (0 == strcasecmp (args, "none") ||
- 0 == strcasecmp (args, "end"))
- frameno = -1;
-#endif
else
frameno = parse_and_eval_address (args);
- sprintf (target_buf, "QTFrame:%x", frameno);
- putpkt (target_buf);
- tmp = remote_get_noisy_reply (target_buf);
-
- if (frameno == -1) /* end trace debugging */
- { /* hopefully the stub has complied! */
- if (0 != strcmp (tmp, "F-1"))
- error ("Bogus response from target: %s", tmp);
+ if (frameno < -1)
+ error ("invalid input (%d is less than zero)", frameno);
- flush_cached_frames ();
- registers_changed ();
- select_frame (get_current_frame (), 0);
- set_traceframe_num (-1);
- set_tracepoint_num (-1);
- set_traceframe_context (-1);
-
- if (from_tty)
- print_stack_frame (selected_frame, selected_frame_level, 1);
- }
- else
- finish_tfind_command (tmp, from_tty);
+ sprintf (target_buf, "QTFrame:%x", frameno);
+ finish_tfind_command (target_buf, from_tty);
}
else
error ("Trace can only be run on remote targets.");
}
+/* tfind end */
static void
trace_find_end_command (args, from_tty)
char *args;
trace_find_command ("-1", from_tty);
}
+/* tfind none */
static void
trace_find_none_command (args, from_tty)
char *args;
trace_find_command ("-1", from_tty);
}
+/* tfind start */
static void
trace_find_start_command (args, from_tty)
char *args;
trace_find_command ("0", from_tty);
}
+/* tfind pc command */
static void
trace_find_pc_command (args, from_tty)
char *args;
int from_tty;
{ /* STUB_COMM PART_IMPLEMENTED */
CORE_ADDR pc;
- int target_frameno;
char *tmp;
if (target_is_remote ())
pc = parse_and_eval_address (args);
sprintf (target_buf, "QTFrame:pc:%x", pc);
- putpkt (target_buf);
- tmp = remote_get_noisy_reply (target_buf);
-
- finish_tfind_command (tmp, from_tty);
+ finish_tfind_command (target_buf, from_tty);
}
else
error ("Trace can only be run on remote targets.");
}
+/* tfind tracepoint command */
static void
trace_find_tracepoint_command (args, from_tty)
char *args;
int from_tty;
{ /* STUB_COMM PART_IMPLEMENTED */
- int target_frameno, tdp;
+ int tdp;
char buf[40], *tmp;
if (target_is_remote ())
tdp = parse_and_eval_address (args);
sprintf (target_buf, "QTFrame:tdp:%x", tdp);
- putpkt (target_buf);
- tmp = remote_get_noisy_reply (target_buf);
-
- finish_tfind_command (tmp, from_tty);
+ finish_tfind_command (target_buf, from_tty);
}
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.
- */
+
+ 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_line_command (args, from_tty)
static CORE_ADDR start_pc, end_pc;
struct symtabs_and_lines sals;
struct symtab_and_line sal;
- int target_frameno;
char *tmp;
struct cleanup *old_chain;
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);
- putpkt (target_buf);
- tmp = remote_get_noisy_reply (target_buf);
-
- finish_tfind_command (tmp, from_tty);
+ finish_tfind_command (target_buf, from_tty);
do_cleanups (old_chain);
}
else
error ("Trace can only be run on remote targets.");
}
+/* tfind range command */
static void
trace_find_range_command (args, from_tty)
char *args;
int from_tty;
{ /* STUB_COMM PART_IMPLEMENTED */
static CORE_ADDR start, stop;
- int target_frameno;
char *tmp;
if (target_is_remote ())
}
sprintf (target_buf, "QTFrame:range:%x:%x", start, stop);
- putpkt (target_buf);
- tmp = remote_get_noisy_reply (target_buf);
-
- finish_tfind_command (tmp, from_tty);
+ finish_tfind_command (target_buf, from_tty);
}
else
error ("Trace can only be run on remote targets.");
}
+/* tfind outside command */
static void
trace_find_outside_command (args, from_tty)
char *args;
int from_tty;
{ /* STUB_COMM PART_IMPLEMENTED */
CORE_ADDR start, stop;
- int target_frameno;
char *tmp;
if (target_is_remote ())
}
sprintf (target_buf, "QTFrame:outside:%x:%x", start, stop);
- putpkt (target_buf);
- tmp = remote_get_noisy_reply (target_buf);
-
- finish_tfind_command (tmp, from_tty);
+ finish_tfind_command (target_buf, from_tty);
}
else
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;
+
+ QUIT; /* allow user to bail out with ^C */
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 minimal_symbol *msym;
struct block *block;
char **canonical, *symname, *save_args = args;
- int i, nsyms, count = 0;
+ int i, j, nsyms, count = 0;
if (args == 0 || *args == 0)
error ("requires an argument (function, line or *addr) to define a scope");
while (block != 0)
{
+ QUIT; /* allow user to bail out with ^C */
nsyms = BLOCK_NSYMS (block);
for (i = 0; i < nsyms; i++)
{
+ QUIT; /* allow user to bail out with ^C */
if (count == 0)
printf_filtered ("Scope for %s:\n", save_args);
count++;
case LOC_CONST_BYTES:
printf_filtered ("constant bytes: ");
if (SYMBOL_TYPE (sym))
- for (i = 0; i < TYPE_LENGTH (SYMBOL_TYPE (sym)); i++)
+ for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
fprintf_filtered (gdb_stdout, " %02x",
- (unsigned) SYMBOL_VALUE_BYTES (sym) [i]);
+ (unsigned) SYMBOL_VALUE_BYTES (sym) [j]);
break;
case LOC_STATIC:
printf_filtered ("in static storage at address ");
break;
case LOC_REGISTER:
printf_filtered ("a local variable in register $%s",
- reg_names [SYMBOL_VALUE (sym)]);
+ REGISTER_NAME (SYMBOL_VALUE (sym)));
break;
case LOC_ARG:
case LOC_LOCAL_ARG:
break;
case LOC_REGPARM:
printf_filtered ("an argument in register $%s",
- reg_names[SYMBOL_VALUE (sym)]);
+ REGISTER_NAME (SYMBOL_VALUE (sym)));
break;
case LOC_REGPARM_ADDR:
printf_filtered ("the address of an argument, in register $%s",
- reg_names[SYMBOL_VALUE (sym)]);
+ REGISTER_NAME (SYMBOL_VALUE (sym)));
break;
case LOC_TYPEDEF:
printf_filtered ("a typedef.\n");
case LOC_BASEREG:
printf_filtered ("a variable at offset %d from register $%s",
SYMBOL_VALUE (sym),
- reg_names [SYMBOL_BASEREG (sym)]);
+ REGISTER_NAME (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)]);
+ REGISTER_NAME (SYMBOL_BASEREG (sym)));
break;
case LOC_UNRESOLVED:
msym = lookup_minimal_symbol (SYMBOL_NAME (sym), NULL, NULL);
save_args);
}
+/* worker function (cleanup) */
static void
replace_comma (comma)
char *comma;
*comma = ',';
}
+/* tdump command */
static void
trace_dump_command (args, from_tty)
char *args;
int stepping_actions = 0;
int stepping_frame = 0;
+ if (!target_is_remote ())
+ {
+ error ("Trace can only be run on remote targets.");
+ return;
+ }
+
if (tracepoint_number == -1)
{
warning ("No current trace frame.");
for (action = t->actions; action; action = action->next)
{
+ struct cmd_list_element *cmd;
+
+ QUIT; /* allow user to bail out with ^C */
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 (0 == strncasecmp (action_exp, "while-stepping", 14))
+ 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 (0 == strncasecmp (action_exp, "end", 3))
+ else if (cmd->function.cfunc == end_actions_pseudocommand)
stepping_actions = 0;
- else if (0 == strncasecmp (action_exp, "collect", 7))
+ else if (cmd->function.cfunc == collect_pseudocommand)
{
/* Display the collected data.
For the trap frame, display only what was collected at the trap.
STEPPING_FRAME and STEPPING_ACTIONS should be equal. */
if (stepping_frame == stepping_actions)
{
- action_exp += 7;
do { /* repeat over a comma-separated list */
- QUIT;
+ QUIT; /* allow user to bail out with ^C */
if (*action_exp == ',')
action_exp++;
while (isspace (*action_exp))
action_exp++;
next_comma = strchr (action_exp, ',');
- if (next_comma)
- {
- make_cleanup (replace_comma, next_comma);
- *next_comma = '\0';
- }
if (0 == strncasecmp (action_exp, "$reg", 4))
registers_info (NULL, from_tty);
else if (0 == strncasecmp (action_exp, "$arg", 4))
args_info (NULL, from_tty);
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");
discard_cleanups (old_cleanups);
}
+/* Convert the memory pointed to by mem into hex, placing result in buf.
+ * Return a pointer to the last char put in buf (null)
+ * "stolen" from sparc-stub.c
+ */
+static const char hexchars[]="0123456789abcdef";
+
+static unsigned char *
+mem2hex(mem, buf, count)
+ unsigned char *mem;
+ unsigned char *buf;
+ int count;
+{
+ unsigned char ch;
+
+ while (count-- > 0)
+ {
+ ch = *mem++;
+
+ *buf++ = hexchars[ch >> 4];
+ *buf++ = hexchars[ch & 0xf];
+ }
+
+ *buf = 0;
+
+ return buf;
+}
+
+int get_traceframe_number()
+{
+ return traceframe_number;
+}
-static struct cmd_list_element *tfindlist;
-static struct cmd_list_element *tracelist;
+/* module initialization */
void
_initialize_tracepoint ()
{
set_internalvar (lookup_internalvar ("tpnum"),
value_from_longest (builtin_type_int, (LONGEST) 0));
set_internalvar (lookup_internalvar ("trace_frame"),
- value_from_longest (builtin_type_int, (LONGEST) 0));
+ value_from_longest (builtin_type_int, (LONGEST) -1));
if (tracepoint_list.list == NULL)
{
tracepoint_list.list = xmalloc
(tracepoint_list.listsize * sizeof (struct memrange));
}
+ if (tracepoint_list.aexpr_list == NULL)
+ {
+ tracepoint_list.aexpr_listsize = 128;
+ tracepoint_list.aexpr_list = xmalloc
+ (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
+ }
+
if (stepping_list.list == NULL)
{
stepping_list.listsize = 128;
(stepping_list.listsize * sizeof (struct memrange));
}
+ if (stepping_list.aexpr_list == NULL)
+ {
+ stepping_list.aexpr_listsize = 128;
+ stepping_list.aexpr_list = xmalloc
+ (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
+ }
+
add_info ("scope", scope_info,
"List the variables local to a scope");
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_pseudocom,
+ 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_pseudocom,
+ 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\
while single-stepping.\n\n\
Note: this command can only be used in a tracepoint \"actions\" list.");
- add_com ("collect", class_trace, collect_pseudocom,
+ 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\
+Accepts a comma-separated list of (one or more) expressions. GDB will\n\
+collect all data (variables, registers) referenced by that expression.\n\
+Also accepts 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,
projects / thirdparty / binutils-gdb.git / blobdiff