#include "probe.h"
#include "ctf.h"
#include "completer.h"
+#include "filestuff.h"
/* readline include files */
#include "readline/readline.h"
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);
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. */
/* 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];
static void
encode_actions_1 (struct command_line *action,
- struct breakpoint *t,
struct bp_location *tloc,
int frame_reg,
LONGEST frame_offset,
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
/* Render all actions into gdb protocol. */
void
-encode_actions (struct breakpoint *t, struct bp_location *tloc,
- char ***tdp_actions, char ***stepping_actions)
+encode_actions (struct bp_location *tloc, char ***tdp_actions,
+ char ***stepping_actions)
{
- static char tdp_buff[2048], step_buff[2048];
char *default_collect_line = NULL;
struct command_line *actions;
struct command_line *default_collect_action = NULL;
gdbarch_virtual_frame_pointer (tloc->gdbarch,
tloc->address, &frame_reg, &frame_offset);
- actions = breakpoint_commands (t);
+ actions = breakpoint_commands (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
default_collect_line = xstrprintf ("collect %s", default_collect);
make_cleanup (xfree, default_collect_line);
- validate_actionline (default_collect_line, t);
+ validate_actionline (default_collect_line, tloc->owner);
default_collect_action = xmalloc (sizeof (struct command_line));
make_cleanup (xfree, default_collect_action);
default_collect_action->line = default_collect_line;
actions = default_collect_action;
}
- encode_actions_1 (actions, t, tloc, frame_reg, frame_offset,
+ encode_actions_1 (actions, tloc, frame_reg, frame_offset,
&tracepoint_list, &stepping_list);
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);
+ *stepping_actions = stringify_collection_list (&stepping_list);
do_cleanups (back_to);
}
}
}
-/* 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,
/* Worker function for the various flavors of the tfind command. */
void
tfind_1 (enum trace_find_type type, int num,
- ULONGEST addr1, ULONGEST addr2,
+ CORE_ADDR addr1, CORE_ADDR addr2,
int from_tty)
{
int target_frameno = -1, target_tracept = -1;
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));
= (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);
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);
value of a collected PC register, but if not available, we
improvise. */
-static ULONGEST
+static CORE_ADDR
tfile_get_traceframe_address (off_t tframe_offset)
{
- ULONGEST addr = 0;
+ CORE_ADDR addr = 0;
short tpnum;
struct tracepoint *tp;
off_t saved_offset = cur_offset;
static int
tfile_trace_find (enum trace_find_type type, int num,
- ULONGEST addr1, ULONGEST addr2, int *tpp)
+ CORE_ADDR addr1, CORE_ADDR addr2, int *tpp)
{
short tpnum;
int tfnum = 0, found = 0;
unsigned int data_size;
struct tracepoint *tp;
off_t offset, tframe_offset;
- ULONGEST tfaddr;
+ CORE_ADDR tfaddr;
if (num == -1)
{
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. */
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;
}
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);