/* Tracepoint code for remote server for GDB.
- Copyright (C) 2009-2014 Free Software Foundation, Inc.
+ Copyright (C) 2009-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "server.h"
#include "tracepoint.h"
#include "gdbthread.h"
-#include "agent.h"
#include "rsp-low.h"
#include <ctype.h>
#include <fcntl.h>
#include <unistd.h>
-#include <sys/time.h>
+#include <chrono>
#include <inttypes.h>
-#include <stdint.h>
-
#include "ax.h"
#include "tdesc.h"
+#define IPA_SYM_STRUCT_NAME ipa_sym_addresses
+#include "agent.h"
+
#define DEFAULT_TRACE_BUFFER_SIZE 5242880 /* 5*1024*1024 */
/* This file is built for both GDBserver, and the in-process
#define trace_debug(FMT, args...) \
trace_debug_1 (1, FMT, ##args)
-#if defined(__GNUC__)
-# define ATTR_USED __attribute__((used))
-# define ATTR_NOINLINE __attribute__((noinline))
-# define ATTR_CONSTRUCTOR __attribute__ ((constructor))
-#else
-# define ATTR_USED
-# define ATTR_NOINLINE
-# define ATTR_CONSTRUCTOR
-#endif
-
-/* Make sure the functions the IPA needs to export (symbols GDBserver
- needs to query GDB about) are exported. */
-
-#ifdef IN_PROCESS_AGENT
-# if defined _WIN32 || defined __CYGWIN__
-# define IP_AGENT_EXPORT __declspec(dllexport) ATTR_USED
-# else
-# if __GNUC__ >= 4
-# define IP_AGENT_EXPORT \
- __attribute__ ((visibility("default"))) ATTR_USED
-# else
-# define IP_AGENT_EXPORT ATTR_USED
-# endif
-# endif
-#else
-# define IP_AGENT_EXPORT
-#endif
-
/* Prefix exported symbols, for good citizenship. All the symbols
- that need exporting are defined in this module. */
+ that need exporting are defined in this module. Note that all
+ these symbols must be tagged with IP_AGENT_EXPORT_*. */
#ifdef IN_PROCESS_AGENT
-# define gdb_tp_heap_buffer gdb_agent_gdb_tp_heap_buffer
-# define gdb_jump_pad_buffer gdb_agent_gdb_jump_pad_buffer
-# define gdb_jump_pad_buffer_end gdb_agent_gdb_jump_pad_buffer_end
-# define gdb_trampoline_buffer gdb_agent_gdb_trampoline_buffer
-# define gdb_trampoline_buffer_end gdb_agent_gdb_trampoline_buffer_end
-# define gdb_trampoline_buffer_error gdb_agent_gdb_trampoline_buffer_error
-# define collecting gdb_agent_collecting
-# define gdb_collect gdb_agent_gdb_collect
-# define stop_tracing gdb_agent_stop_tracing
-# define flush_trace_buffer gdb_agent_flush_trace_buffer
-# define about_to_request_buffer_space gdb_agent_about_to_request_buffer_space
-# define trace_buffer_is_full gdb_agent_trace_buffer_is_full
-# define stopping_tracepoint gdb_agent_stopping_tracepoint
-# define expr_eval_result gdb_agent_expr_eval_result
-# define error_tracepoint gdb_agent_error_tracepoint
-# define tracepoints gdb_agent_tracepoints
-# define tracing gdb_agent_tracing
-# define trace_buffer_ctrl gdb_agent_trace_buffer_ctrl
-# define trace_buffer_ctrl_curr gdb_agent_trace_buffer_ctrl_curr
-# define trace_buffer_lo gdb_agent_trace_buffer_lo
-# define trace_buffer_hi gdb_agent_trace_buffer_hi
-# define traceframe_read_count gdb_agent_traceframe_read_count
-# define traceframe_write_count gdb_agent_traceframe_write_count
-# define traceframes_created gdb_agent_traceframes_created
-# define trace_state_variables gdb_agent_trace_state_variables
-# define get_raw_reg gdb_agent_get_raw_reg
-# define get_trace_state_variable_value \
- gdb_agent_get_trace_state_variable_value
-# define set_trace_state_variable_value \
- gdb_agent_set_trace_state_variable_value
-# define ust_loaded gdb_agent_ust_loaded
-# define helper_thread_id gdb_agent_helper_thread_id
-# define cmd_buf gdb_agent_cmd_buf
+# define gdb_tp_heap_buffer IPA_SYM_EXPORTED_NAME (gdb_tp_heap_buffer)
+# define gdb_jump_pad_buffer IPA_SYM_EXPORTED_NAME (gdb_jump_pad_buffer)
+# define gdb_jump_pad_buffer_end IPA_SYM_EXPORTED_NAME (gdb_jump_pad_buffer_end)
+# define gdb_trampoline_buffer IPA_SYM_EXPORTED_NAME (gdb_trampoline_buffer)
+# define gdb_trampoline_buffer_end IPA_SYM_EXPORTED_NAME (gdb_trampoline_buffer_end)
+# define gdb_trampoline_buffer_error IPA_SYM_EXPORTED_NAME (gdb_trampoline_buffer_error)
+# define collecting IPA_SYM_EXPORTED_NAME (collecting)
+# define gdb_collect_ptr IPA_SYM_EXPORTED_NAME (gdb_collect_ptr)
+# define stop_tracing IPA_SYM_EXPORTED_NAME (stop_tracing)
+# define flush_trace_buffer IPA_SYM_EXPORTED_NAME (flush_trace_buffer)
+# define about_to_request_buffer_space IPA_SYM_EXPORTED_NAME (about_to_request_buffer_space)
+# define trace_buffer_is_full IPA_SYM_EXPORTED_NAME (trace_buffer_is_full)
+# define stopping_tracepoint IPA_SYM_EXPORTED_NAME (stopping_tracepoint)
+# define expr_eval_result IPA_SYM_EXPORTED_NAME (expr_eval_result)
+# define error_tracepoint IPA_SYM_EXPORTED_NAME (error_tracepoint)
+# define tracepoints IPA_SYM_EXPORTED_NAME (tracepoints)
+# define tracing IPA_SYM_EXPORTED_NAME (tracing)
+# define trace_buffer_ctrl IPA_SYM_EXPORTED_NAME (trace_buffer_ctrl)
+# define trace_buffer_ctrl_curr IPA_SYM_EXPORTED_NAME (trace_buffer_ctrl_curr)
+# define trace_buffer_lo IPA_SYM_EXPORTED_NAME (trace_buffer_lo)
+# define trace_buffer_hi IPA_SYM_EXPORTED_NAME (trace_buffer_hi)
+# define traceframe_read_count IPA_SYM_EXPORTED_NAME (traceframe_read_count)
+# define traceframe_write_count IPA_SYM_EXPORTED_NAME (traceframe_write_count)
+# define traceframes_created IPA_SYM_EXPORTED_NAME (traceframes_created)
+# define trace_state_variables IPA_SYM_EXPORTED_NAME (trace_state_variables)
+# define get_raw_reg_ptr IPA_SYM_EXPORTED_NAME (get_raw_reg_ptr)
+# define get_trace_state_variable_value_ptr \
+ IPA_SYM_EXPORTED_NAME (get_trace_state_variable_value_ptr)
+# define set_trace_state_variable_value_ptr \
+ IPA_SYM_EXPORTED_NAME (set_trace_state_variable_value_ptr)
+# define ust_loaded IPA_SYM_EXPORTED_NAME (ust_loaded)
+# define helper_thread_id IPA_SYM_EXPORTED_NAME (helper_thread_id)
+# define cmd_buf IPA_SYM_EXPORTED_NAME (cmd_buf)
+# define ipa_tdesc_idx IPA_SYM_EXPORTED_NAME (ipa_tdesc_idx)
#endif
#ifndef IN_PROCESS_AGENT
CORE_ADDR addr_gdb_trampoline_buffer_end;
CORE_ADDR addr_gdb_trampoline_buffer_error;
CORE_ADDR addr_collecting;
- CORE_ADDR addr_gdb_collect;
+ CORE_ADDR addr_gdb_collect_ptr;
CORE_ADDR addr_stop_tracing;
CORE_ADDR addr_flush_trace_buffer;
CORE_ADDR addr_about_to_request_buffer_space;
CORE_ADDR addr_traceframe_write_count;
CORE_ADDR addr_traceframes_created;
CORE_ADDR addr_trace_state_variables;
- CORE_ADDR addr_get_raw_reg;
- CORE_ADDR addr_get_trace_state_variable_value;
- CORE_ADDR addr_set_trace_state_variable_value;
+ CORE_ADDR addr_get_raw_reg_ptr;
+ CORE_ADDR addr_get_trace_state_variable_value_ptr;
+ CORE_ADDR addr_set_trace_state_variable_value_ptr;
CORE_ADDR addr_ust_loaded;
+ CORE_ADDR addr_ipa_tdesc_idx;
};
static struct
{
const char *name;
int offset;
- int required;
} symbol_list[] = {
IPA_SYM(gdb_tp_heap_buffer),
IPA_SYM(gdb_jump_pad_buffer),
IPA_SYM(gdb_trampoline_buffer_end),
IPA_SYM(gdb_trampoline_buffer_error),
IPA_SYM(collecting),
- IPA_SYM(gdb_collect),
+ IPA_SYM(gdb_collect_ptr),
IPA_SYM(stop_tracing),
IPA_SYM(flush_trace_buffer),
IPA_SYM(about_to_request_buffer_space),
IPA_SYM(traceframe_write_count),
IPA_SYM(traceframes_created),
IPA_SYM(trace_state_variables),
- IPA_SYM(get_raw_reg),
- IPA_SYM(get_trace_state_variable_value),
- IPA_SYM(set_trace_state_variable_value),
+ IPA_SYM(get_raw_reg_ptr),
+ IPA_SYM(get_trace_state_variable_value_ptr),
+ IPA_SYM(set_trace_state_variable_value_ptr),
IPA_SYM(ust_loaded),
+ IPA_SYM(ipa_tdesc_idx),
};
static struct ipa_sym_addresses ipa_sym_addrs;
# define UNKNOWN_SIDE_EFFECTS() do {} while (0)
#endif
-IP_AGENT_EXPORT void ATTR_USED ATTR_NOINLINE
+IP_AGENT_EXPORT_FUNC void
stop_tracing (void)
{
/* GDBserver places breakpoint here. */
UNKNOWN_SIDE_EFFECTS();
}
-IP_AGENT_EXPORT void ATTR_USED ATTR_NOINLINE
+IP_AGENT_EXPORT_FUNC void
flush_trace_buffer (void)
{
/* GDBserver places breakpoint here. */
return write_inferior_memory (symaddr, (unsigned char *) &val, sizeof (val));
}
+static int
+write_inferior_int8 (CORE_ADDR symaddr, int8_t val)
+{
+ return write_inferior_memory (symaddr, (unsigned char *) &val, sizeof (val));
+}
+
static int
write_inferior_uinteger (CORE_ADDR symaddr, unsigned int val)
{
}
static CORE_ADDR target_malloc (ULONGEST size);
-static int write_inferior_data_ptr (CORE_ADDR where, CORE_ADDR ptr);
#define COPY_FIELD_TO_BUF(BUF, OBJ, FIELD) \
do { \
#endif
-/* Operations on various types of tracepoint actions. */
-
-struct tracepoint_action;
-
-struct tracepoint_action_ops
-{
- /* Download tracepoint action ACTION to IPA. Return the address of action
- in IPA/inferior. */
- CORE_ADDR (*download) (const struct tracepoint_action *action);
-
- /* Send ACTION to agent via command buffer started from BUFFER. Return
- updated head of command buffer. */
- char* (*send) (char *buffer, const struct tracepoint_action *action);
-};
-
/* Base action. Concrete actions inherit this. */
struct tracepoint_action
{
-#ifndef IN_PROCESS_AGENT
- const struct tracepoint_action_ops *ops;
-#endif
char type;
};
static CORE_ADDR
m_tracepoint_action_download (const struct tracepoint_action *action)
{
- int size_in_ipa = (sizeof (struct collect_memory_action)
- - offsetof (struct tracepoint_action, type));
- CORE_ADDR ipa_action = target_malloc (size_in_ipa);
+ CORE_ADDR ipa_action = target_malloc (sizeof (struct collect_memory_action));
- write_inferior_memory (ipa_action, (unsigned char *) &action->type,
- size_in_ipa);
+ write_inferior_memory (ipa_action, (unsigned char *) action,
+ sizeof (struct collect_memory_action));
return ipa_action;
}
return buffer;
}
-static const struct tracepoint_action_ops m_tracepoint_action_ops =
-{
- m_tracepoint_action_download,
- m_tracepoint_action_send,
-};
-
static CORE_ADDR
r_tracepoint_action_download (const struct tracepoint_action *action)
{
- int size_in_ipa = (sizeof (struct collect_registers_action)
- - offsetof (struct tracepoint_action, type));
- CORE_ADDR ipa_action = target_malloc (size_in_ipa);
+ CORE_ADDR ipa_action = target_malloc (sizeof (struct collect_registers_action));
- write_inferior_memory (ipa_action, (unsigned char *) &action->type,
- size_in_ipa);
+ write_inferior_memory (ipa_action, (unsigned char *) action,
+ sizeof (struct collect_registers_action));
return ipa_action;
}
return buffer;
}
-static const struct tracepoint_action_ops r_tracepoint_action_ops =
-{
- r_tracepoint_action_download,
- r_tracepoint_action_send,
-};
-
static CORE_ADDR download_agent_expr (struct agent_expr *expr);
static CORE_ADDR
x_tracepoint_action_download (const struct tracepoint_action *action)
{
- int size_in_ipa = (sizeof (struct eval_expr_action)
- - offsetof (struct tracepoint_action, type));
- CORE_ADDR ipa_action = target_malloc (size_in_ipa);
+ CORE_ADDR ipa_action = target_malloc (sizeof (struct eval_expr_action));
CORE_ADDR expr;
- write_inferior_memory (ipa_action, (unsigned char *) &action->type,
- size_in_ipa);
- expr = download_agent_expr (((struct eval_expr_action *)action)->expr);
- write_inferior_data_ptr (ipa_action + offsetof (struct eval_expr_action, expr)
- - offsetof (struct tracepoint_action, type),
- expr);
+ write_inferior_memory (ipa_action, (unsigned char *) action,
+ sizeof (struct eval_expr_action));
+ expr = download_agent_expr (((struct eval_expr_action *) action)->expr);
+ write_inferior_data_pointer (ipa_action
+ + offsetof (struct eval_expr_action, expr),
+ expr);
return ipa_action;
}
return agent_expr_send (buffer, eaction->expr);
}
-static const struct tracepoint_action_ops x_tracepoint_action_ops =
-{
- x_tracepoint_action_download,
- x_tracepoint_action_send,
-};
-
static CORE_ADDR
l_tracepoint_action_download (const struct tracepoint_action *action)
{
- int size_in_ipa = (sizeof (struct collect_static_trace_data_action)
- - offsetof (struct tracepoint_action, type));
- CORE_ADDR ipa_action = target_malloc (size_in_ipa);
+ CORE_ADDR ipa_action
+ = target_malloc (sizeof (struct collect_static_trace_data_action));
- write_inferior_memory (ipa_action, (unsigned char *) &action->type,
- size_in_ipa);
+ write_inferior_memory (ipa_action, (unsigned char *) action,
+ sizeof (struct collect_static_trace_data_action));
return ipa_action;
}
return buffer;
}
-static const struct tracepoint_action_ops l_tracepoint_action_ops =
+static char *
+tracepoint_action_send (char *buffer, const struct tracepoint_action *action)
{
- l_tracepoint_action_download,
- l_tracepoint_action_send,
-};
+ switch (action->type)
+ {
+ case 'M':
+ return m_tracepoint_action_send (buffer, action);
+ case 'R':
+ return r_tracepoint_action_send (buffer, action);
+ case 'X':
+ return x_tracepoint_action_send (buffer, action);
+ case 'L':
+ return l_tracepoint_action_send (buffer, action);
+ }
+ error ("Unknown trace action '%c'.", action->type);
+}
+
+static CORE_ADDR
+tracepoint_action_download (const struct tracepoint_action *action)
+{
+ switch (action->type)
+ {
+ case 'M':
+ return m_tracepoint_action_download (action);
+ case 'R':
+ return r_tracepoint_action_download (action);
+ case 'X':
+ return x_tracepoint_action_download (action);
+ case 'L':
+ return l_tracepoint_action_download (action);
+ }
+ error ("Unknown trace action '%c'.", action->type);
+}
#endif
/* This structure describes a piece of the source-level definition of
struct tracepoint_hit_ctx;
-typedef enum eval_result_type (*condfn) (struct tracepoint_hit_ctx *,
+typedef enum eval_result_type (*condfn) (unsigned char *,
ULONGEST *);
/* The definition of a tracepoint. */
#endif
+EXTERN_C_PUSH
+
/* The linked list of all tracepoints. Marked explicitly as used as
the in-process library doesn't use it for the fast tracepoints
support. */
-IP_AGENT_EXPORT struct tracepoint *tracepoints ATTR_USED;
-
-#ifndef IN_PROCESS_AGENT
-
-/* Pointer to the last tracepoint in the list, new tracepoints are
- linked in at the end. */
-
-static struct tracepoint *last_tracepoint;
-#endif
+IP_AGENT_EXPORT_VAR struct tracepoint *tracepoints;
/* The first tracepoint to exceed its pass count. */
-IP_AGENT_EXPORT struct tracepoint *stopping_tracepoint;
+IP_AGENT_EXPORT_VAR struct tracepoint *stopping_tracepoint;
/* True if the trace buffer is full or otherwise no longer usable. */
-IP_AGENT_EXPORT int trace_buffer_is_full;
+IP_AGENT_EXPORT_VAR int trace_buffer_is_full;
-static enum eval_result_type expr_eval_result = expr_eval_no_error;
+/* The first error that occurred during expression evaluation. */
+
+/* Stored as an int to avoid the IPA ABI being dependent on whatever
+ the compiler decides to use for the enum's underlying type. Holds
+ enum eval_result_type values. */
+IP_AGENT_EXPORT_VAR int expr_eval_result = expr_eval_no_error;
+
+EXTERN_C_POP
#ifndef IN_PROCESS_AGENT
+/* Pointer to the last tracepoint in the list, new tracepoints are
+ linked in at the end. */
+
+static struct tracepoint *last_tracepoint;
+
static const char *eval_result_names[] =
{
"terror:in the attic", /* this should never be reported */
/* The tracepoint in which the error occurred. */
-static struct tracepoint *error_tracepoint;
+EXTERN_C_PUSH
+IP_AGENT_EXPORT_VAR struct tracepoint *error_tracepoint;
+EXTERN_C_POP
struct trace_state_variable
{
struct trace_state_variable *alloced_trace_state_variables;
#endif
-IP_AGENT_EXPORT struct trace_state_variable *trace_state_variables;
+IP_AGENT_EXPORT_VAR struct trace_state_variable *trace_state_variables;
/* The results of tracing go into a fixed-size space known as the
"trace buffer". Because usage follows a limited number of
fields (and no data) marks the end of trace data. */
#define TRACEFRAME_EOB_MARKER_SIZE offsetof (struct traceframe, data)
-/* The traceframe to be used as the source of data to send back to
- GDB. A value of -1 means to get data from the live program. */
-
-int current_traceframe = -1;
-
/* This flag is true if the trace buffer is circular, meaning that
when it fills, the oldest trace frames are discarded in order to
make room. */
static LONGEST trace_buffer_size;
+EXTERN_C_PUSH
+
/* Pointer to the block of memory that traceframes all go into. */
-static unsigned char *trace_buffer_lo;
+IP_AGENT_EXPORT_VAR unsigned char *trace_buffer_lo;
/* Pointer to the end of the trace buffer, more precisely to the byte
after the end of the buffer. */
-static unsigned char *trace_buffer_hi;
+IP_AGENT_EXPORT_VAR unsigned char *trace_buffer_hi;
+
+EXTERN_C_POP
/* Control structure holding the read/write/etc. pointers into the
trace buffer. We need more than one of these to implement a
#define GDBSERVER_UPDATED_FLUSH_COUNT_BIT 0x80000000
#ifdef IN_PROCESS_AGENT
-IP_AGENT_EXPORT struct trace_buffer_control trace_buffer_ctrl[3];
-IP_AGENT_EXPORT unsigned int trace_buffer_ctrl_curr;
+IP_AGENT_EXPORT_VAR struct trace_buffer_control trace_buffer_ctrl[3];
+IP_AGENT_EXPORT_VAR unsigned int trace_buffer_ctrl_curr;
# define TRACE_BUFFER_CTRL_CURR \
(trace_buffer_ctrl_curr & ~GDBSERVER_FLUSH_COUNT_MASK)
of complete traceframes present in the trace buffer. The IP agent
writes to the write count, GDBserver writes to read count. */
-IP_AGENT_EXPORT unsigned int traceframe_write_count;
-IP_AGENT_EXPORT unsigned int traceframe_read_count;
+IP_AGENT_EXPORT_VAR unsigned int traceframe_write_count;
+IP_AGENT_EXPORT_VAR unsigned int traceframe_read_count;
/* Convenience macro. */
/* The count of all traceframes created in the current run, including
ones that were discarded to make room. */
-IP_AGENT_EXPORT int traceframes_created;
+IP_AGENT_EXPORT_VAR int traceframes_created;
#ifndef IN_PROCESS_AGENT
/* The global that controls tracing overall. */
-IP_AGENT_EXPORT int tracing;
+IP_AGENT_EXPORT_VAR int tracing;
#ifndef IN_PROCESS_AGENT
marker. */
alloc_size = (bufsize < TRACEFRAME_EOB_MARKER_SIZE
? TRACEFRAME_EOB_MARKER_SIZE : bufsize);
- trace_buffer_lo = xrealloc (trace_buffer_lo, alloc_size);
+ trace_buffer_lo = (unsigned char *) xrealloc (trace_buffer_lo, alloc_size);
trace_buffer_hi = trace_buffer_lo + trace_buffer_size;
#ifdef IN_PROCESS_AGENT
-IP_AGENT_EXPORT void ATTR_USED ATTR_NOINLINE
+IP_AGENT_EXPORT_FUNC void
about_to_request_buffer_space (void)
{
/* GDBserver places breakpoint here while it goes about to flush
{
struct tracepoint *tpoint, **tp_next;
- tpoint = xmalloc (sizeof (struct tracepoint));
+ tpoint = XNEW (struct tracepoint);
tpoint->number = num;
tpoint->address = addr;
tpoint->numactions = 0;
/* Append another action to perform when the tracepoint triggers. */
static void
-add_tracepoint_action (struct tracepoint *tpoint, char *packet)
+add_tracepoint_action (struct tracepoint *tpoint, const char *packet)
{
- char *act;
+ const char *act;
if (*packet == 'S')
{
while (*act)
{
- char *act_start = act;
+ const char *act_start = act;
struct tracepoint_action *action = NULL;
switch (*act)
{
case 'M':
{
- struct collect_memory_action *maction;
+ struct collect_memory_action *maction =
+ XNEW (struct collect_memory_action);
ULONGEST basereg;
int is_neg;
- maction = xmalloc (sizeof *maction);
maction->base.type = *act;
- maction->base.ops = &m_tracepoint_action_ops;
action = &maction->base;
++act;
}
case 'R':
{
- struct collect_registers_action *raction;
+ struct collect_registers_action *raction =
+ XNEW (struct collect_registers_action);
- raction = xmalloc (sizeof *raction);
raction->base.type = *act;
- raction->base.ops = &r_tracepoint_action_ops;
action = &raction->base;
trace_debug ("Want to collect registers");
}
case 'L':
{
- struct collect_static_trace_data_action *raction;
+ struct collect_static_trace_data_action *raction =
+ XNEW (struct collect_static_trace_data_action);
- raction = xmalloc (sizeof *raction);
raction->base.type = *act;
- raction->base.ops = &l_tracepoint_action_ops;
action = &raction->base;
trace_debug ("Want to collect static trace data");
break;
case 'X':
{
- struct eval_expr_action *xaction;
+ struct eval_expr_action *xaction = XNEW (struct eval_expr_action);
- xaction = xmalloc (sizeof (*xaction));
xaction->base.type = *act;
- xaction->base.ops = &x_tracepoint_action_ops;
action = &xaction->base;
trace_debug ("Want to evaluate expression");
tpoint->num_step_actions++;
tpoint->step_actions
- = xrealloc (tpoint->step_actions,
- (sizeof (*tpoint->step_actions)
- * tpoint->num_step_actions));
+ = XRESIZEVEC (struct tracepoint_action *, tpoint->step_actions,
+ tpoint->num_step_actions);
tpoint->step_actions_str
- = xrealloc (tpoint->step_actions_str,
- (sizeof (*tpoint->step_actions_str)
- * tpoint->num_step_actions));
+ = XRESIZEVEC (char *, tpoint->step_actions_str,
+ tpoint->num_step_actions);
tpoint->step_actions[tpoint->num_step_actions - 1] = action;
tpoint->step_actions_str[tpoint->num_step_actions - 1]
= savestring (act_start, act - act_start);
{
tpoint->numactions++;
tpoint->actions
- = xrealloc (tpoint->actions,
- sizeof (*tpoint->actions) * tpoint->numactions);
+ = XRESIZEVEC (struct tracepoint_action *, tpoint->actions,
+ tpoint->numactions);
tpoint->actions_str
- = xrealloc (tpoint->actions_str,
- sizeof (*tpoint->actions_str) * tpoint->numactions);
+ = XRESIZEVEC (char *, tpoint->actions_str, tpoint->numactions);
tpoint->actions[tpoint->numactions - 1] = action;
tpoint->actions_str[tpoint->numactions - 1]
= savestring (act_start, act - act_start);
return tsv;
/* Create a new variable. */
- tsv = xmalloc (sizeof (struct trace_state_variable));
+ tsv = XNEW (struct trace_state_variable);
tsv->number = num;
tsv->initial_value = 0;
tsv->value = 0;
return tsv;
}
-IP_AGENT_EXPORT LONGEST
+IP_AGENT_EXPORT_FUNC LONGEST
get_trace_state_variable_value (int num)
{
struct trace_state_variable *tsv;
return tsv->value;
}
-IP_AGENT_EXPORT void
+IP_AGENT_EXPORT_FUNC void
set_trace_state_variable_value (int num, LONGEST val)
{
struct trace_state_variable *tsv;
{
struct traceframe *tframe;
- tframe = trace_buffer_alloc (sizeof (struct traceframe));
+ tframe
+ = (struct traceframe *) trace_buffer_alloc (sizeof (struct traceframe));
if (tframe == NULL)
return NULL;
if (!tframe)
return NULL;
- block = trace_buffer_alloc (amt);
+ block = (unsigned char *) trace_buffer_alloc (amt);
if (!block)
return NULL;
find_next_traceframe_in_range (CORE_ADDR lo, CORE_ADDR hi, int inside_p,
int *tfnump)
{
+ client_state &cs = get_client_state ();
struct traceframe *tframe;
CORE_ADDR tfaddr;
- *tfnump = current_traceframe + 1;
+ *tfnump = cs.current_traceframe + 1;
tframe = find_traceframe (*tfnump);
/* The search is not supposed to wrap around. */
if (!tframe)
static struct traceframe *
find_next_traceframe_by_tracepoint (int num, int *tfnump)
{
+ client_state &cs = get_client_state ();
struct traceframe *tframe;
- *tfnump = current_traceframe + 1;
+ *tfnump = cs.current_traceframe + 1;
tframe = find_traceframe (*tfnump);
/* The search is not supposed to wrap around. */
if (!tframe)
static void
cmd_qtinit (char *packet)
{
+ client_state &cs = get_client_state ();
struct trace_state_variable *tsv, *prev, *next;
+ /* Can't do this command without a pid attached. */
+ if (current_thread == NULL)
+ {
+ write_enn (packet);
+ return;
+ }
+
/* Make sure we don't try to read from a trace frame. */
- current_traceframe = -1;
+ cs.current_traceframe = -1;
stop_tracing ();
struct tracepoint *prev_stpoint;
pause_all (1);
- cancel_breakpoints ();
prev_stpoint = NULL;
switch (tpoint->type)
{
case trap_tracepoint:
- delete_breakpoint (tpoint->handle);
+ {
+ struct breakpoint *bp
+ = (struct breakpoint *) tpoint->handle;
+
+ delete_breakpoint (bp);
+ }
break;
case fast_tracepoint:
- delete_fast_tracepoint_jump (tpoint->handle);
+ {
+ struct fast_tracepoint_jump *jump
+ = (struct fast_tracepoint_jump *) tpoint->handle;
+
+ delete_fast_tracepoint_jump (jump);
+ }
break;
case static_tracepoint:
if (prev_stpoint != NULL
ULONGEST addr;
ULONGEST count;
struct tracepoint *tpoint;
- char *actparm;
- char *packet = own_buf;
+ const char *packet = own_buf;
packet += strlen ("QTDP:");
}
else if (*packet == 'X')
{
- actparm = (char *) packet;
- tpoint->cond = gdb_parse_agent_expr (&actparm);
- packet = actparm;
+ tpoint->cond = gdb_parse_agent_expr (&packet);
}
else if (*packet == '-')
break;
{
ULONGEST num, addr, start, slen;
struct tracepoint *tpoint;
- char *packet = own_buf;
- char *saved, *srctype, *src;
+ const char *packet = own_buf;
+ const char *saved;
+ char *srctype, *src;
size_t nbytes;
struct source_string *last, *newlast;
saved = packet;
packet = strchr (packet, ':');
- srctype = xmalloc (packet - saved + 1);
+ srctype = (char *) xmalloc (packet - saved + 1);
memcpy (srctype, saved, packet - saved);
srctype[packet - saved] = '\0';
++packet;
++packet; /* skip a colon */
packet = unpack_varlen_hex (packet, &slen);
++packet; /* skip a colon */
- src = xmalloc (slen + 1);
+ src = (char *) xmalloc (slen + 1);
nbytes = hex2bin (packet, (gdb_byte *) src, strlen (packet) / 2);
src[nbytes] = '\0';
- newlast = xmalloc (sizeof (struct source_string));
+ newlast = XNEW (struct source_string);
newlast->type = srctype;
newlast->str = src;
newlast->next = NULL;
char *varname;
size_t nbytes;
struct trace_state_variable *tsv;
- char *packet = own_buf;
+ const char *packet = own_buf;
packet += strlen ("QTDV:");
++packet; /* skip a colon */
nbytes = strlen (packet) / 2;
- varname = xmalloc (nbytes + 1);
+ varname = (char *) xmalloc (nbytes + 1);
nbytes = hex2bin (packet, (gdb_byte *) varname, nbytes);
varname[nbytes] = '\0';
static void
cmd_qtenable_disable (char *own_buf, int enable)
{
- char *packet = own_buf;
+ const char *packet = own_buf;
ULONGEST num, addr;
struct tracepoint *tp;
write_enn (own_buf);
return;
}
-
- ret = write_inferior_integer (obj_addr, enable);
+
+ ret = write_inferior_int8 (obj_addr, enable);
done_accessing_memory ();
if (ret)
static void
cmd_qtv (char *own_buf)
{
+ client_state &cs = get_client_state ();
ULONGEST num;
LONGEST val = 0;
int err;
packet += strlen ("qTV:");
unpack_varlen_hex (packet, &num);
- if (current_traceframe >= 0)
+ if (cs.current_traceframe >= 0)
{
err = traceframe_read_tsv ((int) num, &val);
if (err)
{
ULONGEST start, end;
struct readonly_region *roreg;
- char *packet = own_buf;
+ const char *packet = own_buf;
trace_debug ("Want to mark readonly regions");
packet = unpack_varlen_hex (packet, &start);
++packet; /* skip a comma */
packet = unpack_varlen_hex (packet, &end);
- roreg = xmalloc (sizeof (struct readonly_region));
+
+ roreg = XNEW (struct readonly_region);
roreg->start = start;
roreg->end = end;
roreg->next = readonly_regions;
return 0;
}
-/* The maximum size of a jump pad entry. */
-static const int max_jump_pad_size = 0x100;
-
static CORE_ADDR gdb_jump_pad_head;
/* Return the address of the next free jump space. */
{
CORE_ADDR jentry, jump_entry;
CORE_ADDR trampoline;
+ CORE_ADDR collect;
ULONGEST trampoline_size;
int err = 0;
/* The jump to the jump pad of the last fast tracepoint
return 0;
}
+ if (read_inferior_data_pointer (ipa_sym_addrs.addr_gdb_collect_ptr,
+ &collect))
+ {
+ error ("error extracting gdb_collect_ptr");
+ return 1;
+ }
+
jentry = jump_entry = get_jump_space_head ();
trampoline = 0;
/* Install the jump pad. */
err = install_fast_tracepoint_jump_pad (tpoint->obj_addr_on_target,
tpoint->address,
- ipa_sym_addrs.addr_gdb_collect,
+ collect,
ipa_sym_addrs.addr_collecting,
tpoint->orig_size,
&jentry,
*packet = '\0';
+ if (agent_loaded_p ())
+ {
+ /* Tell IPA about the correct tdesc. */
+ if (write_inferior_integer (ipa_sym_addrs.addr_ipa_tdesc_idx,
+ target_get_ipa_tdesc_idx ()))
+ error ("Error setting ipa_tdesc_idx variable in lib");
+ }
+
/* Start out empty. */
if (agent_loaded_p ())
- write_inferior_data_ptr (ipa_sym_addrs.addr_tracepoints, 0);
+ write_inferior_data_pointer (ipa_sym_addrs.addr_tracepoints, 0);
/* Download and install tracepoints. */
for (tpoint = tracepoints; tpoint; tpoint = tpoint->next)
if (tpoint == tracepoints)
/* First object in list, set the head pointer in the
inferior. */
- write_inferior_data_ptr (ipa_sym_addrs.addr_tracepoints, tpptr);
+ write_inferior_data_pointer (ipa_sym_addrs.addr_tracepoints, tpptr);
else
- write_inferior_data_ptr (prev_tpptr + offsetof (struct tracepoint,
- next),
- tpptr);
+ write_inferior_data_pointer (prev_tpptr
+ + offsetof (struct tracepoint, next),
+ tpptr);
}
/* Any failure in the inner loop is sufficient cause to give
We can't now, since we may be getting here due to the inferior
agent calling us. */
pause_all (1);
- /* Since we're removing breakpoints, cancel breakpoint hits,
- possibly related to the breakpoints we're about to delete. */
- cancel_breakpoints ();
/* Stop logging. Tracepoints can still be hit, but they will not be
recorded. */
static void
cmd_qtframe (char *own_buf)
{
+ client_state &cs = get_client_state ();
ULONGEST frame, pc, lo, hi, num;
int tfnum, tpnum;
struct traceframe *tframe;
- char *packet = own_buf;
+ const char *packet = own_buf;
packet += strlen ("QTFrame:");
- if (strncmp (packet, "pc:", strlen ("pc:")) == 0)
+ if (startswith (packet, "pc:"))
{
packet += strlen ("pc:");
unpack_varlen_hex (packet, &pc);
trace_debug ("Want to find next traceframe at pc=0x%s", paddress (pc));
tframe = find_next_traceframe_in_range (pc, pc, 1, &tfnum);
}
- else if (strncmp (packet, "range:", strlen ("range:")) == 0)
+ else if (startswith (packet, "range:"))
{
packet += strlen ("range:");
packet = unpack_varlen_hex (packet, &lo);
paddress (lo), paddress (hi));
tframe = find_next_traceframe_in_range (lo, hi, 1, &tfnum);
}
- else if (strncmp (packet, "outside:", strlen ("outside:")) == 0)
+ else if (startswith (packet, "outside:"))
{
packet += strlen ("outside:");
packet = unpack_varlen_hex (packet, &lo);
paddress (lo), paddress (hi));
tframe = find_next_traceframe_in_range (lo, hi, 0, &tfnum);
}
- else if (strncmp (packet, "tdp:", strlen ("tdp:")) == 0)
+ else if (startswith (packet, "tdp:"))
{
packet += strlen ("tdp:");
unpack_varlen_hex (packet, &num);
if (tfnum == -1)
{
trace_debug ("Want to stop looking at traceframes");
- current_traceframe = -1;
+ cs.current_traceframe = -1;
write_ok (own_buf);
return;
}
if (tframe)
{
- current_traceframe = tfnum;
+ cs.current_traceframe = tfnum;
sprintf (own_buf, "F%xT%x", tfnum, tframe->tpnum);
}
else
cmd_qtstatus (char *packet)
{
char *stop_reason_rsp = NULL;
- char *buf1, *buf2, *buf3, *str;
+ char *buf1, *buf2, *buf3;
+ const char *str;
int slen;
/* Translate the plain text of the notes back into hex for
/* The user visible error string in terror needs to be hex encoded.
We leave it as plain string in `tracing_stop_reason' to ease
debugging. */
- if (strncmp (stop_reason_rsp, "terror:", strlen ("terror:")) == 0)
+ if (startswith (stop_reason_rsp, "terror:"))
{
const char *result_name;
int hexstr_len;
result_name = stop_reason_rsp + strlen ("terror:");
hexstr_len = strlen (result_name) * 2;
- p = stop_reason_rsp = alloca (strlen ("terror:") + hexstr_len + 1);
+ p = stop_reason_rsp
+ = (char *) alloca (strlen ("terror:") + hexstr_len + 1);
strcpy (p, "terror:");
p += strlen (p);
bin2hex ((gdb_byte *) result_name, p, strlen (result_name));
/* If this was a forced stop, include any stop note that was supplied. */
if (strcmp (stop_reason_rsp, "tstop") == 0)
{
- stop_reason_rsp = alloca (strlen ("tstop:") + strlen (buf3) + 1);
+ stop_reason_rsp = (char *) alloca (strlen ("tstop:") + strlen (buf3) + 1);
strcpy (stop_reason_rsp, "tstop:");
strcat (stop_reason_rsp, buf3);
}
{
ULONGEST num, addr;
struct tracepoint *tpoint;
- char *packet = own_buf;
+ const char *packet = own_buf;
packet += strlen ("qTP:");
int len;
len = strlen (src->str);
- buf = alloca (len * 2 + 1);
+ buf = (char *) alloca (len * 2 + 1);
bin2hex ((gdb_byte *) src->str, buf, len);
sprintf (packet, "Z%x:%s:%s:%x:%x:%s",
if (tsv->name)
{
namelen = strlen (tsv->name);
- buf = alloca (namelen * 2 + 1);
+ buf = (char *) alloca (namelen * 2 + 1);
bin2hex ((gdb_byte *) tsv->name, buf, namelen);
}
run_inferior_command (packet, strlen (packet) + 1);
}
-/* Helper for gdb_agent_about_to_close.
- Return non-zero if thread ENTRY is in the same process in DATA. */
-
-static int
-same_process_p (struct inferior_list_entry *entry, void *data)
-{
- int *pid = data;
-
- return ptid_get_pid (entry->id) == *pid;
-}
-
/* Sent the agent a command to close it. */
void
if (!maybe_write_ipa_not_loaded (buf))
{
- struct thread_info *save_inferior;
+ struct thread_info *saved_thread;
- save_inferior = current_inferior;
+ saved_thread = current_thread;
/* Find any thread which belongs to process PID. */
- current_inferior = (struct thread_info *)
- find_inferior (&all_threads, same_process_p, &pid);
+ current_thread = find_any_thread_of_pid (pid);
strcpy (buf, "close");
run_inferior_command (buf, strlen (buf) + 1);
- current_inferior = save_inferior;
+ current_thread = saved_thread;
}
}
static void
cmd_qtminftpilen (char *packet)
{
- if (current_inferior == NULL)
+ if (current_thread == NULL)
{
/* Indicate that the minimum length is currently unknown. */
strcpy (packet, "0");
{
ULONGEST offset, num, tot;
unsigned char *tbp;
- char *packet = own_buf;
+ const char *packet = own_buf;
packet += strlen ("qTBuffer:");
while (*packet)
{
- if (strncmp ("user:", packet, strlen ("user:")) == 0)
+ if (startswith (packet, "user:"))
{
packet += strlen ("user:");
saved = packet;
packet = strchr (packet, ';');
nbytes = (packet - saved) / 2;
- user = xmalloc (nbytes + 1);
+ user = (char *) xmalloc (nbytes + 1);
nbytes = hex2bin (saved, (gdb_byte *) user, nbytes);
user[nbytes] = '\0';
++packet; /* skip the semicolon */
xfree (tracing_user_name);
tracing_user_name = user;
}
- else if (strncmp ("notes:", packet, strlen ("notes:")) == 0)
+ else if (startswith (packet, "notes:"))
{
packet += strlen ("notes:");
saved = packet;
packet = strchr (packet, ';');
nbytes = (packet - saved) / 2;
- notes = xmalloc (nbytes + 1);
+ notes = (char *) xmalloc (nbytes + 1);
nbytes = hex2bin (saved, (gdb_byte *) notes, nbytes);
notes[nbytes] = '\0';
++packet; /* skip the semicolon */
xfree (tracing_notes);
tracing_notes = notes;
}
- else if (strncmp ("tstop:", packet, strlen ("tstop:")) == 0)
+ else if (startswith (packet, "tstop:"))
{
packet += strlen ("tstop:");
saved = packet;
packet = strchr (packet, ';');
nbytes = (packet - saved) / 2;
- stopnote = xmalloc (nbytes + 1);
+ stopnote = (char *) xmalloc (nbytes + 1);
nbytes = hex2bin (saved, (gdb_byte *) stopnote, nbytes);
stopnote[nbytes] = '\0';
++packet; /* skip the semicolon */
cmd_qtinit (packet);
return 1;
}
- else if (strncmp ("QTDP:", packet, strlen ("QTDP:")) == 0)
+ else if (startswith (packet, "QTDP:"))
{
cmd_qtdp (packet);
return 1;
}
- else if (strncmp ("QTDPsrc:", packet, strlen ("QTDPsrc:")) == 0)
+ else if (startswith (packet, "QTDPsrc:"))
{
cmd_qtdpsrc (packet);
return 1;
}
- else if (strncmp ("QTEnable:", packet, strlen ("QTEnable:")) == 0)
+ else if (startswith (packet, "QTEnable:"))
{
cmd_qtenable_disable (packet, 1);
return 1;
}
- else if (strncmp ("QTDisable:", packet, strlen ("QTDisable:")) == 0)
+ else if (startswith (packet, "QTDisable:"))
{
cmd_qtenable_disable (packet, 0);
return 1;
}
- else if (strncmp ("QTDV:", packet, strlen ("QTDV:")) == 0)
+ else if (startswith (packet, "QTDV:"))
{
cmd_qtdv (packet);
return 1;
}
- else if (strncmp ("QTro:", packet, strlen ("QTro:")) == 0)
+ else if (startswith (packet, "QTro:"))
{
cmd_qtro (packet);
return 1;
cmd_qtstop (packet);
return 1;
}
- else if (strncmp ("QTDisconnected:", packet,
- strlen ("QTDisconnected:")) == 0)
+ else if (startswith (packet, "QTDisconnected:"))
{
cmd_qtdisconnected (packet);
return 1;
}
- else if (strncmp ("QTFrame:", packet, strlen ("QTFrame:")) == 0)
+ else if (startswith (packet, "QTFrame:"))
{
cmd_qtframe (packet);
return 1;
}
- else if (strncmp ("QTBuffer:circular:", packet, strlen ("QTBuffer:circular:")) == 0)
+ else if (startswith (packet, "QTBuffer:circular:"))
{
cmd_bigqtbuffer_circular (packet);
return 1;
}
- else if (strncmp ("QTBuffer:size:", packet, strlen ("QTBuffer:size:")) == 0)
+ else if (startswith (packet, "QTBuffer:size:"))
{
cmd_bigqtbuffer_size (packet);
return 1;
}
- else if (strncmp ("QTNotes:", packet, strlen ("QTNotes:")) == 0)
+ else if (startswith (packet, "QTNotes:"))
{
cmd_qtnotes (packet);
return 1;
cmd_qtstatus (packet);
return 1;
}
- else if (strncmp ("qTP:", packet, strlen ("qTP:")) == 0)
+ else if (startswith (packet, "qTP:"))
{
cmd_qtp (packet);
return 1;
cmd_qtsv (packet);
return 1;
}
- else if (strncmp ("qTV:", packet, strlen ("qTV:")) == 0)
+ else if (startswith (packet, "qTV:"))
{
cmd_qtv (packet);
return 1;
}
- else if (strncmp ("qTBuffer:", packet, strlen ("qTBuffer:")) == 0)
+ else if (startswith (packet, "qTBuffer:"))
{
cmd_qtbuffer (packet);
return 1;
cmd_qtsstm (packet);
return 1;
}
- else if (strncmp ("qTSTMat:", packet, strlen ("qTSTMat:")) == 0)
+ else if (startswith (packet, "qTSTMat:"))
{
cmd_qtstmat (packet);
return 1;
add_while_stepping_state (struct thread_info *tinfo,
int tp_number, CORE_ADDR tp_address)
{
- struct wstep_state *wstep;
+ struct wstep_state *wstep = XNEW (struct wstep_state);
- wstep = xmalloc (sizeof (*wstep));
wstep->next = tinfo->while_stepping;
wstep->tp_number = tp_number;
wstep_link = &tinfo->while_stepping;
trace_debug ("Thread %s finished a single-step for tracepoint %d at 0x%s",
- target_pid_to_str (tinfo->entry.id),
+ target_pid_to_str (tinfo->id),
wstep->tp_number, paddress (wstep->tp_address));
ctx.base.type = trap_tracepoint;
{
trace_debug ("NO TRACEPOINT %d at 0x%s FOR THREAD %s!",
wstep->tp_number, paddress (wstep->tp_address),
- target_pid_to_str (tinfo->entry.id));
+ target_pid_to_str (tinfo->id));
/* Unlink. */
*wstep_link = wstep->next;
{
/* The requested numbers of steps have occurred. */
trace_debug ("Thread %s done stepping for tracepoint %d at 0x%s",
- target_pid_to_str (tinfo->entry.id),
+ target_pid_to_str (tinfo->id),
wstep->tp_number, paddress (wstep->tp_address));
/* Unlink the wstep. */
trace_debug ("lib stopped due to full buffer.");
if (ipa_stopping_tracepoint)
trace_debug ("lib stopped due to tpoint");
- if (ipa_stopping_tracepoint)
+ if (ipa_error_tracepoint)
trace_debug ("lib stopped due to error");
}
&& tpoint->type != static_tracepoint)
{
trace_debug ("Thread %s at address of tracepoint %d at 0x%s",
- target_pid_to_str (tinfo->entry.id),
+ target_pid_to_str (tinfo->id),
tpoint->number, paddress (tpoint->address));
/* Test the condition if present, and collect if true. */
#endif
#ifdef IN_PROCESS_AGENT
-/* The target description used by the IPA. Given that the IPA library
- is built for a specific architecture that is loaded into the
- inferior, there only needs to be one such description per
- build. */
-const struct target_desc *ipa_tdesc;
+/* The target description index for IPA. Passed from gdbserver, used
+ to select ipa_tdesc. */
+EXTERN_C_PUSH
+IP_AGENT_EXPORT_VAR int ipa_tdesc_idx;
+EXTERN_C_POP
#endif
static struct regcache *
get_context_regcache (struct tracepoint_hit_ctx *ctx)
{
struct regcache *regcache = NULL;
-
#ifdef IN_PROCESS_AGENT
+ const struct target_desc *ipa_tdesc = get_ipa_tdesc (ipa_tdesc_idx);
+
if (ctx->type == fast_tracepoint)
{
struct fast_tracepoint_ctx *fctx = (struct fast_tracepoint_ctx *) ctx;
used. */
#ifdef IN_PROCESS_AGENT
if (tpoint->compiled_cond)
- err = ((condfn) (uintptr_t) (tpoint->compiled_cond)) (ctx, &value);
+ {
+ struct fast_tracepoint_ctx *fctx = (struct fast_tracepoint_ctx *) ctx;
+ err = ((condfn) (uintptr_t) (tpoint->compiled_cond)) (fctx->regs, &value);
+ }
else
#endif
{
static int
match_blocktype (char blocktype, unsigned char *dataptr, void *data)
{
- char *wantedp = data;
+ char *wantedp = (char *) data;
if (*wantedp == blocktype)
return 1;
static int
traceframe_read_tsv (int tsvnum, LONGEST *val)
{
+ client_state &cs = get_client_state ();
int tfnum;
struct traceframe *tframe;
unsigned char *database, *dataptr;
trace_debug ("traceframe_read_tsv");
- tfnum = current_traceframe;
+ tfnum = cs.current_traceframe;
if (tfnum < 0)
{
static int
build_traceframe_info_xml (char blocktype, unsigned char *dataptr, void *data)
{
- struct buffer *buffer = data;
+ struct buffer *buffer = (struct buffer *) data;
switch (blocktype)
{
case, if we want to move the thread out of the jump pad, we need to
single-step it until this function returns 0. */
-int
+fast_tpoint_collect_result
fast_tracepoint_collecting (CORE_ADDR thread_area,
CORE_ADDR stop_pc,
struct fast_tpoint_collect_status *status)
if (tpoint == NULL)
{
warning ("in jump pad, but no matching tpoint?");
- return 0;
+ return fast_tpoint_collect_result::not_collecting;
}
else
{
if (tpoint == NULL)
{
warning ("in trampoline, but no matching tpoint?");
- return 0;
+ return fast_tpoint_collect_result::not_collecting;
}
else
{
{
trace_debug ("fast_tracepoint_collecting:"
" failed reading 'collecting' in the inferior");
- return 0;
+ return fast_tpoint_collect_result::not_collecting;
}
if (!ipa_collecting)
{
trace_debug ("fast_tracepoint_collecting: not collecting"
" (and nobody is).");
- return 0;
+ return fast_tpoint_collect_result::not_collecting;
}
/* Some thread is collecting. Check which. */
{
trace_debug ("fast_tracepoint_collecting: not collecting "
"(another thread is)");
- return 0;
+ return fast_tpoint_collect_result::not_collecting;
}
tpoint
warning ("fast_tracepoint_collecting: collecting, "
"but tpoint %s not found?",
paddress ((CORE_ADDR) ipa_collecting_obj.tpoint));
- return 0;
+ return fast_tpoint_collect_result::not_collecting;
}
/* The thread is within `gdb_collect', skip over the rest of
fast_tracepoint_collecting, returning continue-until-break at %s",
paddress (tpoint->adjusted_insn_addr));
- return 1; /* continue */
+ return fast_tpoint_collect_result::before_insn; /* continue */
}
else
{
paddress (tpoint->adjusted_insn_addr),
paddress (tpoint->adjusted_insn_addr_end));
- return 2; /* single-step */
+ return fast_tpoint_collect_result::at_insn; /* single-step */
}
}
NULL if it isn't locked. Note that this lock *must* be set while
executing any *function other than the jump pad. See
fast_tracepoint_collecting. */
-static collecting_t * ATTR_USED collecting;
+EXTERN_C_PUSH
+IP_AGENT_EXPORT_VAR collecting_t *collecting;
+EXTERN_C_POP
/* This routine, called from the jump pad (in asm) is designed to be
called from the jump pads of fast tracepoints, thus it is on the
critical path. */
-IP_AGENT_EXPORT void ATTR_USED
+IP_AGENT_EXPORT_FUNC void
gdb_collect (struct tracepoint *tpoint, unsigned char *regs)
{
struct fast_tracepoint_ctx ctx;
+ const struct target_desc *ipa_tdesc;
/* Don't do anything until the trace run is completely set up. */
if (!tracing)
return;
+ ipa_tdesc = get_ipa_tdesc (ipa_tdesc_idx);
ctx.base.type = fast_tracepoint;
ctx.regs = regs;
ctx.regcache_initted = 0;
/* Wrap the regblock in a register cache (in the stack, we don't
want to malloc here). */
- ctx.regspace = alloca (ipa_tdesc->registers_size);
+ ctx.regspace = (unsigned char *) alloca (ipa_tdesc->registers_size);
if (ctx.regspace == NULL)
{
trace_debug ("Trace buffer block allocation failed, skipping");
}
}
+/* These global variables points to the corresponding functions. This is
+ necessary on powerpc64, where asking for function symbol address from gdb
+ results in returning the actual code pointer, instead of the descriptor
+ pointer. */
+
+typedef void (*gdb_collect_ptr_type) (struct tracepoint *, unsigned char *);
+typedef ULONGEST (*get_raw_reg_ptr_type) (const unsigned char *, int);
+typedef LONGEST (*get_trace_state_variable_value_ptr_type) (int);
+typedef void (*set_trace_state_variable_value_ptr_type) (int, LONGEST);
+
+EXTERN_C_PUSH
+IP_AGENT_EXPORT_VAR gdb_collect_ptr_type gdb_collect_ptr = gdb_collect;
+IP_AGENT_EXPORT_VAR get_raw_reg_ptr_type get_raw_reg_ptr = get_raw_reg;
+IP_AGENT_EXPORT_VAR get_trace_state_variable_value_ptr_type
+ get_trace_state_variable_value_ptr = get_trace_state_variable_value;
+IP_AGENT_EXPORT_VAR set_trace_state_variable_value_ptr_type
+ set_trace_state_variable_value_ptr = set_trace_state_variable_value;
+EXTERN_C_POP
+
#endif
#ifndef IN_PROCESS_AGENT
CORE_ADDR
get_raw_reg_func_addr (void)
{
- return ipa_sym_addrs.addr_get_raw_reg;
+ CORE_ADDR res;
+ if (read_inferior_data_pointer (ipa_sym_addrs.addr_get_raw_reg_ptr, &res))
+ {
+ error ("error extracting get_raw_reg_ptr");
+ return 0;
+ }
+ return res;
}
CORE_ADDR
get_get_tsv_func_addr (void)
{
- return ipa_sym_addrs.addr_get_trace_state_variable_value;
+ CORE_ADDR res;
+ if (read_inferior_data_pointer (
+ ipa_sym_addrs.addr_get_trace_state_variable_value_ptr, &res))
+ {
+ error ("error extracting get_trace_state_variable_value_ptr");
+ return 0;
+ }
+ return res;
}
CORE_ADDR
get_set_tsv_func_addr (void)
{
- return ipa_sym_addrs.addr_set_trace_state_variable_value;
+ CORE_ADDR res;
+ if (read_inferior_data_pointer (
+ ipa_sym_addrs.addr_set_trace_state_variable_value_ptr, &res))
+ {
+ error ("error extracting set_trace_state_variable_value_ptr");
+ return 0;
+ }
+ return res;
}
static void
*jump_entry += 16;
}
-/* We'll need to adjust these when we consider bi-arch setups, and big
- endian machines. */
-
-static int
-write_inferior_data_ptr (CORE_ADDR where, CORE_ADDR ptr)
-{
- return write_inferior_memory (where,
- (unsigned char *) &ptr, sizeof (void *));
-}
-
/* The base pointer of the IPA's heap. This is the only memory the
IPA is allowed to use. The IPA should _not_ call the inferior's
`malloc' during operation. That'd be slow, and, most importantly,
write_inferior_memory (expr_addr, (unsigned char *) expr, sizeof (*expr));
expr_bytes = target_malloc (expr->length);
- write_inferior_data_ptr (expr_addr + offsetof (struct agent_expr, bytes),
- expr_bytes);
+ write_inferior_data_pointer (expr_addr + offsetof (struct agent_expr, bytes),
+ expr_bytes);
write_inferior_memory (expr_bytes, expr->bytes, expr->length);
return expr_addr;
sizeof (target_tracepoint));
if (tpoint->cond)
- write_inferior_data_ptr (tpptr + offsetof (struct tracepoint,
- cond),
- download_agent_expr (tpoint->cond));
+ write_inferior_data_pointer (tpptr
+ + offsetof (struct tracepoint, cond),
+ download_agent_expr (tpoint->cond));
if (tpoint->numactions)
{
/* The pointers array. */
actions_array
= target_malloc (sizeof (*tpoint->actions) * tpoint->numactions);
- write_inferior_data_ptr (tpptr + offsetof (struct tracepoint,
- actions),
- actions_array);
+ write_inferior_data_pointer (tpptr + offsetof (struct tracepoint,
+ actions),
+ actions_array);
/* Now for each pointer, download the action. */
for (i = 0; i < tpoint->numactions; i++)
{
struct tracepoint_action *action = tpoint->actions[i];
- CORE_ADDR ipa_action = action->ops->download (action);
+ CORE_ADDR ipa_action = tracepoint_action_download (action);
if (ipa_action != 0)
- write_inferior_data_ptr
- (actions_array + i * sizeof (*tpoint->actions),
- ipa_action);
+ write_inferior_data_pointer (actions_array
+ + i * sizeof (*tpoint->actions),
+ ipa_action);
}
}
}
struct tracepoint_action *action = tpoint->actions[i];
p[0] = action->type;
- p = action->ops->send (&p[1], action);
+ p = tracepoint_action_send (&p[1], action);
}
get_jump_space_head ();
if (ret)
return ret;
- if (strncmp (buf, "OK", 2) != 0)
+ if (!startswith (buf, "OK"))
return 1;
/* The value of tracepoint's target address is stored in BUF. */
}
/* tpoint->next = tp_prev->next */
- write_inferior_data_ptr (tpoint->obj_addr_on_target
- + offsetof (struct tracepoint, next),
- tp_prev_target_next_addr);
+ write_inferior_data_pointer (tpoint->obj_addr_on_target
+ + offsetof (struct tracepoint, next),
+ tp_prev_target_next_addr);
/* tp_prev->next = tpoint */
- write_inferior_data_ptr (tp_prev->obj_addr_on_target
- + offsetof (struct tracepoint, next),
- tpoint->obj_addr_on_target);
+ write_inferior_data_pointer (tp_prev->obj_addr_on_target
+ + offsetof (struct tracepoint, next),
+ tpoint->obj_addr_on_target);
}
else
/* First object in list, set the head pointer in the
inferior. */
- write_inferior_data_ptr (ipa_sym_addrs.addr_tracepoints,
- tpoint->obj_addr_on_target);
+ write_inferior_data_pointer (ipa_sym_addrs.addr_tracepoints,
+ tpoint->obj_addr_on_target);
}
struct trace_state_variable *tsv;
/* Start out empty. */
- write_inferior_data_ptr (ipa_sym_addrs.addr_trace_state_variables, 0);
+ write_inferior_data_pointer (ipa_sym_addrs.addr_trace_state_variables, 0);
for (tsv = trace_state_variables; tsv != NULL; tsv = tsv->next)
{
/* First object in list, set the head pointer in the
inferior. */
- write_inferior_data_ptr (ipa_sym_addrs.addr_trace_state_variables,
- ptr);
+ write_inferior_data_pointer (ipa_sym_addrs.addr_trace_state_variables,
+ ptr);
}
else
{
- write_inferior_data_ptr (prev_ptr
- + offsetof (struct trace_state_variable,
- next),
- ptr);
+ write_inferior_data_pointer (prev_ptr
+ + offsetof (struct trace_state_variable,
+ next),
+ ptr);
}
/* Write the whole object. We'll fix up its pointers in a bit.
CORE_ADDR name_addr = target_malloc (size);
write_inferior_memory (name_addr,
(unsigned char *) tsv->name, size);
- write_inferior_data_ptr (ptr
- + offsetof (struct trace_state_variable,
- name),
- name_addr);
+ write_inferior_data_pointer (ptr
+ + offsetof (struct trace_state_variable,
+ name),
+ name_addr);
}
gdb_assert (tsv->getter == NULL);
if (prev_ptr != 0)
{
/* Fixup the next pointer in the last item in the list. */
- write_inferior_data_ptr (prev_ptr
- + offsetof (struct trace_state_variable,
- next), 0);
+ write_inferior_data_pointer (prev_ptr
+ + offsetof (struct trace_state_variable,
+ next), 0);
}
}
trace_debug ("Done uploading traceframes [%d]\n", curr_tbctrl_idx);
pause_all (1);
- cancel_breakpoints ();
delete_breakpoint (about_to_request_buffer_space_bkpt);
about_to_request_buffer_space_bkpt = NULL;
#ifdef IN_PROCESS_AGENT
-IP_AGENT_EXPORT int ust_loaded;
-IP_AGENT_EXPORT char cmd_buf[IPA_CMD_BUF_SIZE];
+IP_AGENT_EXPORT_VAR int ust_loaded;
+IP_AGENT_EXPORT_VAR char cmd_buf[IPA_CMD_BUF_SIZE];
#ifdef HAVE_UST
{
struct tracepoint *tpoint;
struct static_tracepoint_ctx ctx;
+ const struct target_desc *ipa_tdesc;
/* Don't do anything until the trace run is completely set up. */
if (!tracing)
return;
}
+ ipa_tdesc = get_ipa_tdesc (ipa_tdesc_idx);
ctx.base.type = static_tracepoint;
ctx.regcache_initted = 0;
ctx.regs = regs;
run_inferior_command (char *cmd, int len)
{
int err = -1;
- int pid = ptid_get_pid (current_ptid);
+ int pid = current_ptid.pid ();
trace_debug ("run_inferior_command: running: %s", cmd);
/* Thread ID of the helper thread. GDBserver reads this to know which
is the help thread. This is an LWP id on Linux. */
-int helper_thread_id;
+EXTERN_C_PUSH
+IP_AGENT_EXPORT_VAR int helper_thread_id;
+EXTERN_C_POP
static int
init_named_socket (const char *name)
do
{
- fd = accept (listen_fd, &sockaddr, &tmp);
+ fd = accept (listen_fd, (struct sockaddr *) &sockaddr, &tmp);
}
/* It seems an ERESTARTSYS can escape out of accept. */
while (fd == -512 || (fd == -1 && errno == EINTR));
if (cmd_buf[0])
{
- if (strncmp ("close", cmd_buf, 5) == 0)
+ if (startswith (cmd_buf, "close"))
{
stop_loop = 1;
}
{
cmd_qtsstm (cmd_buf);
}
- else if (strncmp ("unprobe_marker_at:",
- cmd_buf,
- sizeof ("unprobe_marker_at:") - 1) == 0)
+ else if (startswith (cmd_buf, "unprobe_marker_at:"))
{
unprobe_marker_at (cmd_buf);
}
- else if (strncmp ("probe_marker_at:",
- cmd_buf,
- sizeof ("probe_marker_at:") - 1) == 0)
+ else if (startswith (cmd_buf, "probe_marker_at:"))
{
probe_marker_at (cmd_buf);
}
- else if (strncmp ("qTSTMat:",
- cmd_buf,
- sizeof ("qTSTMat:") - 1) == 0)
+ else if (startswith (cmd_buf, "qTSTMat:"))
{
cmd_qtstmat (cmd_buf);
}
/* Sleep endlessly to wait the whole inferior stops. This
thread can not exit because GDB or GDBserver may still need
- 'current_inferior' (representing this thread) to access
+ 'current_thread' (representing this thread) to access
inferior memory. Otherwise, this thread exits earlier than
- other threads, and 'current_inferior' is set to NULL. */
+ other threads, and 'current_thread' is set to NULL. */
while (1)
sleep (10);
}
#include <signal.h>
#include <pthread.h>
-IP_AGENT_EXPORT int gdb_agent_capability = AGENT_CAPA_STATIC_TRACE;
+EXTERN_C_PUSH
+IP_AGENT_EXPORT_VAR int gdb_agent_capability = AGENT_CAPA_STATIC_TRACE;
+EXTERN_C_POP
static void
gdb_agent_init (void)
sigfillset (&new_mask);
res = pthread_sigmask (SIG_SETMASK, &new_mask, &orig_mask);
if (res)
- fatal ("pthread_sigmask (1) failed: %s", strerror (res));
+ perror_with_name ("pthread_sigmask (1)");
res = pthread_create (&thread,
NULL,
res = pthread_sigmask (SIG_SETMASK, &orig_mask, NULL);
if (res)
- fatal ("pthread_sigmask (2) failed: %s", strerror (res));
+ perror_with_name ("pthread_sigmask (2)");
while (helper_thread_id == 0)
usleep (1);
}
#include <sys/mman.h>
-#include <fcntl.h>
-IP_AGENT_EXPORT char *gdb_tp_heap_buffer;
-IP_AGENT_EXPORT char *gdb_jump_pad_buffer;
-IP_AGENT_EXPORT char *gdb_jump_pad_buffer_end;
-IP_AGENT_EXPORT char *gdb_trampoline_buffer;
-IP_AGENT_EXPORT char *gdb_trampoline_buffer_end;
-IP_AGENT_EXPORT char *gdb_trampoline_buffer_error;
+IP_AGENT_EXPORT_VAR char *gdb_tp_heap_buffer;
+IP_AGENT_EXPORT_VAR char *gdb_jump_pad_buffer;
+IP_AGENT_EXPORT_VAR char *gdb_jump_pad_buffer_end;
+IP_AGENT_EXPORT_VAR char *gdb_trampoline_buffer;
+IP_AGENT_EXPORT_VAR char *gdb_trampoline_buffer_end;
+IP_AGENT_EXPORT_VAR char *gdb_trampoline_buffer_error;
/* Record the result of getting buffer space for fast tracepoint
trampolines. Any error message is copied, since caller may not be
gdb_agent_init ();
}
+#ifndef HAVE_GETAUXVAL
+/* Retrieve the value of TYPE from the auxiliary vector. If TYPE is not
+ found, 0 is returned. This function is provided if glibc is too old. */
+
+unsigned long
+getauxval (unsigned long type)
+{
+ unsigned long data[2];
+ FILE *f = fopen ("/proc/self/auxv", "r");
+ unsigned long value = 0;
+
+ if (f == NULL)
+ return 0;
+
+ while (fread (data, sizeof (data), 1, f) > 0)
+ {
+ if (data[0] == type)
+ {
+ value = data[1];
+ break;
+ }
+ }
+
+ fclose (f);
+ return value;
+}
+#endif
+
#endif /* IN_PROCESS_AGENT */
/* Return a timestamp, expressed as microseconds of the usual Unix
static LONGEST
get_timestamp (void)
{
- struct timeval tv;
+ using namespace std::chrono;
- if (gettimeofday (&tv, 0) != 0)
- return -1;
- else
- return (LONGEST) tv.tv_sec * 1000000 + tv.tv_usec;
+ steady_clock::time_point now = steady_clock::now ();
+ return duration_cast<microseconds> (now.time_since_epoch ()).count ();
}
void
#ifdef IN_PROCESS_AGENT
{
- uintptr_t addr;
int pagesize;
+ size_t jump_pad_size;
pagesize = sysconf (_SC_PAGE_SIZE);
if (pagesize == -1)
- fatal ("sysconf");
-
- gdb_tp_heap_buffer = xmalloc (5 * 1024 * 1024);
+ perror_with_name ("sysconf");
#define SCRATCH_BUFFER_NPAGES 20
- /* Allocate scratch buffer aligned on a page boundary, at a low
- address (close to the main executable's code). */
- for (addr = pagesize; addr != 0; addr += pagesize)
- {
- gdb_jump_pad_buffer = mmap ((void *) addr, pagesize * SCRATCH_BUFFER_NPAGES,
- PROT_READ | PROT_WRITE | PROT_EXEC,
- MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED,
- -1, 0);
- if (gdb_jump_pad_buffer != MAP_FAILED)
- break;
- }
-
- if (addr == 0)
- fatal ("\
-initialize_tracepoint: mmap'ing jump pad buffer failed with %s",
- strerror (errno));
+ jump_pad_size = pagesize * SCRATCH_BUFFER_NPAGES;
- gdb_jump_pad_buffer_end = gdb_jump_pad_buffer + pagesize * SCRATCH_BUFFER_NPAGES;
+ gdb_tp_heap_buffer = (char *) xmalloc (5 * 1024 * 1024);
+ gdb_jump_pad_buffer = (char *) alloc_jump_pad_buffer (jump_pad_size);
+ if (gdb_jump_pad_buffer == NULL)
+ perror_with_name ("mmap");
+ gdb_jump_pad_buffer_end = gdb_jump_pad_buffer + jump_pad_size;
}
gdb_trampoline_buffer = gdb_trampoline_buffer_end = 0;
buffer setup, but it can be mysterious, so create a channel to
report back on what went wrong, using a fixed size since we may
not be able to allocate space later when the problem occurs. */
- gdb_trampoline_buffer_error = xmalloc (IPA_BUFSIZ);
+ gdb_trampoline_buffer_error = (char *) xmalloc (IPA_BUFSIZ);
strcpy (gdb_trampoline_buffer_error, "No errors reported");