#include "defs.h"
#include "symtab.h"
#include "frame.h"
-#include "tracepoint.h"
#include "gdbtypes.h"
#include "expression.h"
#include "gdbcmd.h"
#include "target.h"
#include "language.h"
#include "gdb_string.h"
+#include "inferior.h"
+#include "tracepoint.h"
+#include "remote.h"
#include "ax.h"
#include "ax-gdb.h"
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 void x_command (char *, int);
extern int addressprint; /* Print machine addresses? */
+/* GDB commands implemented in other modules:
+ */
+
+extern void output_command (char *, int);
+extern void registers_info (char *, int);
+extern void args_info (char *, int);
+extern void locals_info (char *, int);
+
+
/* If this definition isn't overridden by the header files, assume
that isatty and fileno exist on this system. */
#ifndef ISATTY
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));
+static void trace_command (char *, int);
+static void tracepoints_info (char *, int);
+static void delete_trace_command (char *, int);
+static void enable_trace_command (char *, int);
+static void disable_trace_command (char *, int);
+static void trace_pass_command (char *, int);
+static void trace_actions_command (char *, int);
+static void trace_start_command (char *, int);
+static void trace_stop_command (char *, int);
+static void trace_status_command (char *, int);
+static void trace_find_command (char *, int);
+static void trace_find_pc_command (char *, int);
+static void trace_find_tracepoint_command (char *, int);
+static void trace_find_line_command (char *, int);
+static void trace_find_range_command (char *, int);
+static void trace_find_outside_command (char *, int);
+static void tracepoint_save_command (char *, int);
+static void trace_dump_command (char *, int);
/* support routines */
-static void trace_mention PARAMS ((struct tracepoint *));
+static void trace_mention (struct tracepoint *);
-#if __STDC__
struct collection_list;
-#endif
-static void add_aexpr PARAMS ((struct collection_list *, struct agent_expr *));
+static void add_aexpr (struct collection_list *, struct agent_expr *);
static unsigned char *mem2hex (unsigned char *, unsigned char *, int);
-static void add_register PARAMS ((struct collection_list * collection, unsigned long regno));
-static void free_actions_list PARAMS ((char **actions_list));
-static void free_actions_list_cleanup_wrapper PARAMS ((void *));
+static void add_register (struct collection_list *collection,
+ unsigned int regno);
+static struct cleanup *make_cleanup_free_actions (struct tracepoint *t);
+static void free_actions_list (char **actions_list);
+static void free_actions_list_cleanup_wrapper (void *);
-extern void _initialize_tracepoint PARAMS ((void));
+extern void _initialize_tracepoint (void);
/* Utility: returns true if "target remote" */
static int
/* Utility: wait for reply from stub, while accepting "O" packets */
static char *
-remote_get_noisy_reply (buf)
- char *buf;
+remote_get_noisy_reply (char *buf,
+ long sizeof_buf)
{
do /* loop on reply from remote stub */
{
QUIT; /* allow user to bail out with ^C */
- getpkt (buf, 0);
+ getpkt (buf, sizeof_buf, 0);
if (buf[0] == 0)
error ("Target does not support this command.");
else if (buf[0] == 'E')
traceframe_sal.pc = traceframe_sal.line = 0;
traceframe_sal.symtab = NULL;
set_internalvar (lookup_internalvar ("trace_func"),
- value_from_longest (charstar, (LONGEST) 0));
+ value_from_pointer (charstar, (LONGEST) 0));
set_internalvar (lookup_internalvar ("trace_file"),
- value_from_longest (charstar, (LONGEST) 0));
+ value_from_pointer (charstar, (LONGEST) 0));
set_internalvar (lookup_internalvar ("trace_line"),
- value_from_longest (builtin_type_int, (LONGEST) - 1));
+ value_from_pointer (builtin_type_int, (LONGEST) - 1));
return;
}
if (traceframe_fun == NULL ||
SYMBOL_NAME (traceframe_fun) == NULL)
set_internalvar (lookup_internalvar ("trace_func"),
- value_from_longest (charstar, (LONGEST) 0));
+ value_from_pointer (charstar, (LONGEST) 0));
else
{
len = strlen (SYMBOL_NAME (traceframe_fun));
if (traceframe_sal.symtab == NULL ||
traceframe_sal.symtab->filename == NULL)
set_internalvar (lookup_internalvar ("trace_file"),
- value_from_longest (charstar, (LONGEST) 0));
+ value_from_pointer (charstar, (LONGEST) 0));
else
{
len = strlen (traceframe_sal.symtab->filename);
printf_filtered ("%s ",
local_hex_string_custom ((unsigned long) t->address,
"08l"));
- printf_filtered ("%-5d %-5d ", t->pass_count, t->step_count);
+ printf_filtered ("%-5d %-5ld ", t->pass_count, t->step_count);
if (t->source_file)
{
*/
enum tracepoint_opcode
{
- enable,
- disable,
- delete
+ enable_op,
+ disable_op,
+ delete_op
};
-/* This function implements enable, disable and delete. */
+/* This function implements enable, disable and delete commands. */
static void
tracepoint_operation (t, from_tty, opcode)
struct tracepoint *t;
{
struct tracepoint *t2;
+ if (t == NULL) /* no tracepoint operand */
+ return;
+
switch (opcode)
{
- case enable:
+ case enable_op:
t->enabled = enabled;
if (modify_tracepoint_hook)
modify_tracepoint_hook (t);
break;
- case disable:
+ case disable_op:
t->enabled = disabled;
if (modify_tracepoint_hook)
modify_tracepoint_hook (t);
break;
- case delete:
+ case delete_op:
if (tracepoint_chain == t)
tracepoint_chain = t->next;
}
}
-/* Utility: parse a tracepoint number and look it up in the list. */
+/* Utility: parse a tracepoint number and look it up in the list.
+ If MULTI_P is true, there might be a range of tracepoints in ARG.
+ if OPTIONAL_P is true, then if the argument is missing, the most
+ recent tracepoint (tracepoint_count) is returned. */
struct tracepoint *
-get_tracepoint_by_number (arg)
+get_tracepoint_by_number (arg, multi_p, optional_p)
char **arg;
+ int multi_p, optional_p;
{
struct tracepoint *t;
- char *end, *copy;
- value_ptr val;
int tpnum;
+ char *instring = arg == NULL ? NULL : *arg;
- if (arg == 0)
- error ("Bad tracepoint argument");
-
- if (*arg == 0 || **arg == 0) /* empty arg means refer to last tp */
- tpnum = tracepoint_count;
- else if (**arg == '$') /* handle convenience variable */
+ if (arg == NULL || *arg == NULL || ! **arg)
{
- /* 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);
+ if (optional_p)
+ tpnum = tracepoint_count;
+ else
+ error_no_arg ("tracepoint number");
}
else
- /* handle tracepoint number */
+ tpnum = multi_p ? get_number_or_range (arg) : get_number (arg);
+
+ if (tpnum <= 0)
{
- tpnum = strtol (*arg, arg, 0);
- if (tpnum == 0) /* possible strtol failure */
- while (**arg && !isspace (**arg))
- (*arg)++; /* advance to next white space, if any */
+ if (instring && *instring)
+ printf_filtered ("bad tracepoint number at or near '%s'\n", instring);
+ else
+ printf_filtered ("Tracepoint argument missing and no previous tracepoint\n");
+ return NULL;
}
+
ALL_TRACEPOINTS (t)
if (t->number == tpnum)
{
return t;
}
+
+ /* FIXME: if we are in the middle of a range we don't want to give
+ a message. The current interface to get_number_or_range doesn't
+ allow us to discover this. */
printf_unfiltered ("No tracepoint number %d.\n", tpnum);
return NULL;
}
enum tracepoint_opcode opcode;
{
struct tracepoint *t, *tmp;
- int tpnum;
- char *cp;
if (args == 0 || *args == 0) /* do them all */
ALL_TRACEPOINTS_SAFE (t, tmp)
while (*args)
{
QUIT; /* give user option to bail out with ^C */
- t = get_tracepoint_by_number (&args);
- if (t)
- tracepoint_operation (t, from_tty, opcode);
+ t = get_tracepoint_by_number (&args, 1, 0);
+ tracepoint_operation (t, from_tty, opcode);
while (*args == ' ' || *args == '\t')
args++;
}
int from_tty;
{
dont_repeat ();
- map_args_over_tracepoints (args, from_tty, enable);
+ map_args_over_tracepoints (args, from_tty, enable_op);
}
/* The 'disable trace' command enables tracepoints. Not supported by all targets. */
int from_tty;
{
dont_repeat ();
- map_args_over_tracepoints (args, from_tty, disable);
+ map_args_over_tracepoints (args, from_tty, disable_op);
}
/* Remove a tracepoint (or all if no argument) */
if (!query ("Delete all tracepoints? "))
return;
- map_args_over_tracepoints (args, from_tty, delete);
+ map_args_over_tracepoints (args, from_tty, delete_op);
}
/* Set passcount for tracepoint.
int from_tty;
{
struct tracepoint *t1 = (struct tracepoint *) -1, *t2;
- unsigned long count;
+ unsigned int count;
+ int all = 0;
if (args == 0 || *args == 0)
- error ("PASS command requires an argument (count + optional TP num)");
+ error ("passcount command requires an argument (count + optional TP num)");
count = strtoul (args, &args, 10); /* count comes first, then TP num */
- while (*args && isspace (*args))
+ while (*args && isspace ((int) *args))
args++;
if (*args && strncasecmp (args, "all", 3) == 0)
- args += 3; /* skip special argument "all" */
+ {
+ args += 3; /* skip special argument "all" */
+ all = 1;
+ if (*args)
+ error ("Junk at end of arguments.");
+ }
else
- t1 = get_tracepoint_by_number (&args);
-
- if (*args)
- error ("Junk at end of arguments.");
-
- if (t1 == NULL)
- return; /* error, bad tracepoint number */
+ t1 = get_tracepoint_by_number (&args, 1, 1);
- ALL_TRACEPOINTS (t2)
- if (t1 == (struct tracepoint *) -1 || t1 == t2)
+ do
{
- 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);
+ if (t1)
+ {
+ ALL_TRACEPOINTS (t2)
+ 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);
+ }
+ if (! all && *args)
+ t1 = get_tracepoint_by_number (&args, 1, 0);
+ }
}
+ while (*args);
}
/* 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 *));
+static void read_actions (struct tracepoint *);
/* The three functions:
collect_pseudocommand,
int from_tty;
{
struct tracepoint *t;
- char *actions;
char tmpbuf[128];
char *end_msg = "End with a line saying just \"end\".";
- t = get_tracepoint_by_number (&args);
+ t = get_tracepoint_by_number (&args, 0, 1);
if (t)
{
sprintf (tmpbuf, "Enter actions for tracepoint %d, one per line.",
if (readline_end_hook)
(*readline_end_hook) ();
-
/* tracepoints_changed () */
}
- /* else error, just return; */
+ /* else just return */
}
/* worker function */
#ifdef STOP_SIGNAL
if (job_control)
{
- if (async_p)
+ if (event_loop_p)
signal (STOP_SIGNAL, handle_stop_sig);
else
signal (STOP_SIGNAL, stop_sig);
}
#endif
- old_chain = make_cleanup ((make_cleanup_func) free_actions, (void *) t);
+ old_chain = make_cleanup_free_actions (t);
while (1)
{
/* Make sure that all output has been output. Some machines may let
{
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 ((int) *p);)
p++;
/* symbol lookup etc. */
do
{ /* repeat over a comma-separated list */
QUIT; /* allow user to bail out with ^C */
- while (isspace (*p))
+ while (isspace ((int) *p))
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)))
/* 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);
+ old_chain = make_cleanup (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.",
+ warning ("constant %s (value %ld) will not be collected.",
SYMBOL_NAME (exp->elts[2].symbol),
SYMBOL_VALUE (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);
+ make_cleanup_free_agent_expr (aexpr);
if (aexpr->len > MAX_AGENT_EXPR_LEN)
error ("expression too complicated, try simplifying");
{
char *steparg; /* in case warning is necessary */
- while (isspace (*p))
+ while (isspace ((int) *p))
p++;
steparg = p;
if (*p == '\0' ||
(t->step_count = strtol (p, &p, 0)) == 0)
{
- warning ("bad step-count: command ignored.", *line);
+ warning ("'%s': bad step-count; command ignored.", *line);
return BADLINE;
}
return STEPPING;
t->actions = NULL;
}
+static void
+do_free_actions_cleanup (void *t)
+{
+ free_actions (t);
+}
+
+static struct cleanup *
+make_cleanup_free_actions (struct tracepoint *t)
+{
+ return make_cleanup (do_free_actions_cleanup, t);
+}
+
struct memrange
{
- int type; /* 0 for absolute memory range, else basereg number */
+ int type; /* 0 for absolute memory range, else basereg number */
bfd_signed_vma start;
bfd_signed_vma end;
};
/* MEMRANGE functions: */
-static int memrange_cmp PARAMS ((const void *, const void *));
+static int memrange_cmp (const void *, const void *);
/* compare memranges for qsort */
static int
static void
add_register (collection, regno)
struct collection_list *collection;
- unsigned long regno;
+ unsigned int regno;
{
if (info_verbose)
printf_filtered ("collect register %d\n", regno);
unsigned long len;
{
if (info_verbose)
- printf_filtered ("(%d,0x%x,%d)\n", type, base, len);
+ {
+ printf_filtered ("(%d,", type);
+ printf_vma (base);
+ printf_filtered (",%ld)\n", len);
+ }
+
/* type: 0 == memory, n == basereg */
memranges->list[memranges->next_memrange].type = type;
/* base: addr if memory, offset if reg relative. */
long frame_offset;
{
unsigned long len;
- unsigned long reg;
+ unsigned int reg;
bfd_signed_vma offset;
len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
SYMBOL_NAME (sym), SYMBOL_CLASS (sym));
break;
case LOC_CONST:
- printf_filtered ("%s is constant, value is %d: will not be collected.\n",
+ printf_filtered ("constant %s (value %ld) will not be collected.\n",
SYMBOL_NAME (sym), SYMBOL_VALUE (sym));
break;
case LOC_STATIC:
offset = SYMBOL_VALUE_ADDRESS (sym);
if (info_verbose)
- printf_filtered ("LOC_STATIC %s: collect %d bytes at 0x%08x\n",
- SYMBOL_NAME (sym), len, offset);
+ {
+ char tmp[40];
+
+ sprintf_vma (tmp, offset);
+ printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
+ SYMBOL_NAME (sym), len, tmp /* address */);
+ }
add_memrange (collect, -1, offset, len); /* 0 == memory */
break;
case LOC_REGISTER:
offset = frame_offset + SYMBOL_VALUE (sym);
if (info_verbose)
{
- printf_filtered ("LOC_LOCAL %s: Collect %d bytes at offset",
+ printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
SYMBOL_NAME (sym), len);
- printf_filtered (" %d from frame ptr reg %d\n", offset, reg);
+ printf_vma (offset);
+ printf_filtered (" from frame ptr reg %d\n", reg);
}
add_memrange (collect, reg, offset, len);
break;
offset = 0;
if (info_verbose)
{
- printf_filtered ("LOC_REGPARM_ADDR %s: Collect %d bytes at offset",
+ printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
SYMBOL_NAME (sym), len);
- printf_filtered (" %d from reg %d\n", offset, reg);
+ printf_vma (offset);
+ printf_filtered (" from reg %d\n", reg);
}
add_memrange (collect, reg, offset, len);
break;
offset = frame_offset + SYMBOL_VALUE (sym);
if (info_verbose)
{
- printf_filtered ("LOC_LOCAL %s: Collect %d bytes at offset",
+ printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
SYMBOL_NAME (sym), len);
- printf_filtered (" %d from frame ptr reg %d\n", offset, reg);
+ printf_vma (offset);
+ printf_filtered (" from frame ptr reg %d\n", reg);
}
add_memrange (collect, reg, offset, len);
break;
offset = SYMBOL_VALUE (sym);
if (info_verbose)
{
- printf_filtered ("LOC_BASEREG %s: collect %d bytes at offset %d from basereg %d\n",
- SYMBOL_NAME (sym), len, offset, reg);
+ printf_filtered ("LOC_BASEREG %s: collect %ld bytes at offset ",
+ SYMBOL_NAME (sym), len);
+ printf_vma (offset);
+ printf_filtered (" from basereg %d\n", reg);
}
add_memrange (collect, reg, offset, len);
break;
sym = BLOCK_SYM (block, i);
switch (SYMBOL_CLASS (sym))
{
+ default:
+ warning ("don't know how to trace local symbol %s",
+ SYMBOL_NAME (sym));
case LOC_LOCAL:
case LOC_STATIC:
case LOC_REGISTER:
char *string;
{
char temp_buf[2048];
+ char tmp2[40];
int count;
int ndx = 0;
char *(*str_list)[];
for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
{
QUIT; /* allow user to bail out with ^C */
+ sprintf_vma (tmp2, list->list[i].start);
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);
+ {
+ printf_filtered ("(%d, %s, %ld)\n",
+ list->list[i].type,
+ tmp2,
+ (long) (list->list[i].end - list->list[i].start));
+ }
if (count + 27 > MAX_AGENT_EXPR_LEN)
{
(*str_list)[ndx] = savestring (temp_buf, count);
count = 0;
end = temp_buf;
}
- sprintf (end, "M%X,%X,%X",
+
+ sprintf (end, "M%X,%s,%lX",
list->list[i].type,
- list->list[i].start,
- list->list[i].end - list->list[i].start);
+ tmp2,
+ (long) (list->list[i].end - list->list[i].start));
+
count += strlen (end);
- end += strlen (end);
+ end += count;
}
for (i = 0; i < list->next_aexpr_elt; i++)
char *action_exp;
struct expression *exp = NULL;
struct action_line *action;
- bfd_signed_vma offset;
- long i;
+ int i;
value_ptr tempval;
struct collection_list *collect;
struct cmd_list_element *cmd;
{
QUIT; /* allow user to bail out with ^C */
action_exp = action->action;
- while (isspace (*action_exp))
+ while (isspace ((int) *action_exp))
action_exp++;
if (*action_exp == '#') /* comment line */
do
{ /* repeat over a comma-separated list */
QUIT; /* allow user to bail out with ^C */
- while (isspace (*action_exp))
+ while (isspace ((int) *action_exp))
action_exp++;
if (0 == strncasecmp ("$reg", action_exp, 4))
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);
+ old_chain = make_cleanup (free_current_contents, &exp);
switch (exp->elts[0].opcode)
{
default: /* full-fledged expression */
aexpr = gen_trace_for_expr (t->address, exp);
- old_chain1 = make_cleanup ((make_cleanup_func)
- free_agent_expr, aexpr);
+ old_chain1 = make_cleanup_free_agent_expr (aexpr);
ax_reqs (aexpr, &areqs);
if (areqs.flaw != agent_flaw_none)
strcpy (target_buf, "QTro");
for (s = exec_bfd->sections; s; s = s->next)
{
- char tmp[40];
+ char tmp1[40], tmp2[40];
if ((s->flags & SEC_LOAD) == 0 ||
/* (s->flags & SEC_CODE) == 0 || */
anysecs = 1;
lma = s->lma;
size = bfd_get_section_size_before_reloc (s);
- sprintf (tmp, ":%x,%x", lma, lma + size);
- strcat (target_buf, tmp);
+ sprintf_vma (tmp1, lma);
+ sprintf_vma (tmp2, lma + size);
+ sprintf (target_buf + strlen (target_buf),
+ ":%s,%s", tmp1, tmp2);
}
if (anysecs)
{
putpkt (target_buf);
- getpkt (target_buf, 0);
+ getpkt (target_buf, sizeof (target_buf), 0);
}
}
if (target_is_remote ())
{
putpkt ("QTinit");
- remote_get_noisy_reply (target_buf);
+ remote_get_noisy_reply (target_buf, sizeof (target_buf));
if (strcmp (target_buf, "OK"))
error ("Target does not support this command.");
ALL_TRACEPOINTS (t)
{
- int ss_count; /* if actions include singlestepping */
- int disable_mask; /* ??? */
- int enable_mask; /* ??? */
+ char tmp[40];
- sprintf (buf, "QTDP:%x:%x:%c:%x:%x", t->number, t->address,
+ sprintf_vma (tmp, t->address);
+ sprintf (buf, "QTDP:%x:%s:%c:%lx:%x", t->number, tmp, /* 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);
+ remote_get_noisy_reply (target_buf, sizeof (target_buf));
if (strcmp (target_buf, "OK"))
error ("Target does not support tracepoints.");
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,
+ sprintf (buf, "QTDP:-%x:%s:%s%c",
+ t->number, tmp, /* address */
tdp_actions[ndx],
((tdp_actions[ndx + 1] || stepping_actions)
? '-' : 0));
putpkt (buf);
- remote_get_noisy_reply (target_buf);
+ remote_get_noisy_reply (target_buf, sizeof (target_buf));
if (strcmp (target_buf, "OK"))
error ("Error on target while setting tracepoints.");
}
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,
+ sprintf (buf, "QTDP:-%x:%s:%s%s%s",
+ t->number, tmp, /* address */
((ndx == 0) ? "S" : ""),
stepping_actions[ndx],
(stepping_actions[ndx + 1] ? "-" : ""));
putpkt (buf);
- remote_get_noisy_reply (target_buf);
+ remote_get_noisy_reply (target_buf, sizeof (target_buf));
if (strcmp (target_buf, "OK"))
error ("Error on target while setting tracepoints.");
}
remote_set_transparent_ranges ();
/* Now insert traps and begin collecting data */
putpkt ("QTStart");
- remote_get_noisy_reply (target_buf);
+ remote_get_noisy_reply (target_buf, sizeof (target_buf));
if (strcmp (target_buf, "OK"))
error ("Bogus reply from target: %s", target_buf);
set_traceframe_num (-1); /* all old traceframes invalidated */
if (target_is_remote ())
{
putpkt ("QTStop");
- remote_get_noisy_reply (target_buf);
+ remote_get_noisy_reply (target_buf, sizeof (target_buf));
if (strcmp (target_buf, "OK"))
error ("Bogus reply from target: %s", target_buf);
trace_running_p = 0;
if (target_is_remote ())
{
putpkt ("qTStatus");
- remote_get_noisy_reply (target_buf);
+ remote_get_noisy_reply (target_buf, sizeof (target_buf));
if (target_buf[0] != 'T' ||
(target_buf[1] != '0' && target_buf[1] != '1'))
/* Worker function for the various flavors of the tfind command */
static void
-finish_tfind_command (msg, from_tty)
- char *msg;
- int from_tty;
+finish_tfind_command (char *msg,
+ long sizeof_msg,
+ int from_tty)
{
int target_frameno = -1, target_tracept = -1;
CORE_ADDR old_frame_addr;
old_func = find_pc_function (read_pc ());
putpkt (msg);
- reply = remote_get_noisy_reply (msg);
+ reply = remote_get_noisy_reply (msg, sizeof_msg);
while (reply && *reply)
switch (*reply)
{ /* STUB_COMM PART_IMPLEMENTED */
/* this should only be called with a numeric argument */
int frameno = -1;
- char *tmp;
if (target_is_remote ())
{
error ("invalid input (%d is less than zero)", frameno);
sprintf (target_buf, "QTFrame:%x", frameno);
- finish_tfind_command (target_buf, from_tty);
+ finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
}
else
error ("Trace can only be run on remote targets.");
int from_tty;
{ /* STUB_COMM PART_IMPLEMENTED */
CORE_ADDR pc;
- char *tmp;
+ char tmp[40];
if (target_is_remote ())
{
else
pc = parse_and_eval_address (args);
- sprintf (target_buf, "QTFrame:pc:%x", pc);
- finish_tfind_command (target_buf, from_tty);
+ sprintf_vma (tmp, pc);
+ sprintf (target_buf, "QTFrame:pc:%s", tmp);
+ finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
}
else
error ("Trace can only be run on remote targets.");
int from_tty;
{ /* STUB_COMM PART_IMPLEMENTED */
int tdp;
- char buf[40], *tmp;
if (target_is_remote ())
{
tdp = parse_and_eval_address (args);
sprintf (target_buf, "QTFrame:tdp:%x", tdp);
- finish_tfind_command (target_buf, from_tty);
+ finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
}
else
error ("Trace can only be run on remote targets.");
static CORE_ADDR start_pc, end_pc;
struct symtabs_and_lines sals;
struct symtab_and_line sal;
- char *tmp;
struct cleanup *old_chain;
+ char startpc_str[40], endpc_str[40];
if (target_is_remote ())
{
error ("Line number %d is out of range for \"%s\".\n",
sal.line, sal.symtab->filename);
+ sprintf_vma (startpc_str, start_pc);
+ sprintf_vma (endpc_str, end_pc - 1);
if (args && *args) /* find within range of stated line */
- sprintf (target_buf, "QTFrame:range:%x:%x", start_pc, end_pc - 1);
+ sprintf (target_buf, "QTFrame:range:%s:%s", startpc_str, endpc_str);
else /* find OUTSIDE OF range of CURRENT line */
- sprintf (target_buf, "QTFrame:outside:%x:%x", start_pc, end_pc - 1);
- finish_tfind_command (target_buf, from_tty);
+ sprintf (target_buf, "QTFrame:outside:%s:%s", startpc_str, endpc_str);
+ finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
do_cleanups (old_chain);
}
else
trace_find_range_command (args, from_tty)
char *args;
int from_tty;
-{ /* STUB_COMM PART_IMPLEMENTED */
+{
static CORE_ADDR start, stop;
+ char start_str[40], stop_str[40];
char *tmp;
if (target_is_remote ())
{
if (args == 0 || *args == 0)
- { /* XXX FIXME: what should default behavior be? */
+ { /* XXX FIXME: what should default behavior be? */
printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
return;
}
if (0 != (tmp = strchr (args, ',')))
{
*tmp++ = '\0'; /* terminate start address */
- while (isspace (*tmp))
+ while (isspace ((int) *tmp))
tmp++;
start = parse_and_eval_address (args);
stop = parse_and_eval_address (tmp);
stop = start + 1; /* ??? */
}
- sprintf (target_buf, "QTFrame:range:%x:%x", start, stop);
- finish_tfind_command (target_buf, from_tty);
+ sprintf_vma (start_str, start);
+ sprintf_vma (stop_str, stop);
+ sprintf (target_buf, "QTFrame:range:%s:%s", start_str, stop_str);
+ finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
}
else
error ("Trace can only be run on remote targets.");
trace_find_outside_command (args, from_tty)
char *args;
int from_tty;
-{ /* STUB_COMM PART_IMPLEMENTED */
+{
CORE_ADDR start, stop;
+ char start_str[40], stop_str[40];
char *tmp;
if (target_is_remote ())
{
if (args == 0 || *args == 0)
- { /* XXX FIXME: what should default behavior be? */
+ { /* XXX FIXME: what should default behavior be? */
printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
return;
}
if (0 != (tmp = strchr (args, ',')))
{
*tmp++ = '\0'; /* terminate start address */
- while (isspace (*tmp))
+ while (isspace ((int) *tmp))
tmp++;
start = parse_and_eval_address (args);
stop = parse_and_eval_address (tmp);
stop = start + 1; /* ??? */
}
- sprintf (target_buf, "QTFrame:outside:%x:%x", start, stop);
- finish_tfind_command (target_buf, from_tty);
+ sprintf_vma (start_str, start);
+ sprintf_vma (stop_str, stop);
+ sprintf (target_buf, "QTFrame:outside:%s:%s", start_str, stop_str);
+ finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
}
else
error ("Trace can only be run on remote targets.");
FILE *fp;
char *i1 = " ", *i2 = " ";
char *indent, *actionline;
+ char tmp[40];
if (args == 0 || *args == 0)
error ("Argument required (file name in which to save tracepoints");
if (tp->addr_string)
fprintf (fp, "trace %s\n", tp->addr_string);
else
- fprintf (fp, "trace *0x%x\n", tp->address);
+ {
+ sprintf_vma (tmp, tp->address);
+ fprintf (fp, "trace *0x%s\n", tmp);
+ }
if (tp->pass_count)
fprintf (fp, " passcount %d\n", tp->pass_count);
QUIT; /* allow user to bail out with ^C */
actionline = line->action;
- while (isspace (*actionline))
+ while (isspace ((int) *actionline))
actionline++;
fprintf (fp, "%s%s\n", indent, actionline);
char *args;
int from_tty;
{
- struct symtab_and_line sal;
struct symtabs_and_lines sals;
struct symbol *sym;
struct minimal_symbol *msym;
count--; /* don't count this one */
continue;
case LOC_CONST:
- printf_filtered ("a constant with value %d (0x%x)",
+ printf_filtered ("a constant with value %ld (0x%lx)",
SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
break;
case LOC_CONST_BYTES:
gdb_stdout);
break;
case LOC_BASEREG:
- printf_filtered ("a variable at offset %d from register $%s",
+ printf_filtered ("a variable at offset %ld from register $%s",
SYMBOL_VALUE (sym),
REGISTER_NAME (SYMBOL_BASEREG (sym)));
break;
case LOC_BASEREG_ARG:
- printf_filtered ("an argument at offset %d from register $%s",
+ printf_filtered ("an argument at offset %ld from register $%s",
SYMBOL_VALUE (sym),
REGISTER_NAME (SYMBOL_BASEREG (sym)));
break;
QUIT; /* allow user to bail out with ^C */
action_exp = action->action;
- while (isspace (*action_exp))
+ while (isspace ((int) *action_exp))
action_exp++;
/* The collection actions to be done while stepping are
QUIT; /* allow user to bail out with ^C */
if (*action_exp == ',')
action_exp++;
- while (isspace (*action_exp))
+ while (isspace ((int) *action_exp))
action_exp++;
next_comma = strchr (action_exp, ',');
projects / deliverable / binutils-gdb.git / blobdiff