/* Tracing functionality for remote targets in custom GDB protocol
- Copyright 1997, 1998, 1999, 2000, 2001, 2002 Free Software
- Foundation, Inc.
+ Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+ 2007, 2008, 2009 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
+#include "arch-utils.h"
#include "symtab.h"
#include "frame.h"
#include "gdbtypes.h"
#include "language.h"
#include "gdb_string.h"
#include "inferior.h"
+#include "breakpoint.h"
#include "tracepoint.h"
#include "remote.h"
+extern int remote_supports_cond_tracepoints (void);
#include "linespec.h"
#include "regcache.h"
#include "completer.h"
-#include "gdb-events.h"
+#include "block.h"
+#include "dictionary.h"
+#include "observer.h"
+#include "user-regs.h"
+#include "valprint.h"
+#include "gdbcore.h"
+#include "objfiles.h"
#include "ax.h"
#include "ax-gdb.h"
/* readline include files */
-#include <readline/readline.h>
-#include <readline/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
+/* 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.
#define MAX_AGENT_EXPR_LEN 184
-extern void (*readline_begin_hook) (char *, ...);
-extern char *(*readline_hook) (char *);
-extern void (*readline_end_hook) (void);
-extern void x_command (char *, int);
-extern int addressprint; /* Print machine addresses? */
+extern void (*deprecated_readline_begin_hook) (char *, ...);
+extern char *(*deprecated_readline_hook) (char *);
+extern void (*deprecated_readline_end_hook) (void);
/* GDB commands implemented in other modules:
*/
extern void output_command (char *, int);
-/* If this definition isn't overridden by the header files, assume
- that isatty and fileno exist on this system. */
-#ifndef ISATTY
-#define ISATTY(FP) (isatty (fileno (FP)))
-#endif
-
/*
Tracepoint.c:
/* ======= Important global variables: ======= */
-/* Chain of all tracepoints defined. */
-struct tracepoint *tracepoint_chain;
-
-/* Number of last tracepoint made. */
-static int tracepoint_count;
-
/* Number of last traceframe collected. */
static int traceframe_number;
static struct cmd_list_element *tfindlist;
/* ======= Important command functions: ======= */
-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_dump_command (char *, int);
/* support routines */
-static void trace_mention (struct tracepoint *);
struct collection_list;
static void add_aexpr (struct collection_list *, struct agent_expr *);
-static unsigned char *mem2hex (unsigned char *, unsigned char *, int);
+static char *mem2hex (gdb_byte *, char *, int);
static void add_register (struct collection_list *collection,
unsigned int regno);
-static struct cleanup *make_cleanup_free_actions (struct tracepoint *t);
+static struct cleanup *make_cleanup_free_actions (struct breakpoint *t);
static void free_actions_list (char **actions_list);
static void free_actions_list_cleanup_wrapper (void *);
target_is_remote (void)
{
if (current_target.to_shortname &&
- strcmp (current_target.to_shortname, "remote") == 0)
+ (strcmp (current_target.to_shortname, "remote") == 0
+ || strcmp (current_target.to_shortname, "extended-remote") == 0))
return 1;
else
return 0;
{
case '1': /* malformed packet error */
if (*++buf == '0') /* general case: */
- error ("tracepoint.c: error in outgoing packet.");
+ error (_("tracepoint.c: error in outgoing packet."));
else
- error ("tracepoint.c: error in outgoing packet at field #%ld.",
+ error (_("tracepoint.c: error in outgoing packet at field #%ld."),
strtol (buf, NULL, 16));
case '2':
- error ("trace API error 0x%s.", ++buf);
+ error (_("trace API error 0x%s."), ++buf);
default:
- error ("Target returns error code '%s'.", buf);
+ error (_("Target returns error code '%s'."), buf);
}
}
-/* Utility: wait for reply from stub, while accepting "O" packets */
+/* Utility: wait for reply from stub, while accepting "O" packets. */
static char *
-remote_get_noisy_reply (char *buf,
- long sizeof_buf)
+remote_get_noisy_reply (char **buf_p,
+ long *sizeof_buf)
{
- do /* loop on reply from remote stub */
+ do /* Loop on reply from remote stub. */
{
+ char *buf;
QUIT; /* allow user to bail out with ^C */
- getpkt (buf, sizeof_buf, 0);
+ getpkt (buf_p, sizeof_buf, 0);
+ buf = *buf_p;
if (buf[0] == 0)
- error ("Target does not support this command.");
+ error (_("Target does not support this command."));
else if (buf[0] == 'E')
trace_error (buf);
else if (buf[0] == 'O' &&
while (1);
}
-/* Set tracepoint count to NUM. */
-static void
-set_tracepoint_count (int num)
-{
- tracepoint_count = num;
- set_internalvar (lookup_internalvar ("tpnum"),
- value_from_longest (builtin_type_int, (LONGEST) num));
-}
-
/* Set traceframe number to NUM. */
static void
set_traceframe_num (int num)
{
traceframe_number = num;
- set_internalvar (lookup_internalvar ("trace_frame"),
- value_from_longest (builtin_type_int, (LONGEST) num));
+ set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
}
/* Set tracepoint number to NUM. */
set_tracepoint_num (int num)
{
tracepoint_number = num;
- set_internalvar (lookup_internalvar ("tracepoint"),
- value_from_longest (builtin_type_int, (LONGEST) num));
+ set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
}
/* Set externally visible debug variables for querying/printing
the traceframe context (line, function, file) */
static void
-set_traceframe_context (CORE_ADDR trace_pc)
+set_traceframe_context (struct frame_info *trace_frame)
{
- static struct type *func_string, *file_string;
- static struct type *func_range, *file_range;
- struct value *func_val;
- struct value *file_val;
- static struct type *charstar;
- int len;
+ CORE_ADDR trace_pc;
- if (charstar == (struct type *) NULL)
- charstar = lookup_pointer_type (builtin_type_char);
-
- if (trace_pc == -1) /* cease debugging any trace buffers */
+ if (trace_frame == NULL) /* 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_pointer (charstar, (LONGEST) 0));
- set_internalvar (lookup_internalvar ("trace_file"),
- value_from_pointer (charstar, (LONGEST) 0));
- set_internalvar (lookup_internalvar ("trace_line"),
- value_from_pointer (builtin_type_int, (LONGEST) - 1));
+ clear_internalvar (lookup_internalvar ("trace_func"));
+ clear_internalvar (lookup_internalvar ("trace_file"));
+ set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
return;
}
- /* save as globals for internal use */
+ /* Save as globals for internal use. */
+ trace_pc = get_frame_pc (trace_frame);
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_pointer (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_pointer (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!
- Does not print anything.
-
- ==> This routine should not be called if there is a chance of later
- error(); otherwise it leaves a bogus tracepoint on the chain. Validate
- your arguments BEFORE calling this routine! */
-
-static struct tracepoint *
-set_raw_tracepoint (struct symtab_and_line sal)
-{
- register struct tracepoint *t, *tc;
- struct cleanup *old_chain;
-
- t = (struct tracepoint *) xmalloc (sizeof (struct tracepoint));
- old_chain = make_cleanup (xfree, t);
- memset (t, 0, sizeof (*t));
- t->address = sal.pc;
- if (sal.symtab == NULL)
- t->source_file = NULL;
- else
- t->source_file = savestring (sal.symtab->filename,
- strlen (sal.symtab->filename));
-
- t->section = sal.section;
- t->language = current_language->la_language;
- t->input_radix = input_radix;
- t->line_number = sal.line;
- t->enabled_p = 1;
- 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
- of increasing numbers. */
-
- tc = tracepoint_chain;
- if (tc == 0)
- tracepoint_chain = t;
- else
- {
- while (tc->next)
- tc = tc->next;
- tc->next = t;
- }
- discard_cleanups (old_chain);
- return t;
-}
-
-/* Set a tracepoint according to ARG (function, linenum or *address) */
-static void
-trace_command (char *arg, int from_tty)
-{
- char **canonical = (char **) NULL;
- struct symtabs_and_lines sals;
- struct symtab_and_line sal;
- struct tracepoint *t;
- char *addr_start = 0, *addr_end = 0;
- int i;
-
- if (!arg || !*arg)
- error ("trace command requires an argument");
-
- if (from_tty && info_verbose)
- printf_filtered ("TRACE %s\n", arg);
-
- addr_start = arg;
- sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 0, &canonical);
- addr_end = arg;
- if (!sals.nelts)
- return; /* ??? Presumably decode_line_1 has already warned? */
-
- /* Resolve all line numbers to PC's */
- for (i = 0; i < sals.nelts; i++)
- resolve_sal_pc (&sals.sals[i]);
-
- /* Now set all the tracepoints. */
- for (i = 0; i < sals.nelts; i++)
- {
- sal = sals.sals[i];
-
- t = set_raw_tracepoint (sal);
- set_tracepoint_count (tracepoint_count + 1);
- t->number = tracepoint_count;
-
- /* If a canonical line spec is needed use that instead of the
- command string. */
- if (canonical != (char **) NULL && canonical[i] != NULL)
- t->addr_string = canonical[i];
- else if (addr_start)
- t->addr_string = savestring (addr_start, addr_end - addr_start);
-
- trace_mention (t);
- }
-
- if (sals.nelts > 1)
- {
- printf_filtered ("Multiple tracepoints were set.\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 (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 (char *tpnum_exp, int from_tty)
-{
- struct tracepoint *t;
- struct action_line *action;
- int found_a_tracepoint = 0;
- char wrap_indent[80];
- struct symbol *sym;
- int tpnum = -1;
-
- if (tpnum_exp)
- tpnum = parse_and_eval_long (tpnum_exp);
-
- ALL_TRACEPOINTS (t)
- if (tpnum == -1 || tpnum == t->number)
- {
- extern int addressprint; /* print machine addresses? */
-
- if (!found_a_tracepoint++)
- {
- printf_filtered ("Num Enb ");
- if (addressprint)
- {
- if (TARGET_ADDR_BIT <= 32)
- printf_filtered ("Address ");
- else
- printf_filtered ("Address ");
- }
- printf_filtered ("PassC StepC What\n");
- }
- strcpy (wrap_indent, " ");
- if (addressprint)
- {
- if (TARGET_ADDR_BIT <= 32)
- strcat (wrap_indent, " ");
- else
- strcat (wrap_indent, " ");
- }
-
- printf_filtered ("%-3d %-3s ", t->number,
- t->enabled_p ? "y" : "n");
- if (addressprint)
- {
- char *tmp;
-
- if (TARGET_ADDR_BIT <= 32)
- tmp = local_hex_string_custom (t->address
- & (CORE_ADDR) 0xffffffff,
- "08l");
- else
- tmp = local_hex_string_custom (t->address, "016l");
-
- printf_filtered ("%s ", tmp);
- }
- printf_filtered ("%-5d %-5ld ", t->pass_count, t->step_count);
-
- if (t->source_file)
- {
- sym = find_pc_sect_function (t->address, t->section);
- if (sym)
- {
- fputs_filtered ("in ", gdb_stdout);
- fputs_filtered (SYMBOL_SOURCE_NAME (sym), gdb_stdout);
- wrap_here (wrap_indent);
- fputs_filtered (" at ", gdb_stdout);
- }
- fputs_filtered (t->source_file, gdb_stdout);
- printf_filtered (":%d", t->line_number);
- }
- else
- print_address_symbolic (t->address, gdb_stdout, demangle, " ");
-
- printf_filtered ("\n");
- if (t->actions)
- {
- printf_filtered (" Actions for tracepoint %d: \n", t->number);
- for (action = t->actions; action; action = action->next)
- {
- printf_filtered ("\t%s\n", action->action);
- }
- }
- }
- if (!found_a_tracepoint)
- {
- if (tpnum == -1)
- printf_filtered ("No tracepoints.\n");
- else
- printf_filtered ("No tracepoint number %d.\n", tpnum);
- }
-}
-
-/* Optimization: the code to parse an enable, disable, or delete TP command
- is virtually identical except for whether it performs an enable, disable,
- or delete. Therefore I've combined them into one function with an opcode.
- */
-enum tracepoint_opcode
-{
- enable_op,
- disable_op,
- delete_op
-};
-
-/* This function implements enable, disable and delete commands. */
-static void
-tracepoint_operation (struct tracepoint *t, int from_tty,
- enum tracepoint_opcode opcode)
-{
- struct tracepoint *t2;
-
- if (t == NULL) /* no tracepoint operand */
- return;
-
- switch (opcode)
- {
- case enable_op:
- t->enabled_p = 1;
- tracepoint_modify_event (t->number);
- break;
- case disable_op:
- t->enabled_p = 0;
- tracepoint_modify_event (t->number);
- break;
- case delete_op:
- if (tracepoint_chain == t)
- tracepoint_chain = t->next;
-
- ALL_TRACEPOINTS (t2)
- if (t2->next == t)
- {
- tracepoint_delete_event (t2->number);
- t2->next = t->next;
- break;
- }
-
- if (t->addr_string)
- xfree (t->addr_string);
- if (t->source_file)
- xfree (t->source_file);
- if (t->actions)
- free_actions (t);
-
- xfree (t);
- break;
- }
-}
-
-/* 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 (char **arg, int multi_p, int optional_p)
-{
- struct tracepoint *t;
- int tpnum;
- char *instring = arg == NULL ? NULL : *arg;
+ /* Save linenumber as "$trace_line", a debugger variable visible to
+ users. */
+ set_internalvar_integer (lookup_internalvar ("trace_line"),
+ traceframe_sal.line);
- if (arg == NULL || *arg == NULL || ! **arg)
- {
- if (optional_p)
- tpnum = tracepoint_count;
- else
- error_no_arg ("tracepoint number");
- }
+ /* Save func name as "$trace_func", a debugger variable visible to
+ users. */
+ if (traceframe_fun == NULL
+ || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
+ clear_internalvar (lookup_internalvar ("trace_func"));
else
- tpnum = multi_p ? get_number_or_range (arg) : get_number (arg);
-
- if (tpnum <= 0)
- {
- 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;
-}
-
-/* Utility: parse a list of tracepoint numbers, and call a func for each. */
-static void
-map_args_over_tracepoints (char *args, int from_tty,
- enum tracepoint_opcode opcode)
-{
- struct tracepoint *t, *tmp;
-
- if (args == 0 || *args == 0) /* do them all */
- ALL_TRACEPOINTS_SAFE (t, tmp)
- tracepoint_operation (t, from_tty, opcode);
- else
- while (*args)
- {
- QUIT; /* give user option to bail out with ^C */
- t = get_tracepoint_by_number (&args, 1, 0);
- tracepoint_operation (t, from_tty, opcode);
- while (*args == ' ' || *args == '\t')
- args++;
- }
-}
-
-/* The 'enable trace' command enables tracepoints. Not supported by all targets. */
-static void
-enable_trace_command (char *args, int from_tty)
-{
- dont_repeat ();
- map_args_over_tracepoints (args, from_tty, enable_op);
-}
-
-/* The 'disable trace' command enables tracepoints. Not supported by all targets. */
-static void
-disable_trace_command (char *args, int from_tty)
-{
- dont_repeat ();
- map_args_over_tracepoints (args, from_tty, disable_op);
-}
-
-/* Remove a tracepoint (or all if no argument) */
-static void
-delete_trace_command (char *args, int from_tty)
-{
- dont_repeat ();
- 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_op);
-}
-
-/* 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 (char *args, int from_tty)
-{
- struct tracepoint *t1 = (struct tracepoint *) -1, *t2;
- unsigned int count;
- int all = 0;
-
- if (args == 0 || *args == 0)
- error ("passcount command requires an argument (count + optional TP num)");
-
- count = strtoul (args, &args, 10); /* count comes first, then TP num */
-
- while (*args && isspace ((int) *args))
- args++;
-
- if (*args && strncasecmp (args, "all", 3) == 0)
- {
- args += 3; /* skip special argument "all" */
- all = 1;
- if (*args)
- error ("Junk at end of arguments.");
- }
+ set_internalvar_string (lookup_internalvar ("trace_func"),
+ SYMBOL_LINKAGE_NAME (traceframe_fun));
+
+ /* Save file name as "$trace_file", a debugger variable visible to
+ users. */
+ if (traceframe_sal.symtab == NULL
+ || traceframe_sal.symtab->filename == NULL)
+ clear_internalvar (lookup_internalvar ("trace_file"));
else
- t1 = get_tracepoint_by_number (&args, 1, 1);
-
- do
- {
- if (t1)
- {
- ALL_TRACEPOINTS (t2)
- if (t1 == (struct tracepoint *) -1 || t1 == t2)
- {
- t2->pass_count = count;
- tracepoint_modify_event (t2->number);
- 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);
+ set_internalvar_string (lookup_internalvar ("trace_file"),
+ traceframe_sal.symtab->filename);
}
/* ACTIONS functions: */
/* Prototypes for action-parsing utility commands */
-static void read_actions (struct tracepoint *);
+static void read_actions (struct breakpoint *);
/* The three functions:
collect_pseudocommand,
it means that somebody issued the "command" at the top level,
which is always an error. */
-static void
+void
end_actions_pseudocommand (char *args, int from_tty)
{
- error ("This command cannot be used at the top level.");
+ error (_("This command cannot be used at the top level."));
}
-static void
+void
while_stepping_pseudocommand (char *args, int from_tty)
{
- error ("This command can only be used in a tracepoint actions list.");
+ error (_("This command can only be used in a tracepoint actions list."));
}
static void
collect_pseudocommand (char *args, int from_tty)
{
- error ("This command can only be used in a tracepoint actions list.");
+ 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 (char *args, int from_tty)
{
- struct tracepoint *t;
+ struct breakpoint *t;
char tmpbuf[128];
char *end_msg = "End with a line saying just \"end\".";
if (from_tty)
{
- if (readline_begin_hook)
- (*readline_begin_hook) ("%s %s\n", tmpbuf, end_msg);
+ if (deprecated_readline_begin_hook)
+ (*deprecated_readline_begin_hook) ("%s %s\n", tmpbuf, end_msg);
else if (input_from_terminal_p ())
printf_filtered ("%s\n%s\n", tmpbuf, end_msg);
}
t->step_count = 0; /* read_actions may set this */
read_actions (t);
- if (readline_end_hook)
- (*readline_end_hook) ();
+ if (deprecated_readline_end_hook)
+ (*deprecated_readline_end_hook) ();
/* tracepoints_changed () */
}
/* else just return */
/* worker function */
static void
-read_actions (struct tracepoint *t)
+read_actions (struct breakpoint *t)
{
char *line;
char *prompt1 = "> ", *prompt2 = " > ";
isn't declared. Leave this alone for now. */
#ifdef STOP_SIGNAL
if (job_control)
- {
- if (event_loop_p)
- signal (STOP_SIGNAL, handle_stop_sig);
- else
- signal (STOP_SIGNAL, stop_sig);
- }
+ signal (STOP_SIGNAL, handle_stop_sig);
#endif
old_chain = make_cleanup_free_actions (t);
while (1)
{
- /* Make sure that all output has been output. Some machines may let
- you get away with leaving out some of the gdb_flush, but not all. */
+ /* Make sure that all output has been output. Some machines may
+ let you get away with leaving out some of the gdb_flush, but
+ not all. */
wrap_here ("");
gdb_flush (gdb_stdout);
gdb_flush (gdb_stderr);
- if (readline_hook && instream == NULL)
- line = (*readline_hook) (prompt);
+ if (deprecated_readline_hook && instream == NULL)
+ line = (*deprecated_readline_hook) (prompt);
else if (instream == stdin && ISATTY (instream))
{
line = gdb_readline_wrapper (prompt);
else
line = gdb_readline (0);
+ if (!line)
+ {
+ line = xstrdup ("end");
+ printf_filtered ("end\n");
+ }
+
linetype = validate_actionline (&line, t);
if (linetype == BADLINE)
continue; /* already warned -- collect another line */
{
if (prompt == prompt2)
{
- warning ("Already processing 'while-stepping'");
+ warning (_("Already processing 'while-stepping'"));
continue;
}
else
{ /* 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. */
+ /* An "end" all by itself with no other actions
+ means this tracepoint has no actions.
+ Discard empty list. */
free_actions (t);
}
break;
/* worker function */
enum actionline_type
-validate_actionline (char **line, struct tracepoint *t)
+validate_actionline (char **line, struct breakpoint *t)
{
struct cmd_list_element *c;
struct expression *exp = NULL;
struct cleanup *old_chain = NULL;
char *p;
+ /* if EOF is typed, *line is NULL */
+ if (*line == NULL)
+ return END;
+
for (p = *line; isspace ((int) *p);)
p++;
- /* symbol lookup etc. */
- if (*p == '\0') /* empty line: just prompt for another line. */
+ /* Symbol lookup etc. */
+ if (*p == '\0') /* empty line: just prompt for another line. */
return BADLINE;
if (*p == '#') /* comment line */
c = lookup_cmd (&p, cmdlist, "", -1, 1);
if (c == 0)
{
- warning ("'%s' is not an action that I know, or is ambiguous.", p);
+ warning (_("'%s' is not an action that I know, or is ambiguous."),
+ p);
return BADLINE;
}
p = strchr (p, ',');
continue;
}
- /* else fall thru, treat p as an expression and parse it! */
+ /* else fall thru, treat p as an expression and parse it! */
}
- exp = parse_exp_1 (&p, block_for_pc (t->address), 1);
+ exp = parse_exp_1 (&p, block_for_pc (t->loc->address), 1);
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 ("constant %s (value %ld) will not be collected.",
- SYMBOL_NAME (exp->elts[2].symbol),
+ warning (_("constant %s (value %ld) will not be collected."),
+ SYMBOL_PRINT_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));
+ warning (_("%s is optimized away and cannot be collected."),
+ SYMBOL_PRINT_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);
+ /* 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->loc->address, exp);
make_cleanup_free_agent_expr (aexpr);
if (aexpr->len > MAX_AGENT_EXPR_LEN)
- error ("expression too complicated, try simplifying");
+ error (_("expression too complicated, try simplifying"));
ax_reqs (aexpr, &areqs);
(void) make_cleanup (xfree, areqs.reg_mask);
if (areqs.flaw != agent_flaw_none)
- error ("malformed expression");
+ error (_("malformed expression"));
if (areqs.min_height < 0)
- error ("gdb: Internal error: expression has min height < 0");
+ error (_("gdb: Internal error: expression has min height < 0"));
if (areqs.max_height > 20)
- error ("expression too complicated, try simplifying");
+ error (_("expression too complicated, try simplifying"));
do_cleanups (old_chain);
}
if (*p == '\0' ||
(t->step_count = strtol (p, &p, 0)) == 0)
{
- warning ("'%s': bad step-count; command ignored.", *line);
+ warning (_("'%s': bad step-count; command ignored."), *line);
return BADLINE;
}
return STEPPING;
return END;
else
{
- warning ("'%s' is not a supported tracepoint action.", *line);
+ warning (_("'%s' is not a supported tracepoint action."), *line);
return BADLINE;
}
}
/* worker function */
void
-free_actions (struct tracepoint *t)
+free_actions (struct breakpoint *t)
{
struct action_line *line, *next;
}
static struct cleanup *
-make_cleanup_free_actions (struct tracepoint *t)
+make_cleanup_free_actions (struct breakpoint *t)
{
return make_cleanup (do_free_actions_cleanup, t);
}
+enum {
+ memrange_absolute = -1
+};
+
struct memrange
{
- int type; /* 0 for absolute memory range, else basereg number */
+ int type; /* memrange_absolute for absolute memory range,
+ else basereg number */
bfd_signed_vma start;
bfd_signed_vma end;
};
struct collection_list
{
- unsigned char regs_mask[8]; /* room for up to 256 regs */
+ unsigned char regs_mask[32]; /* room for up to 256 regs */
long listsize;
long next_memrange;
struct memrange *list;
return -1;
if (a->type > b->type)
return 1;
- if (a->type == 0)
+ if (a->type == memrange_absolute)
{
if ((bfd_vma) a->start < (bfd_vma) b->start)
return -1;
return 0;
}
-/* Sort the memrange list using qsort, and merge adjacent memranges */
+/* Sort the memrange list using qsort, and merge adjacent memranges. */
static void
memrange_sortmerge (struct collection_list *memranges)
{
{
if (memranges->list[a].type == memranges->list[b].type &&
memranges->list[b].start - memranges->list[a].end <=
- MAX_REGISTER_VIRTUAL_SIZE)
+ MAX_REGISTER_SIZE)
{
/* memrange b starts before memrange a ends; merge them. */
if (memranges->list[b].end > memranges->list[a].end)
}
}
-/* Add a register to a collection list */
+/* Add a register to a collection list. */
static void
add_register (struct collection_list *collection, unsigned int regno)
{
if (info_verbose)
printf_filtered ("collect register %d\n", regno);
- if (regno > (8 * sizeof (collection->regs_mask)))
- error ("Internal: register number %d too large for tracepoint",
+ if (regno >= (8 * sizeof (collection->regs_mask)))
+ error (_("Internal: register number %d too large for tracepoint"),
regno);
collection->regs_mask[regno / 8] |= 1 << (regno % 8);
}
/* Add a memrange to a collection list */
static void
-add_memrange (struct collection_list *memranges, int type, bfd_signed_vma base,
+add_memrange (struct collection_list *memranges,
+ int type, bfd_signed_vma base,
unsigned long len)
{
if (info_verbose)
printf_filtered (",%ld)\n", len);
}
- /* type: 0 == memory, n == basereg */
+ /* type: memrange_absolute == memory, other n == basereg */
memranges->list[memranges->next_memrange].type = type;
- /* base: addr if memory, offset if reg relative. */
+ /* base: addr if memory, offset if reg relative. */
memranges->list[memranges->next_memrange].start = base;
/* len: we actually save end (base + len) for convenience */
memranges->list[memranges->next_memrange].end = base + len;
memranges->listsize);
}
- if (type != -1) /* better collect the base register! */
+ if (type != memrange_absolute) /* Better collect the base register! */
add_register (memranges, type);
}
-/* Add a symbol to a collection list */
+/* Add a symbol to a collection list. */
static void
-collect_symbol (struct collection_list *collect, struct symbol *sym,
+collect_symbol (struct collection_list *collect,
+ struct symbol *sym,
+ struct gdbarch *gdbarch,
long frame_regno, long frame_offset)
{
unsigned long len;
{
default:
printf_filtered ("%s: don't know symbol class %d\n",
- SYMBOL_NAME (sym), SYMBOL_CLASS (sym));
+ SYMBOL_PRINT_NAME (sym),
+ SYMBOL_CLASS (sym));
break;
case LOC_CONST:
printf_filtered ("constant %s (value %ld) will not be collected.\n",
- SYMBOL_NAME (sym), SYMBOL_VALUE (sym));
+ SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE (sym));
break;
case LOC_STATIC:
offset = SYMBOL_VALUE_ADDRESS (sym);
sprintf_vma (tmp, offset);
printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
- SYMBOL_NAME (sym), len, tmp /* address */);
+ SYMBOL_PRINT_NAME (sym), len,
+ tmp /* address */);
}
- add_memrange (collect, -1, offset, len); /* 0 == memory */
+ add_memrange (collect, memrange_absolute, offset, len);
break;
case LOC_REGISTER:
- case LOC_REGPARM:
- reg = SYMBOL_VALUE (sym);
+ reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
if (info_verbose)
- printf_filtered ("LOC_REG[parm] %s: ", SYMBOL_NAME (sym));
+ printf_filtered ("LOC_REG[parm] %s: ",
+ SYMBOL_PRINT_NAME (sym));
add_register (collect, reg);
- /* check for doubles stored in two registers */
- /* FIXME: how about larger types stored in 3 or more regs? */
+ /* 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))
+ len > register_size (gdbarch, reg))
add_register (collect, reg + 1);
break;
case LOC_REF_ARG:
printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
printf_filtered (" (will not collect %s)\n",
- SYMBOL_NAME (sym));
+ SYMBOL_PRINT_NAME (sym));
break;
case LOC_ARG:
reg = frame_regno;
if (info_verbose)
{
printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
- SYMBOL_NAME (sym), len);
+ SYMBOL_PRINT_NAME (sym), len);
printf_vma (offset);
printf_filtered (" from frame ptr reg %d\n", reg);
}
if (info_verbose)
{
printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
- SYMBOL_NAME (sym), len);
+ SYMBOL_PRINT_NAME (sym), len);
printf_vma (offset);
printf_filtered (" from reg %d\n", reg);
}
add_memrange (collect, reg, offset, len);
break;
case LOC_LOCAL:
- case LOC_LOCAL_ARG:
reg = frame_regno;
offset = frame_offset + SYMBOL_VALUE (sym);
if (info_verbose)
{
printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
- SYMBOL_NAME (sym), len);
+ SYMBOL_PRINT_NAME (sym), len);
printf_vma (offset);
printf_filtered (" from frame ptr reg %d\n", reg);
}
add_memrange (collect, reg, offset, len);
break;
- case LOC_BASEREG:
- case LOC_BASEREG_ARG:
- reg = SYMBOL_BASEREG (sym);
- offset = SYMBOL_VALUE (sym);
- if (info_verbose)
- {
- 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;
case LOC_UNRESOLVED:
- printf_filtered ("Don't know LOC_UNRESOLVED %s\n", SYMBOL_NAME (sym));
+ printf_filtered ("Don't know LOC_UNRESOLVED %s\n",
+ SYMBOL_PRINT_NAME (sym));
break;
case LOC_OPTIMIZED_OUT:
printf_filtered ("%s has been optimized out of existence.\n",
- SYMBOL_NAME (sym));
+ SYMBOL_PRINT_NAME (sym));
break;
}
}
/* Add all locals (or args) symbols to collection list */
static void
-add_local_symbols (struct collection_list *collect, CORE_ADDR pc,
+add_local_symbols (struct collection_list *collect,
+ struct gdbarch *gdbarch, CORE_ADDR pc,
long frame_regno, long frame_offset, int type)
{
struct symbol *sym;
struct block *block;
- int i, count = 0;
+ struct dict_iterator iter;
+ int count = 0;
block = block_for_pc (pc);
while (block != 0)
{
QUIT; /* allow user to bail out with ^C */
- ALL_BLOCK_SYMBOLS (block, i, sym)
+ ALL_BLOCK_SYMBOLS (block, iter, sym)
{
- switch (SYMBOL_CLASS (sym))
+ if (SYMBOL_IS_ARGUMENT (sym)
+ ? type == 'A' /* collecting Arguments */
+ : type == 'L') /* collecting Locals */
{
- default:
- warning ("don't know how to trace local symbol %s",
- SYMBOL_NAME (sym));
- case LOC_LOCAL:
- case LOC_STATIC:
- case LOC_REGISTER:
- case LOC_BASEREG:
- if (type == 'L') /* collecting Locals */
- {
- count++;
- collect_symbol (collect, sym, frame_regno, frame_offset);
- }
- break;
- case LOC_ARG:
- case LOC_LOCAL_ARG:
- case LOC_REF_ARG:
- case LOC_REGPARM:
- case LOC_REGPARM_ADDR:
- case LOC_BASEREG_ARG:
- if (type == 'A') /* collecting Arguments */
- {
- count++;
- collect_symbol (collect, sym, frame_regno, frame_offset);
- }
+ count++;
+ collect_symbol (collect, sym, gdbarch,
+ frame_regno, frame_offset);
}
}
if (BLOCK_FUNCTION (block))
block = BLOCK_SUPERBLOCK (block);
}
if (count == 0)
- warning ("No %s found in scope.", type == 'L' ? "locals" : "args");
+ warning (_("No %s found in scope."),
+ type == 'L' ? "locals" : "args");
}
/* worker function */
sprintf (end, "%02X", list->regs_mask[i]);
end += 2;
}
- (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
+ (*str_list)[ndx] = xstrdup (temp_buf);
ndx++;
}
if (info_verbose)
end = temp_buf;
}
- sprintf (end, "M%X,%s,%lX",
- list->list[i].type,
- tmp2,
- (long) (list->list[i].end - list->list[i].start));
+ {
+ bfd_signed_vma length = list->list[i].end - list->list[i].start;
+
+ /* The "%X" conversion specifier expects an unsigned argument,
+ so passing -1 (memrange_absolute) to it directly gives you
+ "FFFFFFFF" (or more, depending on sizeof (unsigned)).
+ Special-case it. */
+ if (list->list[i].type == memrange_absolute)
+ sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
+ else
+ sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
+ }
count += strlen (end);
- end += count;
+ end = temp_buf + count;
}
for (i = 0; i < list->next_aexpr_elt; i++)
end += 10; /* 'X' + 8 hex digits + ',' */
count += 10;
- end = mem2hex (list->aexpr_list[i]->buf, end, list->aexpr_list[i]->len);
+ end = mem2hex (list->aexpr_list[i]->buf,
+ end, list->aexpr_list[i]->len);
count += 2 * list->aexpr_list[i]->len;
}
(*str_list)[ndx] = NULL;
if (ndx == 0)
- return NULL;
+ {
+ xfree (str_list);
+ return NULL;
+ }
else
return *str_list;
}
xfree (actions_list);
}
-/* render all actions into gdb protocol */
+/* Render all actions into gdb protocol. */
static void
-encode_actions (struct tracepoint *t, char ***tdp_actions,
+encode_actions (struct breakpoint *t, char ***tdp_actions,
char ***stepping_actions)
{
static char tdp_buff[2048], step_buff[2048];
*tdp_actions = NULL;
*stepping_actions = NULL;
- TARGET_VIRTUAL_FRAME_POINTER (t->address, &frame_reg, &frame_offset);
+ gdbarch_virtual_frame_pointer (t->gdbarch,
+ t->loc->address, &frame_reg, &frame_offset);
for (action = t->actions; action; action = action->next)
{
cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
if (cmd == 0)
- error ("Bad action list item: %s", action_exp);
+ error (_("Bad action list item: %s"), action_exp);
if (cmd_cfunc_eq (cmd, collect_pseudocommand))
{
if (0 == strncasecmp ("$reg", action_exp, 4))
{
- for (i = 0; i < NUM_REGS; i++)
+ for (i = 0; i < gdbarch_num_regs (t->gdbarch); i++)
add_register (collect, i);
action_exp = strchr (action_exp, ','); /* more? */
}
else if (0 == strncasecmp ("$arg", action_exp, 4))
{
add_local_symbols (collect,
- t->address,
+ t->gdbarch,
+ t->loc->address,
frame_reg,
frame_offset,
'A');
else if (0 == strncasecmp ("$loc", action_exp, 4))
{
add_local_symbols (collect,
- t->address,
+ t->gdbarch,
+ t->loc->address,
frame_reg,
frame_offset,
'L');
struct agent_reqs areqs;
exp = parse_exp_1 (&action_exp,
- block_for_pc (t->address), 1);
+ block_for_pc (t->loc->address), 1);
old_chain = make_cleanup (free_current_contents, &exp);
switch (exp->elts[0].opcode)
{
case OP_REGISTER:
- i = exp->elts[1].longconst;
- if (info_verbose)
- printf_filtered ("OP_REGISTER: ");
- add_register (collect, i);
- break;
+ {
+ const char *name = &exp->elts[2].string;
+
+ i = user_reg_map_name_to_regnum (t->gdbarch,
+ name, strlen (name));
+ if (i == -1)
+ internal_error (__FILE__, __LINE__,
+ _("Register $%s not available"),
+ name);
+ 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);
+ addr = value_address (tempval);
len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
- add_memrange (collect, -1, addr, len);
+ add_memrange (collect, memrange_absolute, addr, len);
break;
case OP_VAR_VALUE:
collect_symbol (collect,
exp->elts[2].symbol,
+ t->gdbarch,
frame_reg,
frame_offset);
break;
default: /* full-fledged expression */
- aexpr = gen_trace_for_expr (t->address, exp);
+ aexpr = gen_trace_for_expr (t->loc->address, exp);
old_chain1 = make_cleanup_free_agent_expr (aexpr);
ax_reqs (aexpr, &areqs);
if (areqs.flaw != agent_flaw_none)
- error ("malformed expression");
+ error (_("malformed expression"));
if (areqs.min_height < 0)
- error ("gdb: Internal error: expression has min height < 0");
+ error (_("gdb: Internal error: expression has min height < 0"));
if (areqs.max_height > 20)
- error ("expression too complicated, try simplifying");
+ error (_("expression too complicated, try simplifying"));
discard_cleanups (old_chain1);
add_aexpr (collect, aexpr);
for (ndx2 = 0; ndx2 < 8; ndx2++)
if (areqs.reg_mask[ndx1] & (1 << ndx2))
/* it's used -- record it */
- add_register (collect, ndx1 * 8 + ndx2);
+ add_register (collect,
+ ndx1 * 8 + ndx2);
}
}
}
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 void
collect->next_aexpr_elt++;
}
-static char target_buf[2048];
+static char *target_buf;
+static long target_buf_size;
/* Set "transparent" memory ranges
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. */
+ return; /* No information to give. */
strcpy (target_buf, "QTro");
for (s = exec_bfd->sections; s; s = s->next)
anysecs = 1;
lma = s->lma;
- size = bfd_get_section_size_before_reloc (s);
+ size = bfd_get_section_size (s);
sprintf_vma (tmp1, lma);
sprintf_vma (tmp2, lma + size);
sprintf (target_buf + strlen (target_buf),
if (anysecs)
{
putpkt (target_buf);
- getpkt (target_buf, sizeof (target_buf), 0);
+ getpkt (&target_buf, &target_buf_size, 0);
}
}
to the target. If no errors,
Tell target to start a new trace experiment. */
+void download_tracepoint (struct breakpoint *t);
+
static void
trace_start_command (char *args, int from_tty)
-{ /* STUB_COMM MOSTLY_IMPLEMENTED */
- struct tracepoint *t;
- char buf[2048];
- char **tdp_actions;
- char **stepping_actions;
- int ndx;
- struct cleanup *old_chain = NULL;
+{
+ VEC(breakpoint_p) *tp_vec = NULL;
+ int ix;
+ struct breakpoint *t;
- dont_repeat (); /* like "run", dangerous to repeat accidentally */
+ dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
if (target_is_remote ())
{
putpkt ("QTinit");
- remote_get_noisy_reply (target_buf, sizeof (target_buf));
+ remote_get_noisy_reply (&target_buf, &target_buf_size);
if (strcmp (target_buf, "OK"))
- error ("Target does not support this command.");
+ error (_("Target does not support this command."));
- ALL_TRACEPOINTS (t)
- {
- char tmp[40];
-
- sprintf_vma (tmp, t->address);
- sprintf (buf, "QTDP:%x:%s:%c:%lx:%x", t->number, tmp, /* address */
- t->enabled_p ? 'E' : 'D',
- t->step_count, t->pass_count);
-
- if (t->actions)
- strcat (buf, "-");
- putpkt (buf);
- remote_get_noisy_reply (target_buf, sizeof (target_buf));
- if (strcmp (target_buf, "OK"))
- error ("Target does not support tracepoints.");
-
- if (t->actions)
- {
- encode_actions (t, &tdp_actions, &stepping_actions);
- old_chain = make_cleanup (free_actions_list_cleanup_wrapper,
- tdp_actions);
- (void) make_cleanup (free_actions_list_cleanup_wrapper,
- stepping_actions);
-
- /* do_single_steps (t); */
- if (tdp_actions)
- {
- for (ndx = 0; tdp_actions[ndx]; ndx++)
- {
- QUIT; /* allow user to bail out with ^C */
- 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, sizeof (target_buf));
- if (strcmp (target_buf, "OK"))
- error ("Error on target while setting tracepoints.");
- }
- }
- if (stepping_actions)
- {
- for (ndx = 0; stepping_actions[ndx]; ndx++)
- {
- QUIT; /* allow user to bail out with ^C */
- 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, sizeof (target_buf));
- if (strcmp (target_buf, "OK"))
- error ("Error on target while setting tracepoints.");
- }
- }
+ tp_vec = all_tracepoints ();
+ for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
+ {
+ download_tracepoint (t);
+ }
+ VEC_free (breakpoint_p, tp_vec);
- do_cleanups (old_chain);
- }
- }
- /* Tell target to treat text-like sections as transparent */
+ /* Tell target to treat text-like sections as transparent. */
remote_set_transparent_ranges ();
- /* Now insert traps and begin collecting data */
+ /* Now insert traps and begin collecting data. */
putpkt ("QTStart");
- remote_get_noisy_reply (target_buf, sizeof (target_buf));
+ remote_get_noisy_reply (&target_buf, &target_buf_size);
if (strcmp (target_buf, "OK"))
- error ("Bogus reply from target: %s", target_buf);
- set_traceframe_num (-1); /* all old traceframes invalidated */
+ error (_("Bogus reply from target: %s"), target_buf);
+ set_traceframe_num (-1); /* All old traceframes invalidated. */
set_tracepoint_num (-1);
- set_traceframe_context (-1);
+ set_traceframe_context (NULL);
trace_running_p = 1;
- if (trace_start_stop_hook)
- trace_start_stop_hook (1, from_tty);
+ if (deprecated_trace_start_stop_hook)
+ deprecated_trace_start_stop_hook (1, from_tty);
}
else
- error ("Trace can only be run on remote targets.");
+ error (_("Trace can only be run on remote targets."));
+}
+
+/* Send the definition of a single tracepoint to the target. */
+
+void
+download_tracepoint (struct breakpoint *t)
+{
+ char tmp[40];
+ char buf[2048];
+ char **tdp_actions;
+ char **stepping_actions;
+ int ndx;
+ struct cleanup *old_chain = NULL;
+ struct agent_expr *aexpr;
+ struct cleanup *aexpr_chain = NULL;
+
+ sprintf_vma (tmp, (t->loc ? t->loc->address : 0));
+ sprintf (buf, "QTDP:%x:%s:%c:%lx:%x", t->number,
+ tmp, /* address */
+ (t->enable_state == bp_enabled ? 'E' : 'D'),
+ t->step_count, t->pass_count);
+ /* If the tracepoint has a conditional, make it into an agent
+ expression and append to the definition. */
+ if (t->loc->cond)
+ {
+ /* Only test support at download time, we may not know target
+ capabilities at definition time. */
+ if (remote_supports_cond_tracepoints ())
+ {
+ aexpr = gen_eval_for_expr (t->loc->address, t->loc->cond);
+ aexpr_chain = make_cleanup_free_agent_expr (aexpr);
+ sprintf (buf + strlen (buf), ":X%x,", aexpr->len);
+ mem2hex (aexpr->buf, buf + strlen (buf), aexpr->len);
+ do_cleanups (aexpr_chain);
+ }
+ else
+ warning (_("Target does not support conditional tracepoints, ignoring tp %d cond"), t->number);
+ }
+
+ if (t->actions)
+ strcat (buf, "-");
+ putpkt (buf);
+ remote_get_noisy_reply (&target_buf, &target_buf_size);
+ if (strcmp (target_buf, "OK"))
+ error (_("Target does not support tracepoints."));
+
+ if (!t->actions)
+ return;
+
+ encode_actions (t, &tdp_actions, &stepping_actions);
+ old_chain = make_cleanup (free_actions_list_cleanup_wrapper,
+ tdp_actions);
+ (void) make_cleanup (free_actions_list_cleanup_wrapper, stepping_actions);
+
+ /* do_single_steps (t); */
+ if (tdp_actions)
+ {
+ for (ndx = 0; tdp_actions[ndx]; ndx++)
+ {
+ QUIT; /* allow user to bail out with ^C */
+ 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,
+ &target_buf_size);
+ if (strcmp (target_buf, "OK"))
+ error (_("Error on target while setting tracepoints."));
+ }
+ }
+ if (stepping_actions)
+ {
+ for (ndx = 0; stepping_actions[ndx]; ndx++)
+ {
+ QUIT; /* allow user to bail out with ^C */
+ 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,
+ &target_buf_size);
+ if (strcmp (target_buf, "OK"))
+ error (_("Error on target while setting tracepoints."));
+ }
+ }
+ do_cleanups (old_chain);
}
/* tstop command */
static void
trace_stop_command (char *args, int from_tty)
-{ /* STUB_COMM IS_IMPLEMENTED */
+{
if (target_is_remote ())
{
putpkt ("QTStop");
- remote_get_noisy_reply (target_buf, sizeof (target_buf));
+ remote_get_noisy_reply (&target_buf, &target_buf_size);
if (strcmp (target_buf, "OK"))
- error ("Bogus reply from target: %s", target_buf);
+ error (_("Bogus reply from target: %s"), target_buf);
trace_running_p = 0;
- if (trace_start_stop_hook)
- trace_start_stop_hook (0, from_tty);
+ if (deprecated_trace_start_stop_hook)
+ deprecated_trace_start_stop_hook (0, from_tty);
}
else
- error ("Trace can only be run on remote targets.");
+ error (_("Trace can only be run on remote targets."));
}
unsigned long trace_running_p;
/* tstatus command */
static void
trace_status_command (char *args, int from_tty)
-{ /* STUB_COMM IS_IMPLEMENTED */
+{
if (target_is_remote ())
{
putpkt ("qTStatus");
- remote_get_noisy_reply (target_buf, sizeof (target_buf));
+ remote_get_noisy_reply (&target_buf, &target_buf_size);
if (target_buf[0] != 'T' ||
(target_buf[1] != '0' && target_buf[1] != '1'))
- error ("Bogus reply from target: %s", target_buf);
+ 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.");
+ error (_("Trace can only be run on remote targets."));
}
-/* Worker function for the various flavors of the tfind command */
+/* Worker function for the various flavors of the tfind command. */
static void
-finish_tfind_command (char *msg,
- long sizeof_msg,
+finish_tfind_command (char **msg,
+ long *sizeof_msg,
int from_tty)
{
int target_frameno = -1, target_tracept = -1;
- CORE_ADDR old_frame_addr;
- struct symbol *old_func;
+ struct frame_id old_frame_id;
char *reply;
- old_frame_addr = get_frame_base (get_current_frame ());
- old_func = find_pc_function (read_pc ());
+ old_frame_id = get_frame_id (get_current_frame ());
- putpkt (msg);
+ putpkt (*msg);
reply = remote_get_noisy_reply (msg, sizeof_msg);
while (reply && *reply)
and then continue on to do something else. */
if (from_tty)
- error ("Target failed to find requested trace frame.");
+ 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 */
+ /* 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) */
+ reply = NULL; /* Break out of loop
+ (avoid recursive nonsense). */
}
}
break;
case 'T':
if ((target_tracept = (int) strtol (++reply, &reply, 16)) == -1)
- error ("Target failed to find requested trace frame.");
+ 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);
+ error (_("Bogus reply from target: %s"), reply);
break;
default:
- error ("Bogus reply from target: %s", reply);
+ error (_("Bogus reply from target: %s"), reply);
}
- flush_cached_frames ();
+ reinit_frame_cache ();
registers_changed ();
- select_frame (get_current_frame ());
set_traceframe_num (target_frameno);
set_tracepoint_num (target_tracept);
if (target_frameno == -1)
- set_traceframe_context (-1);
+ set_traceframe_context (NULL);
else
- set_traceframe_context (read_pc ());
+ set_traceframe_context (get_current_frame ());
if (from_tty)
{
- int source_only;
+ enum print_what print_what;
/* 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 ||
- get_frame_base (get_current_frame ()) == 0 ||
- old_frame_addr == get_frame_base (get_current_frame ())))
- source_only = -1;
+ 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. */
+
+ if (frame_id_eq (old_frame_id,
+ get_frame_id (get_current_frame ())))
+ print_what = SRC_LINE;
else
- source_only = 1;
+ print_what = SRC_AND_LOC;
- print_stack_frame (deprecated_selected_frame,
- frame_relative_level (deprecated_selected_frame),
- source_only);
+ print_stack_frame (get_selected_frame (NULL), 1, print_what);
do_displays ();
}
}
/* tfind command */
static void
trace_find_command (char *args, int from_tty)
-{ /* STUB_COMM PART_IMPLEMENTED */
- /* this should only be called with a numeric argument */
+{ /* this should only be called with a numeric argument */
int frameno = -1;
if (target_is_remote ())
{
- if (trace_find_hook)
- trace_find_hook (args, from_tty);
+ if (deprecated_trace_find_hook)
+ deprecated_trace_find_hook (args, from_tty);
if (args == 0 || *args == 0)
- { /* TFIND with no args means find NEXT trace frame. */
+ { /* TFIND with no args means find NEXT trace frame. */
if (traceframe_number == -1)
frameno = 0; /* "next" is first one */
else
else if (0 == strcmp (args, "-"))
{
if (traceframe_number == -1)
- error ("not debugging trace buffer");
+ error (_("not debugging trace buffer"));
else if (from_tty && traceframe_number == 0)
- error ("already at start of trace buffer");
+ error (_("already at start of trace buffer"));
frameno = traceframe_number - 1;
}
frameno = parse_and_eval_long (args);
if (frameno < -1)
- error ("invalid input (%d is less than zero)", frameno);
+ error (_("invalid input (%d is less than zero)"), frameno);
sprintf (target_buf, "QTFrame:%x", frameno);
- finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
+ finish_tfind_command (&target_buf, &target_buf_size, from_tty);
}
else
- error ("Trace can only be run on remote targets.");
+ error (_("Trace can only be run on remote targets."));
}
/* tfind end */
/* tfind pc command */
static void
trace_find_pc_command (char *args, int from_tty)
-{ /* STUB_COMM PART_IMPLEMENTED */
+{
CORE_ADDR pc;
char tmp[40];
if (target_is_remote ())
{
if (args == 0 || *args == 0)
- pc = read_pc (); /* default is current pc */
+ pc = regcache_read_pc (get_current_regcache ());
else
pc = parse_and_eval_address (args);
sprintf_vma (tmp, pc);
sprintf (target_buf, "QTFrame:pc:%s", tmp);
- finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
+ finish_tfind_command (&target_buf, &target_buf_size, from_tty);
}
else
- error ("Trace can only be run on remote targets.");
+ error (_("Trace can only be run on remote targets."));
}
/* tfind tracepoint command */
static void
trace_find_tracepoint_command (char *args, int from_tty)
-{ /* STUB_COMM PART_IMPLEMENTED */
+{
int tdp;
if (target_is_remote ())
if (args == 0 || *args == 0)
{
if (tracepoint_number == -1)
- error ("No current tracepoint -- please supply an argument.");
+ error (_("No current tracepoint -- please supply an argument."));
else
tdp = tracepoint_number; /* default is current TDP */
}
tdp = parse_and_eval_long (args);
sprintf (target_buf, "QTFrame:tdp:%x", tdp);
- finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
+ finish_tfind_command (&target_buf, &target_buf_size, from_tty);
}
else
- error ("Trace can only be run on remote targets.");
+ 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).
+ 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 (char *args, int from_tty)
-{ /* STUB_COMM PART_IMPLEMENTED */
+{
static CORE_ADDR start_pc, end_pc;
struct symtabs_and_lines sals;
struct symtab_and_line sal;
{
if (args == 0 || *args == 0)
{
- sal = find_pc_line ((get_current_frame ())->pc, 0);
+ sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
sals.nelts = 1;
sals.sals = (struct symtab_and_line *)
xmalloc (sizeof (struct symtab_and_line));
old_chain = make_cleanup (xfree, sals.sals);
if (sal.symtab == 0)
{
+ struct gdbarch *gdbarch = get_current_arch ();
+
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. */
+ /* 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);
+ print_address (gdbarch, 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? */
+ return; /* No line, no PC; what can we do? */
}
}
else if (sal.line > 0
&& find_line_pc_range (sal, &start_pc, &end_pc))
{
+ struct gdbarch *gdbarch = get_objfile_arch (sal.symtab->objfile);
+
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);
+ print_address (gdbarch, start_pc, gdb_stdout);
wrap_here (" ");
printf_filtered (" but contains no code.\n");
sal = find_pc_line (start_pc, 0);
printf_filtered ("Attempting to find line %d instead.\n",
sal.line);
else
- error ("Cannot find a good line.");
+ 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",
+ 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\"."),
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:%s:%s", startpc_str, endpc_str);
- else /* find OUTSIDE OF range of CURRENT line */
- sprintf (target_buf, "QTFrame:outside:%s:%s", startpc_str, endpc_str);
- finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
+ /* Find within range of stated line. */
+ if (args && *args)
+ sprintf (target_buf, "QTFrame:range:%s:%s",
+ startpc_str, endpc_str);
+ /* Find OUTSIDE OF range of CURRENT line. */
+ else
+ sprintf (target_buf, "QTFrame:outside:%s:%s",
+ startpc_str, endpc_str);
+ finish_tfind_command (&target_buf, &target_buf_size,
+ from_tty);
do_cleanups (old_chain);
}
else
- error ("Trace can only be run on remote targets.");
+ error (_("Trace can only be run on remote targets."));
}
/* tfind range command */
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;
}
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);
+ finish_tfind_command (&target_buf, &target_buf_size, from_tty);
}
else
- error ("Trace can only be run on remote targets.");
+ error (_("Trace can only be run on remote targets."));
}
/* tfind outside command */
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;
}
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);
+ finish_tfind_command (&target_buf, &target_buf_size, from_tty);
}
else
- error ("Trace can only be run on remote targets.");
-}
-
-/* save-tracepoints command */
-static void
-tracepoint_save_command (char *args, int from_tty)
-{
- struct tracepoint *tp;
- struct action_line *line;
- FILE *fp;
- char *i1 = " ", *i2 = " ";
- char *indent, *actionline, *pathname;
- char tmp[40];
-
- if (args == 0 || *args == 0)
- error ("Argument required (file name in which to save tracepoints");
-
- if (tracepoint_chain == 0)
- {
- warning ("save-tracepoints: no tracepoints to save.\n");
- return;
- }
-
- pathname = tilde_expand (args);
- if (!(fp = fopen (pathname, "w")))
- error ("Unable to open file '%s' for saving tracepoints (%s)",
- args, safe_strerror (errno));
- xfree (pathname);
-
- ALL_TRACEPOINTS (tp)
- {
- if (tp->addr_string)
- fprintf (fp, "trace %s\n", tp->addr_string);
- else
- {
- sprintf_vma (tmp, tp->address);
- fprintf (fp, "trace *0x%s\n", tmp);
- }
-
- if (tp->pass_count)
- fprintf (fp, " passcount %d\n", tp->pass_count);
-
- if (tp->actions)
- {
- fprintf (fp, " actions\n");
- 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 ((int) *actionline))
- actionline++;
-
- fprintf (fp, "%s%s\n", indent, actionline);
- 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_cfunc_eq (cmd, while_stepping_pseudocommand))
- indent = i2;
- else if (cmd_cfunc_eq (cmd, end_actions_pseudocommand))
- indent = i1;
- }
- }
- }
- }
- fclose (fp);
- if (from_tty)
- printf_filtered ("Tracepoints saved to file '%s'.\n", args);
- return;
+ error (_("Trace can only be run on remote targets."));
}
/* info scope command: list the locals for a scope. */
struct minimal_symbol *msym;
struct block *block;
char **canonical, *symname, *save_args = args;
- int i, j, count = 0;
+ struct dict_iterator iter;
+ int j, count = 0;
+ struct gdbarch *gdbarch;
+ int regno;
if (args == 0 || *args == 0)
- error ("requires an argument (function, line or *addr) to define a scope");
+ error (_("requires an argument (function, line or *addr) to define a scope"));
- sals = decode_line_1 (&args, 1, NULL, 0, &canonical);
+ sals = decode_line_1 (&args, 1, NULL, 0, &canonical, NULL);
if (sals.nelts == 0)
- return; /* presumably decode_line_1 has already warned */
+ return; /* presumably decode_line_1 has already warned */
/* Resolve line numbers to PC */
resolve_sal_pc (&sals.sals[0]);
while (block != 0)
{
QUIT; /* allow user to bail out with ^C */
- ALL_BLOCK_SYMBOLS (block, i, sym)
+ ALL_BLOCK_SYMBOLS (block, iter, sym)
{
QUIT; /* allow user to bail out with ^C */
if (count == 0)
printf_filtered ("Scope for %s:\n", save_args);
count++;
- symname = SYMBOL_NAME (sym);
+ symname = SYMBOL_PRINT_NAME (sym);
if (symname == NULL || *symname == '\0')
continue; /* probably botched, certainly useless */
+ gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
+
printf_filtered ("Symbol %s is ", symname);
switch (SYMBOL_CLASS (sym))
{
break;
case LOC_STATIC:
printf_filtered ("in static storage at address ");
- print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
+ printf_filtered ("%s", paddress (gdbarch,
+ SYMBOL_VALUE_ADDRESS (sym)));
break;
case LOC_REGISTER:
- printf_filtered ("a local variable in register $%s",
- REGISTER_NAME (SYMBOL_VALUE (sym)));
+ /* GDBARCH is the architecture associated with the objfile
+ the symbol is defined in; the target architecture may be
+ different, and may provide additional registers. However,
+ we do not know the target architecture at this point.
+ We assume the objfile architecture will contain all the
+ standard registers that occur in debug info in that
+ objfile. */
+ regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
+
+ if (SYMBOL_IS_ARGUMENT (sym))
+ printf_filtered ("an argument in register $%s",
+ gdbarch_register_name (gdbarch, regno));
+ else
+ printf_filtered ("a local variable in register $%s",
+ gdbarch_register_name (gdbarch, regno));
break;
case LOC_ARG:
- case LOC_LOCAL_ARG:
printf_filtered ("an argument at stack/frame offset %ld",
SYMBOL_VALUE (sym));
break;
printf_filtered ("a reference argument at offset %ld",
SYMBOL_VALUE (sym));
break;
- case LOC_REGPARM:
- printf_filtered ("an argument in register $%s",
- REGISTER_NAME (SYMBOL_VALUE (sym)));
- break;
case LOC_REGPARM_ADDR:
+ /* Note comment at LOC_REGISTER. */
+ regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
printf_filtered ("the address of an argument, in register $%s",
- REGISTER_NAME (SYMBOL_VALUE (sym)));
+ gdbarch_register_name (gdbarch, regno));
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);
+ printf_filtered ("%s", paddress (gdbarch,
+ SYMBOL_VALUE_ADDRESS (sym)));
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 %ld from register $%s",
- SYMBOL_VALUE (sym),
- REGISTER_NAME (SYMBOL_BASEREG (sym)));
- break;
- case LOC_BASEREG_ARG:
- printf_filtered ("an argument at offset %ld from register $%s",
- SYMBOL_VALUE (sym),
- REGISTER_NAME (SYMBOL_BASEREG (sym)));
+ printf_filtered ("%s",
+ paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
break;
case LOC_UNRESOLVED:
- msym = lookup_minimal_symbol (SYMBOL_NAME (sym), NULL, NULL);
+ msym = lookup_minimal_symbol (SYMBOL_LINKAGE_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);
+ printf_filtered ("%s",
+ paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
}
break;
case LOC_OPTIMIZED_OUT:
printf_filtered ("optimized out.\n");
continue;
+ case LOC_COMPUTED:
+ SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, gdb_stdout);
+ break;
}
if (SYMBOL_TYPE (sym))
printf_filtered (", length %d.\n",
- TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
+ TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
}
if (BLOCK_FUNCTION (block))
break;
static void
trace_dump_command (char *args, int from_tty)
{
- struct tracepoint *t;
+ struct regcache *regcache;
+ struct gdbarch *gdbarch;
+ struct breakpoint *t;
struct action_line *action;
char *action_exp, *next_comma;
struct cleanup *old_cleanups;
if (!target_is_remote ())
{
- error ("Trace can only be run on remote targets.");
+ error (_("Trace can only be run on remote targets."));
return;
}
if (tracepoint_number == -1)
{
- warning ("No current trace frame.");
+ warning (_("No current trace frame."));
return;
}
- ALL_TRACEPOINTS (t)
- if (t->number == tracepoint_number)
- break;
+ t = get_tracepoint (tracepoint_number);
if (t == NULL)
- error ("No known tracepoint matches 'current' tracepoint #%d.",
+ error (_("No known tracepoint matches 'current' tracepoint #%d."),
tracepoint_number);
old_cleanups = make_cleanup (null_cleanup, NULL);
to the tracepoint PC. If not, then the current frame was
collected during single-stepping. */
- stepping_frame = (t->address != read_pc ());
+ regcache = get_current_regcache ();
+ gdbarch = get_regcache_arch (regcache);
+
+ stepping_frame = (t->loc->address != (regcache_read_pc (regcache)
+ - gdbarch_decr_pc_after_break (gdbarch)));
for (action = t->actions; action; action = action->next)
{
cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
if (cmd == 0)
- error ("Bad action list item: %s", action_exp);
+ error (_("Bad action list item: %s"), action_exp);
if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
stepping_actions = 1;
else if (cmd_cfunc_eq (cmd, 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. */
+ 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
static const char hexchars[] = "0123456789abcdef";
-static unsigned char *
-mem2hex (unsigned char *mem, unsigned char *buf, int count)
+static char *
+mem2hex (gdb_byte *mem, char *buf, int count)
{
- unsigned char ch;
+ gdb_byte ch;
while (count-- > 0)
{
{
struct cmd_list_element *c;
- tracepoint_chain = 0;
- tracepoint_count = 0;
traceframe_number = -1;
tracepoint_number = -1;
- 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) - 1));
-
if (tracepoint_list.list == NULL)
{
tracepoint_list.listsize = 128;
}
add_info ("scope", scope_info,
- "List the variables local to a scope");
+ _("List the variables local to a scope"));
add_cmd ("tracepoints", class_trace, NULL,
- "Tracing of program execution without stopping the program.",
+ _("Tracing of program execution without stopping the program."),
&cmdlist);
- add_info ("tracepoints", tracepoints_info,
- "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);
-
- c = 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.");
- set_cmd_completer (c, filename_completer);
-
add_com ("tdump", class_trace, trace_dump_command,
- "Print everything collected at the current tracepoint.");
+ _("Print everything collected at the current tracepoint."));
- 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.",
+ add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
+Select a trace frame;\n\
+No argument means forward by one frame; '-' means backward by one frame."),
&tfindlist, "tfind ", 1, &cmdlist);
- add_cmd ("outside", class_trace, trace_find_outside_command,
- "Select a trace frame whose PC is outside the given \
-range.\nUsage: tfind outside addr1, addr2",
+ add_cmd ("outside", class_trace, trace_find_outside_command, _("\
+Select a trace frame whose PC is outside the given range.\n\
+Usage: tfind outside addr1, addr2"),
&tfindlist);
- add_cmd ("range", class_trace, trace_find_range_command,
- "Select a trace frame whose PC is in the given range.\n\
-Usage: tfind range addr1,addr2",
+ add_cmd ("range", class_trace, trace_find_range_command, _("\
+Select a trace frame whose PC is in the given range.\n\
+Usage: tfind range addr1,addr2"),
&tfindlist);
- add_cmd ("line", class_trace, trace_find_line_command,
- "Select a trace frame by source line.\n\
+ 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'.",
+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.",
+ 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.\n\
-Default is the current PC, or the PC of the current trace frame.",
+ add_cmd ("pc", class_trace, trace_find_pc_command, _("\
+Select a trace frame by PC.\n\
+Default is the current PC, or the PC of the current trace frame."),
&tfindlist);
- add_cmd ("end", class_trace, trace_find_end_command,
- "Synonym for 'none'.\n\
-De-select any trace frame and resume 'live' debugging.",
+ 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.",
+ _("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.",
+ _("Select the first trace frame in the trace buffer."),
&tfindlist);
add_com ("tstatus", class_trace, trace_status_command,
- "Display the status of the current trace data collection.");
+ _("Display the status of the current trace data collection."));
add_com ("tstop", class_trace, trace_stop_command,
- "Stop trace data collection.");
+ _("Stop trace data collection."));
add_com ("tstart", class_trace, trace_start_command,
- "Start 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\
-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\
+ 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.");
+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\
+ 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.");
+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\
+ 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) 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\
-Note: this command can only be used in a tracepoint \"actions\" list.");
+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\
+ add_com ("actions", class_trace, trace_actions_command, _("\
+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.\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.\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.\n\
-Arguments are tracepoint numbers, separated by spaces.\n\
-No argument means enable all tracepoints.",
- &enablelist);
-
- c = add_com ("trace", class_trace, trace_command,
- "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.");
- set_cmd_completer (c, location_completer);
-
- 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);
+depending on target's capabilities."));
+
+ target_buf_size = 2048;
+ target_buf = xmalloc (target_buf_size);
}
projects / deliverable / binutils-gdb.git / blobdiff