#include "gdbcmd.h"
#include "value.h"
#include "target.h"
+#include "target-dcache.h"
#include "language.h"
-#include "gdb_string.h"
+#include <string.h>
#include "inferior.h"
#include "breakpoint.h"
#include "tracepoint.h"
#include "probe.h"
#include "ctf.h"
#include "completer.h"
+#include "filestuff.h"
/* readline include files */
#include "readline/readline.h"
/* readline defines this. */
#undef savestring
-#ifdef HAVE_UNISTD_H
#include <unistd.h>
-#endif
#ifndef O_LARGEFILE
#define O_LARGEFILE 0
large. (400 - 31)/2 == 184 */
#define MAX_AGENT_EXPR_LEN 184
-#define TFILE_PID (1)
-
/* A hook used to notify the UI of tracepoint operations. */
void (*deprecated_trace_find_hook) (char *arg, int from_tty);
void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
-extern void (*deprecated_readline_begin_hook) (char *, ...);
-extern char *(*deprecated_readline_hook) (char *);
-extern void (*deprecated_readline_end_hook) (void);
-
/*
Tracepoint.c:
typedef struct trace_state_variable tsv_s;
DEF_VEC_O(tsv_s);
-/* An object describing the contents of a traceframe. */
-
-struct traceframe_info
-{
- /* Collected memory. */
- VEC(mem_range_s) *memory;
-};
-
static VEC(tsv_s) *tvariables;
/* The next integer to assign to a variable. */
/* Tracepoint for last traceframe collected. */
static int tracepoint_number;
-/* Symbol for function for last traceframe collected. */
-static struct symbol *traceframe_fun;
-
-/* Symtab and line for last traceframe collected. */
-static struct symtab_and_line traceframe_sal;
-
/* The traceframe info of the current traceframe. NULL if we haven't
yet attempted to fetch it, or if the target does not support
fetching this object, or if we're not inspecting a traceframe
static void free_uploaded_tps (struct uploaded_tp **utpp);
static void free_uploaded_tsvs (struct uploaded_tsv **utsvp);
+static struct command_line *
+ all_tracepoint_actions_and_cleanup (struct breakpoint *t);
extern void _initialize_tracepoint (void);
if (info != NULL)
{
VEC_free (mem_range_s, info->memory);
+ VEC_free (int, info->tvars);
xfree (info);
}
set_traceframe_context (struct frame_info *trace_frame)
{
CORE_ADDR trace_pc;
+ struct symbol *traceframe_fun;
+ struct symtab_and_line traceframe_sal;
/* Save as globals for internal use. */
if (trace_frame != NULL
return NULL;
}
+/* Look for a trace state variable of the given number. Return NULL if
+ not found. */
+
+struct trace_state_variable *
+find_trace_state_variable_by_number (int number)
+{
+ struct trace_state_variable *tsv;
+ int ix;
+
+ for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
+ if (tsv->number == number)
+ return tsv;
+
+ return NULL;
+}
+
static void
delete_trace_state_variable (const char *name)
{
memrange_absolute = -1
};
-struct memrange
-{
- 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[32]; /* room for up to 256 regs */
- long listsize;
- long next_memrange;
- struct memrange *list;
- long aexpr_listsize; /* size of array pointed to by expr_list elt */
- long next_aexpr_elt;
- struct agent_expr **aexpr_list;
-
- /* True is the user requested a collection of "$_sdata", "static
- tracepoint data". */
- int strace_data;
- }
-tracepoint_list, stepping_list;
-
/* MEMRANGE functions: */
static int memrange_cmp (const void *, const void *);
collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
p->frame_offset, p->pc, p->trace_string);
p->count++;
+
+ VEC_safe_push (char_ptr, p->collect->wholly_collected,
+ xstrdup (print_name));
}
/* Add all locals (or args) symbols to collection list. */
list->next_aexpr_elt = 0;
memset (list->regs_mask, 0, sizeof (list->regs_mask));
list->strace_data = 0;
+
+ xfree (list->aexpr_list);
+ xfree (list->list);
+
+ VEC_free (char_ptr, list->wholly_collected);
+ VEC_free (char_ptr, list->computed);
+}
+
+/* A cleanup wrapper for function clear_collection_list. */
+
+static void
+do_clear_collection_list (void *list)
+{
+ struct collection_list *l = list;
+
+ clear_collection_list (l);
+}
+
+/* Initialize collection_list CLIST. */
+
+static void
+init_collection_list (struct collection_list *clist)
+{
+ memset (clist, 0, sizeof *clist);
+
+ clist->listsize = 128;
+ clist->list = xcalloc (clist->listsize,
+ sizeof (struct memrange));
+
+ clist->aexpr_listsize = 128;
+ clist->aexpr_list = xcalloc (clist->aexpr_listsize,
+ sizeof (struct agent_expr *));
}
/* Reduce a collection list to string form (for gdb protocol). */
static char **
-stringify_collection_list (struct collection_list *list, char *string)
+stringify_collection_list (struct collection_list *list)
{
char temp_buf[2048];
char tmp2[40];
return *str_list;
}
+/* Add the printed expression EXP to *LIST. */
+
+static void
+append_exp (struct expression *exp, VEC(char_ptr) **list)
+{
+ struct ui_file *tmp_stream = mem_fileopen ();
+ char *text;
+
+ print_expression (exp, tmp_stream);
+
+ text = ui_file_xstrdup (tmp_stream, NULL);
+
+ VEC_safe_push (char_ptr, *list, text);
+ ui_file_delete (tmp_stream);
+}
static void
encode_actions_1 (struct command_line *action,
- struct breakpoint *t,
struct bp_location *tloc,
int frame_reg,
LONGEST frame_offset,
check_typedef (exp->elts[1].type);
add_memrange (collect, memrange_absolute, addr,
TYPE_LENGTH (exp->elts[1].type));
+ append_exp (exp, &collect->computed);
break;
case OP_VAR_VALUE:
- collect_symbol (collect,
- exp->elts[2].symbol,
- tloc->gdbarch,
- frame_reg,
- frame_offset,
- tloc->address,
- trace_string);
+ {
+ struct symbol *sym = exp->elts[2].symbol;
+ char_ptr name = (char_ptr) SYMBOL_NATURAL_NAME (sym);
+
+ collect_symbol (collect,
+ exp->elts[2].symbol,
+ tloc->gdbarch,
+ frame_reg,
+ frame_offset,
+ tloc->address,
+ trace_string);
+ VEC_safe_push (char_ptr,
+ collect->wholly_collected,
+ name);
+ }
break;
default: /* Full-fledged expression. */
}
}
}
+
+ append_exp (exp, &collect->computed);
break;
} /* switch */
do_cleanups (old_chain);
here. */
gdb_assert (stepping_list);
- encode_actions_1 (action->body_list[0], t, tloc, frame_reg,
+ encode_actions_1 (action->body_list[0], tloc, frame_reg,
frame_offset, stepping_list, NULL);
}
else
} /* for */
}
-/* Render all actions into gdb protocol. */
+/* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
+ and STEPPING_LIST. Return a cleanup pointer to clean up both
+ TRACEPOINT_LIST and STEPPING_LIST. */
-void
-encode_actions (struct breakpoint *t, struct bp_location *tloc,
- char ***tdp_actions, char ***stepping_actions)
+struct cleanup *
+encode_actions_and_make_cleanup (struct bp_location *tloc,
+ struct collection_list *tracepoint_list,
+ struct collection_list *stepping_list)
{
- static char tdp_buff[2048], step_buff[2048];
char *default_collect_line = NULL;
struct command_line *actions;
struct command_line *default_collect_action = NULL;
int frame_reg;
LONGEST frame_offset;
- struct cleanup *back_to;
+ struct cleanup *back_to, *return_chain;
- back_to = make_cleanup (null_cleanup, NULL);
+ return_chain = make_cleanup (null_cleanup, NULL);
+ init_collection_list (tracepoint_list);
+ init_collection_list (stepping_list);
- clear_collection_list (&tracepoint_list);
- clear_collection_list (&stepping_list);
-
- *tdp_actions = NULL;
- *stepping_actions = NULL;
+ make_cleanup (do_clear_collection_list, tracepoint_list);
+ make_cleanup (do_clear_collection_list, stepping_list);
+ back_to = make_cleanup (null_cleanup, NULL);
gdbarch_virtual_frame_pointer (tloc->gdbarch,
tloc->address, &frame_reg, &frame_offset);
- actions = breakpoint_commands (t);
+ actions = all_tracepoint_actions_and_cleanup (tloc->owner);
- /* If there are default expressions to collect, make up a collect
- action and prepend to the action list to encode. Note that since
- validation is per-tracepoint (local var "xyz" might be valid for
- one tracepoint and not another, etc), we make up the action on
- the fly, and don't cache it. */
- if (*default_collect)
- {
- default_collect_line = xstrprintf ("collect %s", default_collect);
- make_cleanup (xfree, default_collect_line);
+ encode_actions_1 (actions, tloc, frame_reg, frame_offset,
+ tracepoint_list, stepping_list);
- validate_actionline (default_collect_line, t);
+ memrange_sortmerge (tracepoint_list);
+ memrange_sortmerge (stepping_list);
- default_collect_action = xmalloc (sizeof (struct command_line));
- make_cleanup (xfree, default_collect_action);
- default_collect_action->next = actions;
- default_collect_action->line = default_collect_line;
- actions = default_collect_action;
- }
- encode_actions_1 (actions, t, tloc, frame_reg, frame_offset,
- &tracepoint_list, &stepping_list);
+ do_cleanups (back_to);
+ return return_chain;
+}
- memrange_sortmerge (&tracepoint_list);
- memrange_sortmerge (&stepping_list);
+/* Render all actions into gdb protocol. */
- *tdp_actions = stringify_collection_list (&tracepoint_list,
- tdp_buff);
- *stepping_actions = stringify_collection_list (&stepping_list,
- step_buff);
+void
+encode_actions_rsp (struct bp_location *tloc, char ***tdp_actions,
+ char ***stepping_actions)
+{
+ struct collection_list tracepoint_list, stepping_list;
+ struct cleanup *cleanup;
- do_cleanups (back_to);
+ *tdp_actions = NULL;
+ *stepping_actions = NULL;
+
+ cleanup = encode_actions_and_make_cleanup (tloc, &tracepoint_list,
+ &stepping_list);
+
+ *tdp_actions = stringify_collection_list (&tracepoint_list);
+ *stepping_actions = stringify_collection_list (&stepping_list);
+
+ do_cleanups (cleanup);
}
static void
" GDB is disconnected\n"));
}
+/* Reset local state of tracing. */
+
+void
+trace_reset_local_state (void)
+{
+ set_traceframe_num (-1);
+ set_tracepoint_num (-1);
+ set_traceframe_context (NULL);
+ clear_traceframe_info ();
+}
void
start_tracing (char *notes)
target_trace_start ();
/* Reset our local state. */
- set_traceframe_num (-1);
- set_tracepoint_num (-1);
- set_traceframe_context (NULL);
+ trace_reset_local_state ();
current_trace_status()->running = 1;
- clear_traceframe_info ();
}
/* The tstart command requests the target to start a new trace run.
/* Reporting a run time is more readable than two long numbers. */
printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
- (long int) ts->start_time / 1000000,
- (long int) ts->start_time % 1000000,
- (long int) run_time / 1000000,
- (long int) run_time % 1000000);
+ (long int) (ts->start_time / 1000000),
+ (long int) (ts->start_time % 1000000),
+ (long int) (run_time / 1000000),
+ (long int) (run_time % 1000000));
}
else
printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
- (long int) ts->start_time / 1000000,
- (long int) ts->start_time % 1000000);
+ (long int) (ts->start_time / 1000000),
+ (long int) (ts->start_time % 1000000));
}
else if (ts->stop_time)
printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
- (long int) ts->stop_time / 1000000,
- (long int) ts->stop_time % 1000000);
+ (long int) (ts->stop_time / 1000000),
+ (long int) (ts->stop_time % 1000000));
/* Now report any per-tracepoint status available. */
tp_vec = all_tracepoints ();
char buf[100];
xsnprintf (buf, sizeof buf, "%ld.%06ld",
- (long int) ts->start_time / 1000000,
- (long int) ts->start_time % 1000000);
+ (long int) (ts->start_time / 1000000),
+ (long int) (ts->start_time % 1000000));
ui_out_field_string (uiout, "start-time", buf);
xsnprintf (buf, sizeof buf, "%ld.%06ld",
- (long int) ts->stop_time / 1000000,
- (long int) ts->stop_time % 1000000);
+ (long int) (ts->stop_time / 1000000),
+ (long int) (ts->stop_time % 1000000));
ui_out_field_string (uiout, "stop-time", buf);
}
}
-/* This function handles the details of what to do about an ongoing
- tracing run if the user has asked to detach or otherwise disconnect
- from the target. */
+/* Check if a trace run is ongoing. If so, and FROM_TTY, query the
+ user if she really wants to detach. */
+
void
-disconnect_tracing (int from_tty)
+query_if_trace_running (int from_tty)
{
+ if (!from_tty)
+ return;
+
/* It can happen that the target that was tracing went away on its
own, and we didn't notice. Get a status update, and if the
current target doesn't even do tracing, then assume it's not
just going to disconnect and let the target deal with it,
according to how it's been instructed previously via
disconnected-tracing. */
- if (current_trace_status ()->running && from_tty)
+ if (current_trace_status ()->running)
{
process_tracepoint_on_disconnect ();
error (_("Not confirmed."));
}
}
+}
+
+/* This function handles the details of what to do about an ongoing
+ tracing run if the user has asked to detach or otherwise disconnect
+ from the target. */
+void
+disconnect_tracing (void)
+{
/* Also we want to be out of tfind mode, otherwise things can get
confusing upon reconnection. Just use these calls instead of
full tfind_1 behavior because we're in the middle of detaching,
and there's no point to updating current stack frame etc. */
- set_current_traceframe (-1);
- set_tracepoint_num (-1);
- set_traceframe_context (NULL);
+ trace_reset_local_state ();
}
/* Worker function for the various flavors of the tfind command. */
else
print_what = SRC_AND_LOC;
- print_stack_frame (get_selected_frame (NULL), 1, print_what);
+ print_stack_frame (get_selected_frame (NULL), 1, print_what, 1);
do_displays ();
}
}
}
}
-/* The tdump command. */
+/* Return bp_location of the tracepoint associated with the current
+ traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
+ is a stepping traceframe. */
-static void
-trace_dump_command (char *args, int from_tty)
+struct bp_location *
+get_traceframe_location (int *stepping_frame_p)
{
- struct regcache *regcache;
struct tracepoint *t;
- int stepping_frame = 0;
- struct bp_location *loc;
- char *default_collect_line = NULL;
- struct command_line *actions, *default_collect_action = NULL;
- struct cleanup *old_chain = NULL;
+ struct bp_location *tloc;
+ struct regcache *regcache;
if (tracepoint_number == -1)
- {
- warning (_("No current trace frame."));
- return;
- }
+ error (_("No current trace frame."));
t = get_tracepoint (tracepoint_number);
error (_("No known tracepoint matches 'current' tracepoint #%d."),
tracepoint_number);
- printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
- tracepoint_number, traceframe_number);
-
- /* The current frame is a trap frame if the frame PC is equal
- to the tracepoint PC. If not, then the current frame was
- collected during single-stepping. */
-
+ /* The current frame is a trap frame if the frame PC is equal to the
+ tracepoint PC. If not, then the current frame was collected
+ during single-stepping. */
regcache = get_current_regcache ();
/* If the traceframe's address matches any of the tracepoint's
locations, assume it is a direct hit rather than a while-stepping
frame. (FIXME this is not reliable, should record each frame's
type.) */
- stepping_frame = 1;
- for (loc = t->base.loc; loc; loc = loc->next)
- if (loc->address == regcache_read_pc (regcache))
- stepping_frame = 0;
+ for (tloc = t->base.loc; tloc; tloc = tloc->next)
+ if (tloc->address == regcache_read_pc (regcache))
+ {
+ *stepping_frame_p = 0;
+ return tloc;
+ }
- actions = breakpoint_commands (&t->base);
+ /* If this is a stepping frame, we don't know which location
+ triggered. The first is as good (or bad) a guess as any... */
+ *stepping_frame_p = 1;
+ return t->base.loc;
+}
+
+/* Return all the actions, including default collect, of a tracepoint
+ T. It constructs cleanups into the chain, and leaves the caller to
+ handle them (call do_cleanups). */
- /* If there is a default-collect list, make up a collect command,
- prepend to the tracepoint's commands, and pass the whole mess to
- the trace dump scanner. We need to validate because
- default-collect might have been junked since the trace run. */
+static struct command_line *
+all_tracepoint_actions_and_cleanup (struct breakpoint *t)
+{
+ struct command_line *actions;
+
+ actions = breakpoint_commands (t);
+
+ /* If there are default expressions to collect, make up a collect
+ action and prepend to the action list to encode. Note that since
+ validation is per-tracepoint (local var "xyz" might be valid for
+ one tracepoint and not another, etc), we make up the action on
+ the fly, and don't cache it. */
if (*default_collect)
{
+ struct command_line *default_collect_action;
+ char *default_collect_line;
+
default_collect_line = xstrprintf ("collect %s", default_collect);
- old_chain = make_cleanup (xfree, default_collect_line);
- validate_actionline (default_collect_line, &t->base);
+ make_cleanup (xfree, default_collect_line);
+
+ validate_actionline (default_collect_line, t);
default_collect_action = xmalloc (sizeof (struct command_line));
make_cleanup (xfree, default_collect_action);
default_collect_action->next = actions;
actions = default_collect_action;
}
+ return actions;
+}
+
+/* The tdump command. */
+
+static void
+trace_dump_command (char *args, int from_tty)
+{
+ int stepping_frame = 0;
+ struct bp_location *loc;
+ struct cleanup *old_chain;
+ struct command_line *actions;
+
+ /* This throws an error is not inspecting a trace frame. */
+ loc = get_traceframe_location (&stepping_frame);
+
+ printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
+ tracepoint_number, traceframe_number);
+
+ old_chain = make_cleanup (null_cleanup, NULL);
+
+ /* This command only makes sense for the current frame, not the
+ selected frame. */
+ make_cleanup_restore_current_thread ();
+ select_frame (get_current_frame ());
+
+ actions = all_tracepoint_actions_and_cleanup (loc->owner);
+
trace_dump_actions (actions, 0, stepping_frame, from_tty);
- if (*default_collect)
- do_cleanups (old_chain);
+ do_cleanups (old_chain);
}
/* Encode a piece of a tracepoint's source-level definition in a form
srctype, 0, (int) strlen (src));
if (strlen (buf) + strlen (src) * 2 >= buf_size)
error (_("Source string too long for buffer"));
- bin2hex (src, buf + strlen (buf), 0);
+ bin2hex ((gdb_byte *) src, buf + strlen (buf), 0);
return -1;
}
= (struct tfile_trace_file_writer *) self;
writer->pathname = tilde_expand (filename);
- writer->fp = fopen (writer->pathname, "wb");
+ writer->fp = gdb_fopen_cloexec (writer->pathname, "wb");
if (writer->fp == NULL)
error (_("Unable to open file '%s' for saving trace data (%s)"),
- filename, safe_strerror (errno));
+ writer->pathname, safe_strerror (errno));
}
/* This is the implementation of trace_file_write_ops method
fprintf (writer->fp, ";disconn:%x", ts->disconnected_tracing);
if (ts->circular_buffer)
fprintf (writer->fp, ";circular:%x", ts->circular_buffer);
+ if (ts->start_time)
+ {
+ fprintf (writer->fp, ";starttime:%s",
+ phex_nz (ts->start_time, sizeof (ts->start_time)));
+ }
+ if (ts->stop_time)
+ {
+ fprintf (writer->fp, ";stoptime:%s",
+ phex_nz (ts->stop_time, sizeof (ts->stop_time)));
+ }
if (ts->notes != NULL)
{
char *buf = (char *) alloca (strlen (ts->notes) * 2 + 1);
= (struct tfile_trace_file_writer *) self;
int a;
char *act;
- gdb_byte buf[MAX_TRACE_UPLOAD];
+ char buf[MAX_TRACE_UPLOAD];
fprintf (writer->fp, "tp T%x:%s:%c:%x:%x",
utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
#define TRACE_WRITE_V_BLOCK(writer, num, val) \
writer->ops->frame_ops->write_v_block ((writer), (num), (val))
-extern int trace_regblock_size;
-
/* Save tracepoint data to file named FILENAME through WRITER. WRITER
determines the trace file format. If TARGET_DOES_SAVE is non-zero,
the save is performed on the target, otherwise GDB obtains all trace
ULONGEST offset = 0;
gdb_byte buf[MAX_TRACE_UPLOAD];
+#define MAX_TRACE_UPLOAD 2000
int written;
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
return traceframe_number;
}
+int
+get_tracepoint_number (void)
+{
+ return tracepoint_number;
+}
+
/* Make the traceframe NUM be the current trace frame. Does nothing
if NUM is already current. */
/* Given a number and address, return an uploaded tracepoint with that
number, creating if necessary. */
-static struct uploaded_tsv *
+struct uploaded_tsv *
get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
{
struct uploaded_tsv *utsv;
int scratch_chan;
char header[TRACE_HEADER_SIZE];
char linebuf[1000]; /* Should be max remote packet size or so. */
- char byte;
+ gdb_byte byte;
int bytes, i;
struct trace_status *ts;
struct uploaded_tp *uploaded_tps = NULL;
flags = O_BINARY | O_LARGEFILE;
flags |= O_RDONLY;
- scratch_chan = open (filename, flags, 0);
+ scratch_chan = gdb_open_cloexec (filename, flags, 0);
if (scratch_chan < 0)
perror_with_name (filename);
}
if (ex.reason < 0)
{
- /* Pop the partially set up target. */
- pop_target ();
+ /* Remove the partially set up target. */
+ unpush_target (&tfile_ops);
throw_exception (ex);
}
- inferior_appeared (current_inferior (), TFILE_PID);
- inferior_ptid = pid_to_ptid (TFILE_PID);
- add_thread_silent (inferior_ptid);
-
if (ts->traceframe_count <= 0)
warning (_("No traceframes present in this file."));
merge_uploaded_trace_state_variables (&uploaded_tsvs);
merge_uploaded_tracepoints (&uploaded_tps);
-
- post_create_inferior (&tfile_ops, from_tty);
}
/* Interpret the given line from the definitions part of the trace
file. */
static void
-tfile_interp_line (char *line,
- struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
+tfile_interp_line (char *line, struct uploaded_tp **utpp,
+ struct uploaded_tsv **utsvp)
{
char *p = line;
else if (p2 != p1)
{
ts->stop_desc = xmalloc (strlen (line));
- end = hex2bin (p1, ts->stop_desc, (p2 - p1) / 2);
+ end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
ts->stop_desc[end] = '\0';
}
else
if (p2 != p1)
{
ts->stop_desc = xmalloc ((p2 - p1) / 2 + 1);
- end = hex2bin (p1, ts->stop_desc, (p2 - p1) / 2);
+ end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
ts->stop_desc[end] = '\0';
}
else
{
++p1;
ts->user_name = xmalloc (strlen (p) / 2);
- end = hex2bin (p1, ts->user_name, (p3 - p1) / 2);
+ end = hex2bin (p1, (gdb_byte *) ts->user_name, (p3 - p1) / 2);
ts->user_name[end] = '\0';
p = p3;
}
{
++p1;
ts->notes = xmalloc (strlen (p) / 2);
- end = hex2bin (p1, ts->notes, (p3 - p1) / 2);
+ end = hex2bin (p1, (gdb_byte *) ts->notes, (p3 - p1) / 2);
ts->notes[end] = '\0';
p = p3;
}
if (trace_fd < 0)
return;
- pid = ptid_get_pid (inferior_ptid);
- inferior_ptid = null_ptid; /* Avoid confusion from thread stuff. */
- exit_inferior_silent (pid);
-
close (trace_fd);
trace_fd = -1;
xfree (trace_filename);
trace_filename = NULL;
+
+ trace_reset_local_state ();
}
static void
unsigned short mlen;
char block_type;
- tfile_read (&block_type, 1);
+ tfile_read ((gdb_byte *) &block_type, 1);
++pos;
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int offset, regn, regsize, pc_regno;
- char *regs;
+ gdb_byte *regs;
/* An uninitialized reg size says we're not going to be
successful at getting register blocks. */
return traceframe_number != -1;
}
-static int
-tfile_thread_alive (struct target_ops *ops, ptid_t ptid)
-{
- return 1;
-}
-
/* Callback for traceframe_walk_blocks. Builds a traceframe_info
object for the tfile target's current traceframe. */
break;
}
case 'V':
+ {
+ int vnum;
+
+ tfile_read ((gdb_byte *) &vnum, 4);
+ VEC_safe_push (int, info->tvars, vnum);
+ }
case 'R':
case 'S':
{
tfile_ops.to_has_stack = tfile_has_stack;
tfile_ops.to_has_registers = tfile_has_registers;
tfile_ops.to_traceframe_info = tfile_traceframe_info;
- tfile_ops.to_thread_alive = tfile_thread_alive;
tfile_ops.to_magic = OPS_MAGIC;
}
r->length = *length_p;
}
+/* Handle the start of a <tvar> element. */
+
+static void
+traceframe_info_start_tvar (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data,
+ VEC(gdb_xml_value_s) *attributes)
+{
+ struct traceframe_info *info = user_data;
+ const char *id_attrib = xml_find_attribute (attributes, "id")->value;
+ int id = gdb_xml_parse_ulongest (parser, id_attrib);
+
+ VEC_safe_push (int, info->tvars, id);
+}
+
/* Discard the constructed trace frame info (if an error occurs). */
static void
{ NULL, GDB_XML_AF_NONE, NULL, NULL }
};
+static const struct gdb_xml_attribute tvar_attributes[] = {
+ { "id", GDB_XML_AF_NONE, NULL, NULL },
+ { NULL, GDB_XML_AF_NONE, NULL, NULL }
+};
+
static const struct gdb_xml_element traceframe_info_children[] = {
{ "memory", memory_attributes, NULL,
GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
traceframe_info_start_memory, NULL },
+ { "tvar", tvar_attributes, NULL,
+ GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
+ traceframe_info_start_tvar, NULL },
{ NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
};
This is where we avoid re-fetching the object from the target if we
already have it cached. */
-static struct traceframe_info *
+struct traceframe_info *
get_traceframe_info (void)
{
if (traceframe_info == NULL)
traceframe_number = -1;
tracepoint_number = -1;
- if (tracepoint_list.list == NULL)
- {
- tracepoint_list.listsize = 128;
- tracepoint_list.list = xmalloc
- (tracepoint_list.listsize * sizeof (struct memrange));
- }
- if (tracepoint_list.aexpr_list == NULL)
- {
- tracepoint_list.aexpr_listsize = 128;
- tracepoint_list.aexpr_list = xmalloc
- (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
- }
-
- if (stepping_list.list == NULL)
- {
- stepping_list.listsize = 128;
- stepping_list.list = xmalloc
- (stepping_list.listsize * sizeof (struct memrange));
- }
-
- if (stepping_list.aexpr_list == NULL)
- {
- stepping_list.aexpr_listsize = 128;
- stepping_list.aexpr_list = xmalloc
- (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
- }
-
add_info ("scope", scope_info,
_("List the variables local to a scope"));
Set requested size of trace buffer."), _("\
Show requested size of trace buffer."), _("\
Use this to choose a size for the trace buffer. Some targets\n\
-may have fixed or limited buffer sizes. A value of -1 disables\n\
-any attempt to set the buffer size and lets the target choose."),
+may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
+disables any attempt to set the buffer size and lets the target choose."),
set_trace_buffer_size, NULL,
&setlist, &showlist);
projects / deliverable / binutils-gdb.git / blobdiff