/* Tracing functionality for remote targets in custom GDB protocol
Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
- 2007 Free Software Foundation, Inc.
+ 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., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "symtab.h"
#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 "ax.h"
#include "ax-gdb.h"
extern void (*deprecated_readline_begin_hook) (char *, ...);
extern char *(*deprecated_readline_hook) (char *);
extern void (*deprecated_readline_end_hook) (void);
-extern int addressprint; /* Print machine addresses? */
/* GDB commands implemented in other modules:
*/
{
tracepoint_count = num;
set_internalvar (lookup_internalvar ("tpnum"),
- value_from_longest (builtin_type_int, (LONGEST) num));
+ value_from_longest (builtin_type_int32, (LONGEST) num));
}
/* Set traceframe number to NUM. */
{
traceframe_number = num;
set_internalvar (lookup_internalvar ("trace_frame"),
- value_from_longest (builtin_type_int, (LONGEST) num));
+ value_from_longest (builtin_type_int32, (LONGEST) num));
}
/* Set tracepoint number to NUM. */
{
tracepoint_number = num;
set_internalvar (lookup_internalvar ("tracepoint"),
- value_from_longest (builtin_type_int,
- (LONGEST) num));
+ value_from_longest (builtin_type_int32, (LONGEST) num));
}
/* Set externally visible debug variables for querying/printing
static struct type *func_range, *file_range;
struct value *func_val;
struct value *file_val;
- static struct type *charstar;
int len;
- if (charstar == (struct type *) NULL)
- charstar = lookup_pointer_type (builtin_type_char);
-
if (trace_pc == -1) /* Cease debugging any trace buffers. */
{
traceframe_fun = 0;
traceframe_sal.pc = traceframe_sal.line = 0;
traceframe_sal.symtab = NULL;
set_internalvar (lookup_internalvar ("trace_func"),
- value_from_pointer (charstar, (LONGEST) 0));
+ allocate_value (builtin_type_void));
set_internalvar (lookup_internalvar ("trace_file"),
- value_from_pointer (charstar, (LONGEST) 0));
+ allocate_value (builtin_type_void));
set_internalvar (lookup_internalvar ("trace_line"),
- value_from_longest (builtin_type_int,
+ value_from_longest (builtin_type_int32,
(LONGEST) - 1));
return;
}
/* Save linenumber as "$trace_line", a debugger variable visible to
users. */
set_internalvar (lookup_internalvar ("trace_line"),
- value_from_longest (builtin_type_int,
+ value_from_longest (builtin_type_int32,
(LONGEST) traceframe_sal.line));
/* Save func name as "$trace_func", a debugger variable visible to
users. */
if (traceframe_fun == NULL ||
- DEPRECATED_SYMBOL_NAME (traceframe_fun) == NULL)
+ SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
set_internalvar (lookup_internalvar ("trace_func"),
- value_from_pointer (charstar, (LONGEST) 0));
+ allocate_value (builtin_type_void));
else
{
- len = strlen (DEPRECATED_SYMBOL_NAME (traceframe_fun));
+ len = strlen (SYMBOL_LINKAGE_NAME (traceframe_fun));
func_range = create_range_type (func_range,
- builtin_type_int, 0, len - 1);
+ builtin_type_int32, 0, len - 1);
func_string = create_array_type (func_string,
- builtin_type_char, func_range);
+ builtin_type_true_char, func_range);
func_val = allocate_value (func_string);
deprecated_set_value_type (func_val, func_string);
memcpy (value_contents_raw (func_val),
- DEPRECATED_SYMBOL_NAME (traceframe_fun),
+ SYMBOL_LINKAGE_NAME (traceframe_fun),
len);
deprecated_set_value_modifiable (func_val, 0);
set_internalvar (lookup_internalvar ("trace_func"), func_val);
if (traceframe_sal.symtab == NULL ||
traceframe_sal.symtab->filename == NULL)
set_internalvar (lookup_internalvar ("trace_file"),
- value_from_pointer (charstar, (LONGEST) 0));
+ allocate_value (builtin_type_void));
else
{
len = strlen (traceframe_sal.symtab->filename);
file_range = create_range_type (file_range,
- builtin_type_int, 0, len - 1);
+ builtin_type_int32, 0, len - 1);
file_string = create_array_type (file_string,
- builtin_type_char, file_range);
+ builtin_type_true_char, file_range);
file_val = allocate_value (file_string);
deprecated_set_value_type (file_val, file_string);
memcpy (value_contents_raw (file_val),
static void
trace_mention (struct tracepoint *tp)
{
+ struct value_print_options opts;
printf_filtered ("Tracepoint %d", tp->number);
- if (addressprint || (tp->source_file == NULL))
+ get_user_print_options (&opts);
+ if (opts.addressprint || (tp->source_file == NULL))
{
printf_filtered (" at ");
- deprecated_print_address_numeric (tp->address, 1, gdb_stdout);
+ printf_filtered ("%s", paddress (tp->address));
}
if (tp->source_file)
printf_filtered (": file %s, line %d.",
ALL_TRACEPOINTS (t)
if (tpnum == -1 || tpnum == t->number)
{
- extern int addressprint; /* Print machine addresses? */
-
+ struct value_print_options opts;
+ get_user_print_options (&opts);
if (!found_a_tracepoint++)
{
printf_filtered ("Num Enb ");
- if (addressprint)
+ if (opts.addressprint)
{
- if (TARGET_ADDR_BIT <= 32)
+ if (gdbarch_addr_bit (current_gdbarch) <= 32)
printf_filtered ("Address ");
else
printf_filtered ("Address ");
printf_filtered ("PassC StepC What\n");
}
strcpy (wrap_indent, " ");
- if (addressprint)
+ if (opts.addressprint)
{
- if (TARGET_ADDR_BIT <= 32)
+ if (gdbarch_addr_bit (current_gdbarch) <= 32)
strcat (wrap_indent, " ");
else
strcat (wrap_indent, " ");
printf_filtered ("%-3d %-3s ", t->number,
t->enabled_p ? "y" : "n");
- if (addressprint)
+ if (opts.addressprint)
{
char *tmp;
- if (TARGET_ADDR_BIT <= 32)
+ if (gdbarch_addr_bit (current_gdbarch) <= 32)
tmp = hex_string_custom (t->address & (CORE_ADDR) 0xffffffff,
8);
else
{
case enable_op:
t->enabled_p = 1;
- tracepoint_modify_event (t->number);
+ observer_notify_tracepoint_modified (t->number);
break;
case disable_op:
t->enabled_p = 0;
- tracepoint_modify_event (t->number);
+ observer_notify_tracepoint_modified (t->number);
break;
case delete_op:
if (tracepoint_chain == t)
ALL_TRACEPOINTS (t2)
if (t2->next == t)
{
- tracepoint_delete_event (t2->number);
t2->next = t->next;
break;
}
+ observer_notify_tracepoint_deleted (t->number);
+
if (t->addr_string)
xfree (t->addr_string);
if (t->source_file)
if (t1 == (struct tracepoint *) -1 || t1 == t2)
{
t2->pass_count = count;
- tracepoint_modify_event (t2->number);
+ observer_notify_tracepoint_modified (t2->number);
if (from_tty)
printf_filtered ("Setting tracepoint %d's passcount to %d\n",
t2->number, count);
line = gdb_readline (0);
if (!line)
- line = "end";
+ {
+ line = xstrdup ("end");
+ printf_filtered ("end\n");
+ }
linetype = validate_actionline (&line, t);
if (linetype == BADLINE)
if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
{
warning (_("constant %s (value %ld) will not be collected."),
- DEPRECATED_SYMBOL_NAME (exp->elts[2].symbol),
+ 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."),
- DEPRECATED_SYMBOL_NAME (exp->elts[2].symbol));
+ SYMBOL_PRINT_NAME (exp->elts[2].symbol));
return BADLINE;
}
}
{
if (info_verbose)
printf_filtered ("collect register %d\n", regno);
- if (regno > (8 * sizeof (collection->regs_mask)))
+ 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);
{
default:
printf_filtered ("%s: don't know symbol class %d\n",
- DEPRECATED_SYMBOL_NAME (sym),
+ SYMBOL_PRINT_NAME (sym),
SYMBOL_CLASS (sym));
break;
case LOC_CONST:
printf_filtered ("constant %s (value %ld) will not be collected.\n",
- DEPRECATED_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",
- DEPRECATED_SYMBOL_NAME (sym), len,
+ SYMBOL_PRINT_NAME (sym), len,
tmp /* address */);
}
add_memrange (collect, memrange_absolute, offset, len);
break;
case LOC_REGISTER:
- case LOC_REGPARM:
reg = SYMBOL_VALUE (sym);
if (info_verbose)
printf_filtered ("LOC_REG[parm] %s: ",
- DEPRECATED_SYMBOL_NAME (sym));
+ 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? */
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",
- DEPRECATED_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 ",
- DEPRECATED_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 ",
- DEPRECATED_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 ",
- DEPRECATED_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 ",
- DEPRECATED_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",
- DEPRECATED_SYMBOL_NAME (sym));
+ SYMBOL_PRINT_NAME (sym));
break;
case LOC_OPTIMIZED_OUT:
printf_filtered ("%s has been optimized out of existence.\n",
- DEPRECATED_SYMBOL_NAME (sym));
+ SYMBOL_PRINT_NAME (sym));
break;
}
}
QUIT; /* allow user to bail out with ^C */
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"),
- DEPRECATED_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, frame_regno,
+ frame_offset);
}
}
if (BLOCK_FUNCTION (block))
(*str_list)[ndx] = NULL;
if (ndx == 0)
- return NULL;
+ {
+ xfree (str_list);
+ return NULL;
+ }
else
return *str_list;
}
*tdp_actions = NULL;
*stepping_actions = NULL;
- TARGET_VIRTUAL_FRAME_POINTER (t->address, &frame_reg, &frame_offset);
+ gdbarch_virtual_frame_pointer (current_gdbarch,
+ t->address, &frame_reg, &frame_offset);
for (action = t->actions; action; action = action->next)
{
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 (current_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 */
char *i1 = " ", *i2 = " ";
char *indent, *actionline, *pathname;
char tmp[40];
+ struct cleanup *cleanup;
if (args == 0 || *args == 0)
error (_("Argument required (file name in which to save tracepoints)"));
}
pathname = tilde_expand (args);
+ cleanup = make_cleanup (xfree, pathname);
if (!(fp = fopen (pathname, "w")))
error (_("Unable to open file '%s' for saving tracepoints (%s)"),
args, safe_strerror (errno));
- xfree (pathname);
+ make_cleanup_fclose (fp);
ALL_TRACEPOINTS (tp)
{
}
}
}
- fclose (fp);
+ do_cleanups (cleanup);
if (from_tty)
printf_filtered ("Tracepoints saved to file '%s'.\n", args);
return;
printf_filtered ("Scope for %s:\n", save_args);
count++;
- symname = DEPRECATED_SYMBOL_NAME (sym);
+ symname = SYMBOL_PRINT_NAME (sym);
if (symname == NULL || *symname == '\0')
continue; /* probably botched, certainly useless */
break;
case LOC_STATIC:
printf_filtered ("in static storage at address ");
- deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (sym),
- 1, gdb_stdout);
+ printf_filtered ("%s", paddress (SYMBOL_VALUE_ADDRESS (sym)));
break;
case LOC_REGISTER:
- printf_filtered ("a local variable in register $%s",
- gdbarch_register_name
+ if (SYMBOL_IS_ARGUMENT (sym))
+ printf_filtered ("an argument in register $%s",
+ gdbarch_register_name
+ (current_gdbarch, SYMBOL_VALUE (sym)));
+ else
+ printf_filtered ("a local variable in register $%s",
+ gdbarch_register_name
(current_gdbarch, SYMBOL_VALUE (sym)));
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",
- gdbarch_register_name
- (current_gdbarch, SYMBOL_VALUE (sym)));
- break;
case LOC_REGPARM_ADDR:
printf_filtered ("the address of an argument, in register $%s",
gdbarch_register_name
continue;
case LOC_LABEL:
printf_filtered ("a label at address ");
- deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (sym),
- 1, gdb_stdout);
+ printf_filtered ("%s", paddress (SYMBOL_VALUE_ADDRESS (sym)));
break;
case LOC_BLOCK:
printf_filtered ("a function at address ");
- deprecated_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),
- gdbarch_register_name
- (current_gdbarch, SYMBOL_BASEREG (sym)));
- break;
- case LOC_BASEREG_ARG:
- printf_filtered ("an argument at offset %ld from register $%s",
- SYMBOL_VALUE (sym),
- gdbarch_register_name
- (current_gdbarch, SYMBOL_BASEREG (sym)));
+ printf_filtered ("%s", paddress (BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
break;
case LOC_UNRESOLVED:
- msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym),
+ msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
NULL, NULL);
if (msym == NULL)
printf_filtered ("Unresolved Static");
else
{
printf_filtered ("static storage at address ");
- deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (msym), 1,
- gdb_stdout);
+ printf_filtered ("%s", paddress (SYMBOL_VALUE_ADDRESS (msym)));
}
break;
case LOC_OPTIMIZED_OUT:
printf_filtered ("optimized out.\n");
continue;
- case LOC_HP_THREAD_LOCAL_STATIC:
- printf_filtered ("HP thread local static ");
- break;
- case LOC_INDIRECT:
- printf_filtered ("extern (local indirect) at address ");
- deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (sym),
- 1, gdb_stdout);
- break;
case LOC_COMPUTED:
- case LOC_COMPUTED_ARG:
SYMBOL_OPS (sym)->describe_location (sym, gdb_stdout);
break;
}
static void
trace_dump_command (char *args, int from_tty)
{
+ struct regcache *regcache;
+ struct gdbarch *gdbarch;
struct tracepoint *t;
struct action_line *action;
char *action_exp, *next_comma;
to the tracepoint PC. If not, then the current frame was
collected during single-stepping. */
- stepping_frame = (t->address != (read_pc () - gdbarch_decr_pc_after_break
- (current_gdbarch)));
+ regcache = get_current_regcache ();
+ gdbarch = get_regcache_arch (regcache);
+
+ stepping_frame = (t->address != (regcache_read_pc (regcache)
+ - gdbarch_decr_pc_after_break (gdbarch)));
for (action = t->actions; action; action = action->next)
{