Merge GDB 7.5.1

gdb/gdbserver/tracepoint.c

 /* Tracepoint code for remote server for GDB.
    Copyright (C) 2009-2012 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 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    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, see <http://www.gnu.org/licenses/>.  */
 
 #include "server.h"
+#include "gdbthread.h"
+#include "agent.h"
+
 #include <ctype.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <sys/time.h>
 #include <stddef.h>
-#if HAVE_STDINT_H
+#include <inttypes.h>
 #include <stdint.h>
-#endif
+
+#include "ax.h"
 
 /* This file is built for both GDBserver, and the in-process
    agent (IPA), a shared library that includes a tracing agent that is
    loaded by the inferior to support fast tracepoints.  Fast
    tracepoints (or more accurately, jump based tracepoints) are
    implemented by patching the tracepoint location with a jump into a
    small trampoline function whose job is to save the register state,
    call the in-process tracing agent, and then execute the original
    instruction that was under the tracepoint jump (possibly adjusted,
    if PC-relative, or some such).
@@ skipping 18 matching lines @@
 static void trace_vdebug (const char *, ...) ATTR_FORMAT (printf, 1, 2);
 
 static void
 trace_vdebug (const char *fmt, ...)
 {
   char buf[1024];
   va_list ap;
 
   va_start (ap, fmt);
   vsprintf (buf, fmt, ap);
-  fprintf (stderr, "gdbserver/tracepoint: %s\n", buf);
+  fprintf (stderr, PROG "/tracepoint: %s\n", buf);
   va_end (ap);
 }
 
 #define trace_debug_1(level, fmt, args...)      \
   do {                                          \
-    if (level <= debug_threads)                 \
+    if (level <= debug_threads)         \
       trace_vdebug ((fmt), ##args);             \
   } while (0)
 
 #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))
@@ skipping 87 matching lines @@
   CORE_ADDR addr_trace_buffer_lo;
   CORE_ADDR addr_trace_buffer_hi;
   CORE_ADDR addr_traceframe_read_count;
   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_ust_loaded;
-  CORE_ADDR addr_helper_thread_id;
-  CORE_ADDR addr_cmd_buf;
 };
 
-#define STRINGIZE_1(STR) #STR
-#define STRINGIZE(STR) STRINGIZE_1(STR)
-#define IPA_SYM(SYM)                                    \
-  {                                                     \
-    STRINGIZE (gdb_agent_ ## SYM),                      \
-    offsetof (struct ipa_sym_addresses, addr_ ## SYM)   \
-  }
-
 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_jump_pad_buffer_end),
   IPA_SYM(gdb_trampoline_buffer),
@@ skipping 15 matching lines @@
   IPA_SYM(trace_buffer_lo),
   IPA_SYM(trace_buffer_hi),
   IPA_SYM(traceframe_read_count),
   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(ust_loaded),
-  IPA_SYM(helper_thread_id),
-  IPA_SYM(cmd_buf),
 };
 
-struct ipa_sym_addresses ipa_sym_addrs;
-
-int all_tracepoint_symbols_looked_up;
-
-int
-in_process_agent_loaded (void)
-{
-  return all_tracepoint_symbols_looked_up;
-}
+static struct ipa_sym_addresses ipa_sym_addrs;
 
 static int read_inferior_integer (CORE_ADDR symaddr, int *val);
 
 /* Returns true if both the in-process agent library and the static
-   tracepoints libraries are loaded in the inferior.  */
+   tracepoints libraries are loaded in the inferior, and agent has
+   capability on static tracepoints.  */
 
 static int
-in_process_agent_loaded_ust (void)
+in_process_agent_supports_ust (void)
 {
   int loaded = 0;
 
-  if (!in_process_agent_loaded ())
+  if (!agent_loaded_p ())
     {
       warning ("In-process agent not loaded");
       return 0;
     }
 
-  if (read_inferior_integer (ipa_sym_addrs.addr_ust_loaded, &loaded))
+  if (agent_capability_check (AGENT_CAPA_STATIC_TRACE))
     {
-      warning ("Error reading ust_loaded in lib");
-      return 0;
+      /* Agent understands static tracepoint, then check whether UST is in
+         fact loaded in the inferior.  */
+      if (read_inferior_integer (ipa_sym_addrs.addr_ust_loaded, &loaded))
+        {
+          warning ("Error reading ust_loaded in lib");
+          return 0;
+        }
+
+      return loaded;
     }
-
-  return loaded;
+  else
+    return 0;
 }
 
 static void
 write_e_ipa_not_loaded (char *buffer)
 {
   sprintf (buffer,
            "E.In-process agent library not loaded in process.  "
            "Fast and static tracepoints unavailable.");
 }
 
@@ skipping 11 matching lines @@
   sprintf (buffer, "E.GDBserver was built without static tracepoints support");
 #endif
 }
 
 /* If the in-process agent library isn't loaded in the inferior, write
    an error to BUFFER, and return 1.  Otherwise, return 0.  */
 
 static int
 maybe_write_ipa_not_loaded (char *buffer)
 {
-  if (!in_process_agent_loaded ())
+  if (!agent_loaded_p ())
     {
       write_e_ipa_not_loaded (buffer);
       return 1;
     }
   return 0;
 }
 
 /* If the in-process agent library and the ust (static tracepoints)
    library aren't loaded in the inferior, write an error to BUFFER,
    and return 1.  Otherwise, return 0.  */
 
 static int
 maybe_write_ipa_ust_not_loaded (char *buffer)
 {
-  if (!in_process_agent_loaded ())
+  if (!agent_loaded_p ())
     {
       write_e_ipa_not_loaded (buffer);
       return 1;
     }
-  else if (!in_process_agent_loaded_ust ())
+  else if (!in_process_agent_supports_ust ())
     {
       write_e_ust_not_loaded (buffer);
       return 1;
     }
   return 0;
 }
 
 /* Cache all future symbols that the tracepoints module might request.
    We can not request symbols at arbitrary states in the remote
    protocol, only when the client tells us that new symbols are
    available.  So when we load the in-process library, make sure to
    check the entire list.  */
 
 void
 tracepoint_look_up_symbols (void)
 {
   int i;
 
-  if (all_tracepoint_symbols_looked_up)
+  if (agent_loaded_p ())
     return;
 
   for (i = 0; i < sizeof (symbol_list) / sizeof (symbol_list[0]); i++)
     {
       CORE_ADDR *addrp =
         (CORE_ADDR *) ((char *) &ipa_sym_addrs + symbol_list[i].offset);
 
       if (look_up_one_symbol (symbol_list[i].name, addrp, 1) == 0)
         {
           if (debug_threads)
             fprintf (stderr, "symbol `%s' not found\n", symbol_list[i].name);
           return;
         }
     }
 
-  all_tracepoint_symbols_looked_up = 1;
+  agent_look_up_symbols (NULL);
 }
 
 #endif
 
 /* GDBserver places a breakpoint on the IPA's version (which is a nop)
    of the "stop_tracing" function.  When this breakpoint is hit,
    tracing stopped in the IPA for some reason.  E.g., due to
    tracepoint reaching the pass count, hitting conditional expression
    evaluation error, etc.
 
    The IPA's trace buffer is never in circular tracing mode: instead,
    GDBserver's is, and whenever the in-process buffer fills, it calls
    "flush_trace_buffer", which triggers an internal breakpoint.
    GDBserver reacts to this breakpoint by pulling the meanwhile
    collected data.  Old frames discarding is always handled on the
    GDBserver side.  */
 
 #ifdef IN_PROCESS_AGENT
-int debug_threads = 0;
-
 int
 read_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
 {
   memcpy (myaddr, (void *) (uintptr_t) memaddr, len);
   return 0;
 }
 
 /* Call this in the functions where GDBserver places a breakpoint, so
    that the compiler doesn't try to be clever and skip calling the
    function at all.  This is necessary, even if we tell the compiler
@@ skipping 31 matching lines @@
 }
 
 /* Breakpoint at "stop_tracing" in the inferior lib.  */
 struct breakpoint *stop_tracing_bkpt;
 static int stop_tracing_handler (CORE_ADDR);
 
 /* Breakpoint at "flush_trace_buffer" in the inferior lib.  */
 struct breakpoint *flush_trace_buffer_bkpt;
 static int flush_trace_buffer_handler (CORE_ADDR);
 
-static void download_tracepoints (void);
 static void download_trace_state_variables (void);
 static void upload_fast_traceframes (void);
 
-static int run_inferior_command (char *cmd);
+static int run_inferior_command (char *cmd, int len);
 
 static int
 read_inferior_integer (CORE_ADDR symaddr, int *val)
 {
   return read_inferior_memory (symaddr, (unsigned char *) val,
                                sizeof (*val));
 }
 
+struct tracepoint;
+static int tracepoint_send_agent (struct tracepoint *tpoint);
+
 static int
 read_inferior_uinteger (CORE_ADDR symaddr, unsigned int *val)
 {
   return read_inferior_memory (symaddr, (unsigned char *) val,
                                sizeof (*val));
 }
 
 static int
 read_inferior_data_pointer (CORE_ADDR symaddr, CORE_ADDR *val)
 {
@@ skipping 18 matching lines @@
 {
   return write_inferior_memory (symaddr, (unsigned char *) &val, sizeof (val));
 }
 
 static int
 write_inferior_uinteger (CORE_ADDR symaddr, unsigned int val)
 {
   return write_inferior_memory (symaddr, (unsigned char *) &val, sizeof (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 {                                                  \
+    memcpy (BUF, &(OBJ)->FIELD, sizeof ((OBJ)->FIELD)); \
+    BUF += sizeof ((OBJ)->FIELD);                       \
+  } while (0)
+
 #endif
 
-/* This enum must exactly match what is documented in
-   gdb/doc/agentexpr.texi, including all the numerical values.  */
+/* Operations on various types of tracepoint actions.  */
 
-enum gdb_agent_op
-  {
-#define DEFOP(NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED, VALUE)  \
-    gdb_agent_op_ ## NAME = VALUE,
-#include "ax.def"
-#undef DEFOP
-    gdb_agent_op_last
-  };
+struct tracepoint_action;
 
-static const char *gdb_agent_op_names [gdb_agent_op_last] =
-  {
-    "?undef?"
-#define DEFOP(NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED, VALUE)  , # NAME
-#include "ax.def"
-#undef DEFOP
-  };
+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);
 
-static const unsigned char gdb_agent_op_sizes [gdb_agent_op_last] =
-  {
-    0
-#define DEFOP(NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED, VALUE)  , SIZE
-#include "ax.def"
-#undef DEFOP
-  };
-
-struct agent_expr
-{
-  int length;
-
-  unsigned char *bytes;
+  /* 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;
 };
 
 /* An 'M' (collect memory) action.  */
 struct collect_memory_action
 {
   struct tracepoint_action base;
 
   ULONGEST addr;
   ULONGEST len;
-  int basereg;
+  int32_t basereg;
 };
 
 /* An 'R' (collect registers) action.  */
 
 struct collect_registers_action
 {
   struct tracepoint_action base;
 };
 
 /* An 'X' (evaluate expression) action.  */
 
 struct eval_expr_action
 {
   struct tracepoint_action base;
 
   struct agent_expr *expr;
 };
 
 /* An 'L' (collect static trace data) action.  */
 struct collect_static_trace_data_action
 {
   struct tracepoint_action base;
 };
 
+#ifndef IN_PROCESS_AGENT
+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);
+
+  write_inferior_memory (ipa_action, (unsigned char *) &action->type,
+                         size_in_ipa);
+
+  return ipa_action;
+}
+static char *
+m_tracepoint_action_send (char *buffer, const struct tracepoint_action *action)
+{
+  struct collect_memory_action *maction
+    = (struct collect_memory_action *) action;
+
+  COPY_FIELD_TO_BUF (buffer, maction, addr);
+  COPY_FIELD_TO_BUF (buffer, maction, len);
+  COPY_FIELD_TO_BUF (buffer, maction, basereg);
+
+  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);
+
+  write_inferior_memory (ipa_action, (unsigned char *) &action->type,
+                        size_in_ipa);
+
+  return ipa_action;
+}
+
+static char *
+r_tracepoint_action_send (char *buffer, const struct tracepoint_action *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 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);
+
+  return ipa_action;
+}
+
+/* Copy agent expression AEXPR to buffer pointed by P.  If AEXPR is NULL,
+   copy 0 to P.  Return updated header of buffer.  */
+
+static char *
+agent_expr_send (char *p, const struct agent_expr *aexpr)
+{
+  /* Copy the length of condition first, and then copy its
+     content.  */
+  if (aexpr == NULL)
+    {
+      memset (p, 0, 4);
+      p += 4;
+    }
+  else
+    {
+      memcpy (p, &aexpr->length, 4);
+      p +=4;
+
+      memcpy (p, aexpr->bytes, aexpr->length);
+      p += aexpr->length;
+    }
+  return p;
+}
+
+static char *
+x_tracepoint_action_send ( char *buffer, const struct tracepoint_action *action)
+{
+  struct eval_expr_action *eaction = (struct eval_expr_action *) 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);
+
+  write_inferior_memory (ipa_action, (unsigned char *) &action->type,
+                         size_in_ipa);
+
+  return ipa_action;
+}
+
+static char *
+l_tracepoint_action_send (char *buffer, const struct tracepoint_action *action)
+{
+  return buffer;
+}
+
+static const struct tracepoint_action_ops l_tracepoint_action_ops =
+{
+  l_tracepoint_action_download,
+  l_tracepoint_action_send,
+};
+#endif
+
 /* This structure describes a piece of the source-level definition of
    the tracepoint.  The contents are not interpreted by the target,
    but preserved verbatim for uploading upon reconnection.  */
 
 struct source_string
 {
   /* The type of string, such as "cond" for a conditional.  */
   char *type;
 
   /* The source-level string itself.  For the sake of target
@@ skipping 34 matching lines @@
    location.  Our target version of tracepoints is more like GDB's
    notion of "breakpoint locations", but we have almost nothing that
    is not per-location, so we bother having two kinds of objects.  The
    key consequence is that numbers are not unique, and that it takes
    both number and address to identify a tracepoint uniquely.  */
 
 struct tracepoint
 {
   /* The number of the tracepoint, as specified by GDB.  Several
      tracepoint objects here may share a number.  */
-  int number;
+  uint32_t number;
 
   /* Address at which the tracepoint is supposed to trigger.  Several
      tracepoints may share an address.  */
   CORE_ADDR address;
 
   /* Tracepoint type.  */
   enum tracepoint_type type;
 
   /* True if the tracepoint is currently enabled.  */
-  int enabled;
+  int8_t enabled;
 
   /* The number of single steps that will be performed after each
      tracepoint hit.  */
-  long step_count;
+  uint64_t step_count;
 
   /* The number of times the tracepoint may be hit before it will
      terminate the entire tracing run.  */
-  long pass_count;
+  uint64_t pass_count;
 
   /* Pointer to the agent expression that is the tracepoint's
      conditional, or NULL if the tracepoint is unconditional.  */
   struct agent_expr *cond;
 
   /* The list of actions to take when the tracepoint triggers.  */
-  int numactions;
+  uint32_t numactions;
   struct tracepoint_action **actions;
 
   /* Count of the times we've hit this tracepoint during the run.
      Note that while-stepping steps are not counted as "hits".  */
-  long hit_count;
+  uint64_t hit_count;
 
   /* Cached sum of the sizes of traceframes created by this point.  */
-  long traceframe_usage;
+  uint64_t traceframe_usage;
 
   CORE_ADDR compiled_cond;
 
   /* Link to the next tracepoint in the list.  */
   struct tracepoint *next;
 
 #ifndef IN_PROCESS_AGENT
   /* The list of actions to take when the tracepoint triggers, in
      string/packet form.  */
   char **actions_str;
 
   /* The collection of strings that describe the tracepoint as it was
      entered into GDB.  These are not used by the target, but are
      reported back to GDB upon reconnection.  */
   struct source_string *source_strings;
 
   /* The number of bytes displaced by fast tracepoints. It may subsume
      multiple instructions, for multi-byte fast tracepoints.  This
      field is only valid for fast tracepoints.  */
-  int orig_size;
+  uint32_t orig_size;
 
   /* Only for fast tracepoints.  */
   CORE_ADDR obj_addr_on_target;
 
   /* Address range where the original instruction under a fast
      tracepoint was relocated to.  (_end is actually one byte past
      the end).  */
   CORE_ADDR adjusted_insn_addr;
   CORE_ADDR adjusted_insn_addr_end;
 
@@ skipping 64 matching lines @@
 #endif
 
 /* The first tracepoint to exceed its pass count.  */
 
 IP_AGENT_EXPORT struct tracepoint *stopping_tracepoint;
 
 /* True if the trace buffer is full or otherwise no longer usable.  */
 
 IP_AGENT_EXPORT int trace_buffer_is_full;
 
-/* Enumeration of the different kinds of things that can happen during
-   agent expression evaluation.  */
-
-enum eval_result_type
-  {
-    expr_eval_no_error,
-    expr_eval_empty_expression,
-    expr_eval_empty_stack,
-    expr_eval_stack_overflow,
-    expr_eval_stack_underflow,
-    expr_eval_unhandled_opcode,
-    expr_eval_unrecognized_opcode,
-    expr_eval_divide_by_zero,
-    expr_eval_invalid_goto
-  };
-
 static enum eval_result_type expr_eval_result = expr_eval_no_error;
 
 #ifndef IN_PROCESS_AGENT
 
 static const char *eval_result_names[] =
   {
     "terror:in the attic",  /* this should never be reported */
     "terror:empty expression",
     "terror:empty stack",
     "terror:stack overflow",
@@ skipping 463 matching lines @@
    collect_data_at_tracepoint.  */
 struct trap_tracepoint_ctx
 {
   struct tracepoint_hit_ctx base;
 
   struct regcache *regcache;
 };
 
 #endif
 
-#ifndef IN_PROCESS_AGENT
-static struct agent_expr *parse_agent_expr (char **actparm);
-static char *unparse_agent_expr (struct agent_expr *aexpr);
-#endif
-static enum eval_result_type eval_agent_expr (struct tracepoint_hit_ctx *ctx,
-                                              struct traceframe *tframe,
-                                              struct agent_expr *aexpr,
-                                              ULONGEST *rslt);
-
-static int agent_mem_read (struct traceframe *tframe,
-                           unsigned char *to, CORE_ADDR from, ULONGEST len);
-static int agent_mem_read_string (struct traceframe *tframe,
-                                  unsigned char *to, CORE_ADDR from,
-                                  ULONGEST len);
-static int agent_tsv_read (struct traceframe *tframe, int n);
+static enum eval_result_type
+eval_tracepoint_agent_expr (struct tracepoint_hit_ctx *ctx,
+                            struct traceframe *tframe,
+                            struct agent_expr *aexpr,
+                            ULONGEST *rslt);
 
 #ifndef IN_PROCESS_AGENT
 static CORE_ADDR traceframe_get_pc (struct traceframe *tframe);
 static int traceframe_read_tsv (int num, LONGEST *val);
 #endif
 
 static int condition_true_at_tracepoint (struct tracepoint_hit_ctx *ctx,
                                          struct tracepoint *tpoint);
 
 #ifndef IN_PROCESS_AGENT
@@ skipping 16 matching lines @@
                                      struct tracepoint *tpoint,
                                      struct traceframe *tframe,
                                      struct tracepoint_action *taction);
 
 #ifndef IN_PROCESS_AGENT
 static struct tracepoint *fast_tracepoint_from_ipa_tpoint_address (CORE_ADDR);
 
 static void install_tracepoint (struct tracepoint *, char *own_buf);
 static void download_tracepoint (struct tracepoint *);
 static int install_fast_tracepoint (struct tracepoint *, char *errbuf);
+static void clone_fast_tracepoint (struct tracepoint *to,
+                                   const struct tracepoint *from);
 #endif
 
 static LONGEST get_timestamp (void);
 
 #if defined(__GNUC__)
 #  define memory_barrier() asm volatile ("" : : : "memory")
 #else
 #  define memory_barrier() do {} while (0)
 #endif
 
 /* We only build the IPA if this builtin is supported, and there are
    no uses of this in GDBserver itself, so we're safe in defining this
    unconditionally.  */
 #define cmpxchg(mem, oldval, newval) \
   __sync_val_compare_and_swap (mem, oldval, newval)
 
-/* The size in bytes of the buffer used to talk to the IPA helper
-   thread.  */
-#define CMD_BUF_SIZE 1024
-
 /* Record that an error occurred during expression evaluation.  */
 
 static void
 record_tracepoint_error (struct tracepoint *tpoint, const char *which,
                          enum eval_result_type rtype)
 {
   trace_debug ("Tracepoint %d at %s %s eval reports error %d",
                tpoint->number, paddress (tpoint->address), which, rtype);
 
 #ifdef IN_PROCESS_AGENT
@@ skipping 432 matching lines @@
 {
   struct tracepoint *tpoint;
 
   for (tpoint = tracepoints; tpoint; tpoint = tpoint->next)
     if (tpoint->number == id && tpoint->address == addr)
       return tpoint;
 
   return NULL;
 }
 
+/* Remove TPOINT from global list.  */
+
+static void
+remove_tracepoint (struct tracepoint *tpoint)
+{
+  struct tracepoint *tp, *tp_prev;
+
+  for (tp = tracepoints, tp_prev = NULL; tp && tp != tpoint;
+       tp_prev = tp, tp = tp->next)
+    ;
+
+  if (tp)
+    {
+      if (tp_prev)
+        tp_prev->next = tp->next;
+      else
+        tracepoints = tp->next;
+
+      xfree (tp);
+    }
+}
+
 /* There may be several tracepoints with the same number (because they
    are "locations", in GDB parlance); return the next one after the
    given tracepoint, or search from the beginning of the list if the
    first argument is NULL.  */
 
 static struct tracepoint *
 find_next_tracepoint_by_number (struct tracepoint *prev_tp, int num)
 {
   struct tracepoint *tpoint;
 
@@ skipping 45 matching lines @@
       switch (*act)
         {
         case 'M':
           {
             struct collect_memory_action *maction;
             ULONGEST basereg;
             int is_neg;
 
             maction = xmalloc (sizeof *maction);
             maction->base.type = *act;
+            maction->base.ops = &m_tracepoint_action_ops;
             action = &maction->base;
 
             ++act;
             is_neg = (*act == '-');
             if (*act == '-')
               ++act;
             act = unpack_varlen_hex (act, &basereg);
             ++act;
             act = unpack_varlen_hex (act, &maction->addr);
             ++act;
             act = unpack_varlen_hex (act, &maction->len);
             maction->basereg = (is_neg
                                 ? - (int) basereg
                                 : (int) basereg);
             trace_debug ("Want to collect %s bytes at 0x%s (basereg %d)",
                          pulongest (maction->len),
                          paddress (maction->addr), maction->basereg);
             break;
           }
         case 'R':
           {
             struct collect_registers_action *raction;
 
             raction = xmalloc (sizeof *raction);
             raction->base.type = *act;
+            raction->base.ops = &r_tracepoint_action_ops;
             action = &raction->base;
 
             trace_debug ("Want to collect registers");
             ++act;
             /* skip past hex digits of mask for now */
             while (isxdigit(*act))
               ++act;
             break;
           }
         case 'L':
           {
             struct collect_static_trace_data_action *raction;
 
             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");
             ++act;
             break;
           }
         case 'S':
           trace_debug ("Unexpected step action, ignoring");
           ++act;
           break;
         case 'X':
           {
             struct eval_expr_action *xaction;
 
             xaction = xmalloc (sizeof (*xaction));
             xaction->base.type = *act;
+            xaction->base.ops = &x_tracepoint_action_ops;
             action = &xaction->base;
 
             trace_debug ("Want to evaluate expression");
-            xaction->expr = parse_agent_expr (&act);
+            xaction->expr = gdb_parse_agent_expr (&act);
             break;
           }
         default:
           trace_debug ("unknown trace action '%c', ignoring...", *act);
           break;
         case '-':
           break;
         }
 
       if (action == NULL)
@@ skipping 123 matching lines @@
 
   if (!tsv)
     {
       trace_debug ("No trace state variable %d, skipping value set", num);
       return;
     }
 
   tsv->value = val;
 }
 
+LONGEST
+agent_get_trace_state_variable_value (int num)
+{
+  return get_trace_state_variable_value (num);
+}
+
+void
+agent_set_trace_state_variable_value (int num, LONGEST val)
+{
+  set_trace_state_variable_value (num, val);
+}
+
 static void
 set_trace_state_variable_name (int num, const char *name)
 {
   struct trace_state_variable *tsv;
 
   tsv = get_trace_state_variable (num);
 
   if (!tsv)
     {
       trace_debug ("No trace state variable %d, skipping name set", num);
@@ skipping 219 matching lines @@
   clear_inferior_trace_buffer ();
 
   write_ok (packet);
 }
 
 /* Unprobe the UST marker at ADDRESS.  */
 
 static void
 unprobe_marker_at (CORE_ADDR address)
 {
-  char cmd[CMD_BUF_SIZE];
+  char cmd[IPA_CMD_BUF_SIZE];
 
   sprintf (cmd, "unprobe_marker_at:%s", paddress (address));
-  run_inferior_command (cmd);
+  run_inferior_command (cmd, strlen (cmd) + 1);
 }
 
 /* Restore the program to its pre-tracing state.  This routine may be called
    in error situations, so it needs to be careful about only restoring
    from known-valid bits.  */
 
 static void
 clear_installed_tracepoints (void)
 {
   struct tracepoint *tpoint;
@@ skipping 113 matching lines @@
               tpoint->orig_size = count;
             }
           else if (*packet == 'S')
             {
               tpoint->type = static_tracepoint;
               ++packet;
             }
           else if (*packet == 'X')
             {
               actparm = (char *) packet;
-              tpoint->cond = parse_agent_expr (&actparm);
+              tpoint->cond = gdb_parse_agent_expr (&actparm);
               packet = actparm;
             }
           else if (*packet == '-')
             break;
           else if (*packet == '\0')
             break;
           else
             trace_debug ("Unknown optional tracepoint field");
         }
       if (*packet == '-')
         {
           trail_hyphen = 1;
           trace_debug ("Also has actions\n");
         }
 
       trace_debug ("Defined %stracepoint %d at 0x%s, "
-                   "enabled %d step %ld pass %ld",
+                   "enabled %d step %" PRIu64 " pass %" PRIu64,
                    tpoint->type == fast_tracepoint ? "fast "
-                   : "",
+                   : tpoint->type == static_tracepoint ? "static " : "",
                    tpoint->number, paddress (tpoint->address), tpoint->enabled,
                    tpoint->step_count, tpoint->pass_count);
     }
   else if (tpoint)
     add_tracepoint_action (tpoint, packet);
   else
     {
       trace_debug ("Tracepoint error: tracepoint %d at 0x%s not found",
                    (int) num, paddress (addr));
       write_enn (own_buf);
       return;
     }
 
   /* Install tracepoint during tracing only once for each tracepoint location.
      For each tracepoint loc, GDB may send multiple QTDP packets, and we can
      determine the last QTDP packet for one tracepoint location by checking
      trailing hyphen in QTDP packet.  */
   if (tracing && !trail_hyphen)
     {
+      struct tracepoint *tp = NULL;
+
       /* Pause all threads temporarily while we patch tracepoints.  */
       pause_all (0);
 
       /* download_tracepoint will update global `tracepoints'
          list, so it is unsafe to leave threads in jump pad.  */
       stabilize_threads ();
 
       /* Freeze threads.  */
       pause_all (1);
 
-      download_tracepoint (tpoint);
-      install_tracepoint (tpoint, own_buf);
+
+      if (tpoint->type != trap_tracepoint)
+        {
+          /* Find another fast or static tracepoint at the same address.  */
+          for (tp = tracepoints; tp; tp = tp->next)
+            {
+              if (tp->address == tpoint->address && tp->type == tpoint->type
+                  && tp->number != tpoint->number)
+                break;
+            }
+
+          /* TPOINT is installed at the same address as TP.  */
+          if (tp)
+            {
+              if (tpoint->type == fast_tracepoint)
+                clone_fast_tracepoint (tpoint, tp);
+              else if (tpoint->type == static_tracepoint)
+                tpoint->handle = (void *) -1;
+            }
+        }
+
+      if (use_agent && tpoint->type == fast_tracepoint
+          && agent_capability_check (AGENT_CAPA_FAST_TRACE))
+        {
+          /* Download and install fast tracepoint by agent.  */
+          if (tracepoint_send_agent (tpoint) == 0)
+            write_ok (own_buf);
+          else
+            {
+              write_enn (own_buf);
+              remove_tracepoint (tpoint);
+            }
+        }
+      else
+        {
+          download_tracepoint (tpoint);
+
+          if (tpoint->type == trap_tracepoint || tp == NULL)
+            {
+              install_tracepoint (tpoint, own_buf);
+              if (strcmp (own_buf, "OK") != 0)
+                remove_tracepoint (tpoint);
+            }
+          else
+            write_ok (own_buf);
+        }
 
       unpause_all (1);
       return;
     }
 
   write_ok (own_buf);
 }
 
 static void
 cmd_qtdpsrc (char *own_buf)
@@ skipping 366 matching lines @@
 
 /* Ask the IPA to probe the marker at ADDRESS.  Returns -1 if running
    the command fails, or 0 otherwise.  If the command ran
    successfully, but probing the marker failed, ERROUT will be filled
    with the error to reply to GDB, and -1 is also returned.  This
    allows directly passing IPA errors to GDB.  */
 
 static int
 probe_marker_at (CORE_ADDR address, char *errout)
 {
-  char cmd[CMD_BUF_SIZE];
+  char cmd[IPA_CMD_BUF_SIZE];
   int err;
 
   sprintf (cmd, "probe_marker_at:%s", paddress (address));
-  err = run_inferior_command (cmd);
+  err = run_inferior_command (cmd, strlen (cmd) + 1);
 
   if (err == 0)
     {
       if (*cmd == 'E')
         {
           strcpy (errout, cmd);
           return -1;
         }
     }
 
@@ skipping 92 matching lines @@
     {
       /* Tracepoints are installed as memory breakpoints.  Just go
          ahead and install the trap.  The breakpoints module
          handles duplicated breakpoints, and the memory read
          routine handles un-patching traps from memory reads.  */
       tpoint->handle = set_breakpoint_at (tpoint->address,
                                           tracepoint_handler);
     }
   else if (tpoint->type == fast_tracepoint || tpoint->type == static_tracepoint)
     {
-      struct tracepoint *tp;
-
-      if (!in_process_agent_loaded ())
+      if (!agent_loaded_p ())
         {
           trace_debug ("Requested a %s tracepoint, but fast "
                        "tracepoints aren't supported.",
                        tpoint->type == static_tracepoint ? "static" : "fast");
           write_e_ipa_not_loaded (own_buf);
           return;
         }
-      if (tpoint->type == static_tracepoint && !in_process_agent_loaded_ust ())
+      if (tpoint->type == static_tracepoint
+          && !in_process_agent_supports_ust ())
         {
           trace_debug ("Requested a static tracepoint, but static "
                        "tracepoints are not supported.");
           write_e_ust_not_loaded (own_buf);
           return;
         }
 
-      /* Find another fast or static tracepoint at the same address.  */
-      for (tp = tracepoints; tp; tp = tp->next)
-        {
-          if (tp->address == tpoint->address && tp->type == tpoint->type
-              && tp->number != tpoint->number)
-            break;
-        }
-
       if (tpoint->type == fast_tracepoint)
-        {
-          if (tp) /* TPOINT is installed at the same address as TP.  */
-            clone_fast_tracepoint (tpoint, tp);
-          else
-            install_fast_tracepoint (tpoint, own_buf);
-        }
+        install_fast_tracepoint (tpoint, own_buf);
       else
         {
-          if (tp)
+          if (probe_marker_at (tpoint->address, own_buf) == 0)
             tpoint->handle = (void *) -1;
-          else
-            {
-              if (probe_marker_at (tpoint->address, own_buf) == 0)
-                tpoint->handle = (void *) -1;
-            }
         }
 
     }
   else
     internal_error (__FILE__, __LINE__, "Unknown tracepoint type");
 
   if (tpoint->handle == NULL)
     {
       if (*own_buf == '\0')
         write_enn (own_buf);
     }
   else
     write_ok (own_buf);
 }
 
+static void download_tracepoint_1 (struct tracepoint *tpoint);
+
 static void
 cmd_qtstart (char *packet)
 {
   struct tracepoint *tpoint, *prev_ftpoint, *prev_stpoint;
+  CORE_ADDR tpptr = 0, prev_tpptr = 0;
 
   trace_debug ("Starting the trace");
 
   /* Pause all threads temporarily while we patch tracepoints.  */
   pause_all (0);
 
   /* Get threads out of jump pads.  Safe to do here, since this is a
      top level command.  And, required to do here, since we're
      deleting/rewriting jump pads.  */
 
   stabilize_threads ();
 
   /* Freeze threads.  */
   pause_all (1);
 
   /* Sync the fast tracepoints list in the inferior ftlib.  */
-  if (in_process_agent_loaded ())
-    {
-      download_tracepoints ();
-      download_trace_state_variables ();
-    }
+  if (agent_loaded_p ())
+    download_trace_state_variables ();
 
   /* No previous fast tpoint yet.  */
   prev_ftpoint = NULL;
 
   /* No previous static tpoint yet.  */
   prev_stpoint = NULL;
 
   *packet = '\0';
 
-  /* Install tracepoints.  */
+  /* Start out empty.  */
+  if (agent_loaded_p ())
+    write_inferior_data_ptr (ipa_sym_addrs.addr_tracepoints, 0);
+
+  /* Download and install tracepoints.  */
   for (tpoint = tracepoints; tpoint; tpoint = tpoint->next)
     {
       /* Ensure all the hit counts start at zero.  */
       tpoint->hit_count = 0;
       tpoint->traceframe_usage = 0;
 
       if (tpoint->type == trap_tracepoint)
         {
           /* Tracepoints are installed as memory breakpoints.  Just go
              ahead and install the trap.  The breakpoints module
              handles duplicated breakpoints, and the memory read
              routine handles un-patching traps from memory reads.  */
           tpoint->handle = set_breakpoint_at (tpoint->address,
                                               tracepoint_handler);
         }
-      else if (tpoint->type == fast_tracepoint)
+      else if (tpoint->type == fast_tracepoint
+               || tpoint->type == static_tracepoint)
         {
           if (maybe_write_ipa_not_loaded (packet))
             {
-              trace_debug ("Requested a fast tracepoint, but fast "
-                           "tracepoints aren't supported.");
+              trace_debug ("Requested a %s tracepoint, but fast "
+                           "tracepoints aren't supported.",
+                           tpoint->type == static_tracepoint
+                           ? "static" : "fast");
               break;
             }
 
-          if (prev_ftpoint != NULL && prev_ftpoint->address == tpoint->address)
-            clone_fast_tracepoint (tpoint, prev_ftpoint);
-          else
+          if (tpoint->type == fast_tracepoint)
             {
-              if (install_fast_tracepoint (tpoint, packet) == 0)
-                prev_ftpoint = tpoint;
-            }
-        }
-      else if (tpoint->type == static_tracepoint)
-        {
-          if (maybe_write_ipa_ust_not_loaded (packet))
-            {
-              trace_debug ("Requested a static tracepoint, but static "
-                           "tracepoints are not supported.");
-              break;
-            }
+              int use_agent_p
+                = use_agent && agent_capability_check (AGENT_CAPA_FAST_TRACE);
 
-          /* Can only probe a given marker once.  */
-          if (prev_stpoint != NULL && prev_stpoint->address == tpoint->address)
-            {
-              tpoint->handle = (void *) -1;
+              if (prev_ftpoint != NULL
+                  && prev_ftpoint->address == tpoint->address)
+                {
+                  if (use_agent_p)
+                    tracepoint_send_agent (tpoint);
+                  else
+                    download_tracepoint_1 (tpoint);
+
+                  clone_fast_tracepoint (tpoint, prev_ftpoint);
+                }
+              else
+                {
+                  /* Tracepoint is installed successfully?  */
+                  int installed = 0;
+
+                  /* Download and install fast tracepoint by agent.  */
+                  if (use_agent_p)
+                    installed = !tracepoint_send_agent (tpoint);
+                  else
+                    {
+                      download_tracepoint_1 (tpoint);
+                      installed = !install_fast_tracepoint (tpoint, packet);
+                    }
+
+                  if (installed)
+                    prev_ftpoint = tpoint;
+                }
             }
           else
             {
-              if (probe_marker_at (tpoint->address, packet) == 0)
+              if (!in_process_agent_supports_ust ())
                 {
-                  tpoint->handle = (void *) -1;
+                  trace_debug ("Requested a static tracepoint, but static "
+                               "tracepoints are not supported.");
+                  break;
+                }
 
-                  /* So that we can handle multiple static tracepoints
-                     at the same address easily.  */
-                  prev_stpoint = tpoint;
+              download_tracepoint_1 (tpoint);
+              /* Can only probe a given marker once.  */
+              if (prev_stpoint != NULL
+                  && prev_stpoint->address == tpoint->address)
+                tpoint->handle = (void *) -1;
+              else
+                {
+                  if (probe_marker_at (tpoint->address, packet) == 0)
+                    {
+                      tpoint->handle = (void *) -1;
+
+                      /* So that we can handle multiple static tracepoints
+                         at the same address easily.  */
+                      prev_stpoint = tpoint;
+                    }
                 }
             }
+
+          prev_tpptr = tpptr;
+          tpptr = tpoint->obj_addr_on_target;
+
+          if (tpoint == tracepoints)
+            /* First object in list, set the head pointer in the
+               inferior.  */
+            write_inferior_data_ptr (ipa_sym_addrs.addr_tracepoints, tpptr);
+          else
+            write_inferior_data_ptr (prev_tpptr + offsetof (struct tracepoint,
+                                                            next),
+                                     tpptr);
         }
 
       /* Any failure in the inner loop is sufficient cause to give
          up.  */
       if (tpoint->handle == NULL)
         break;
     }
 
   /* Any error in tracepoint insertion is unacceptable; better to
      address the problem now, than end up with a useless or misleading
      trace run.  */
   if (tpoint != NULL)
     {
       clear_installed_tracepoints ();
       if (*packet == '\0')
         write_enn (packet);
       unpause_all (1);
       return;
     }
 
   stopping_tracepoint = NULL;
   trace_buffer_is_full = 0;
   expr_eval_result = expr_eval_no_error;
   error_tracepoint = NULL;
   tracing_start_time = get_timestamp ();
 
   /* Tracing is now active, hits will now start being logged.  */
   tracing = 1;
 
-  if (in_process_agent_loaded ())
+  if (agent_loaded_p ())
     {
       if (write_inferior_integer (ipa_sym_addrs.addr_tracing, 1))
         fatal ("Error setting tracing variable in lib");
 
       if (write_inferior_data_pointer (ipa_sym_addrs.addr_stopping_tracepoint,
                                        0))
         fatal ("Error clearing stopping_tracepoint variable in lib");
 
       if (write_inferior_integer (ipa_sym_addrs.addr_trace_buffer_is_full, 0))
         fatal ("Error clearing trace_buffer_is_full variable in lib");
@@ skipping 38 matching lines @@
      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.  */
   tracing = 0;
-  if (in_process_agent_loaded ())
+  if (agent_loaded_p ())
     {
       if (write_inferior_integer (ipa_sym_addrs.addr_tracing, 0))
         fatal ("Error clearing tracing variable in lib");
     }
 
   tracing_stop_time = get_timestamp ();
   tracing_stop_reason = "t???";
   tracing_stop_tpnum = 0;
   if (stopping_tracepoint)
     {
       trace_debug ("Stopping the trace because "
-                   "tracepoint %d was hit %ld times",
+                   "tracepoint %d was hit %" PRIu64 " times",
                    stopping_tracepoint->number,
                    stopping_tracepoint->pass_count);
       tracing_stop_reason = "tpasscount";
       tracing_stop_tpnum = stopping_tracepoint->number;
     }
   else if (trace_buffer_is_full)
     {
       trace_debug ("Stopping the trace because the trace buffer is full");
       tracing_stop_reason = "tfull";
     }
@@ skipping 15 matching lines @@
       trace_debug ("Stopping the trace because of a tstop command");
       tracing_stop_reason = "tstop";
     }
 
   stopping_tracepoint = NULL;
   error_tracepoint = NULL;
 
   /* Clear out the tracepoints.  */
   clear_installed_tracepoints ();
 
-  if (in_process_agent_loaded ())
+  if (agent_loaded_p ())
     {
       /* Pull in fast tracepoint trace frames from the inferior lib
          buffer into our buffer, even if our buffer is already full,
          because we want to present the full number of created frames
          in addition to what fit in the trace buffer.  */
       upload_fast_traceframes ();
     }
 
   if (stop_tracing_bkpt != NULL)
     {
@@ skipping 142 matching lines @@
   hexify (buf2, str, slen);
 
   str = (tracing_stop_note ? tracing_stop_note : "");
   slen = strlen (str);
   buf3 = (char *) alloca (slen * 2 + 1);
   hexify (buf3, str, slen);
 
   trace_debug ("Returning trace status as %d, stop reason %s",
                tracing, tracing_stop_reason);
 
-  if (in_process_agent_loaded ())
+  if (agent_loaded_p ())
     {
       pause_all (1);
 
       upload_fast_traceframes ();
 
       unpause_all (1);
    }
 
   stop_reason_rsp = (char *) tracing_stop_reason;
 
@@ skipping 58 matching lines @@
   tpoint = find_tracepoint (num, addr);
 
   if (!tpoint)
     {
       trace_debug ("Tracepoint error: tracepoint %d at 0x%s not found",
                    (int) num, paddress (addr));
       write_enn (own_buf);
       return;
     }
 
-  sprintf (own_buf, "V%lx:%lx", tpoint->hit_count, tpoint->traceframe_usage);
+  sprintf (own_buf, "V%" PRIu64 ":%" PRIu64 "", tpoint->hit_count,
+           tpoint->traceframe_usage);
 }
 
 /* State variables to help return all the tracepoint bits.  */
 static struct tracepoint *cur_tpoint;
 static int cur_action;
 static int cur_step_action;
 static struct source_string *cur_source_string;
 static struct trace_state_variable *cur_tsv;
 
 /* Compose a response that is an imitation of the syntax by which the
    tracepoint was originally downloaded.  */
 
 static void
 response_tracepoint (char *packet, struct tracepoint *tpoint)
 {
   char *buf;
 
-  sprintf (packet, "T%x:%s:%c:%lx:%lx", tpoint->number,
+  sprintf (packet, "T%x:%s:%c:%" PRIx64 ":%" PRIx64, tpoint->number,
            paddress (tpoint->address),
            (tpoint->enabled ? 'E' : 'D'), tpoint->step_count,
            tpoint->pass_count);
   if (tpoint->type == fast_tracepoint)
     sprintf (packet + strlen (packet), ":F%x", tpoint->orig_size);
   else if (tpoint->type == static_tracepoint)
     sprintf (packet + strlen (packet), ":S");
 
   if (tpoint->cond)
     {
-      buf = unparse_agent_expr (tpoint->cond);
+      buf = gdb_unparse_agent_expr (tpoint->cond);
       sprintf (packet + strlen (packet), ":X%x,%s",
                tpoint->cond->length, buf);
       free (buf);
     }
 }
 
 /* Compose a response that is an imitation of the syntax by which the
    tracepoint action was originally downloaded (with the difference
    that due to the way we store the actions, this will output a packet
    per action, while GDB could have combined more than one action
@@ skipping 158 matching lines @@
 }
 
 /* Return the first static tracepoint marker, and initialize the state
    machine that will iterate through all the static tracepoints
    markers.  */
 
 static void
 cmd_qtfstm (char *packet)
 {
   if (!maybe_write_ipa_ust_not_loaded (packet))
-    run_inferior_command (packet);
+    run_inferior_command (packet, strlen (packet) + 1);
 }
 
 /* Return additional static tracepoints markers.  */
 
 static void
 cmd_qtsstm (char *packet)
 {
   if (!maybe_write_ipa_ust_not_loaded (packet))
-    run_inferior_command (packet);
+    run_inferior_command (packet, strlen (packet) + 1);
 }
 
 /* Return the definition of the static tracepoint at a given address.
    Result packet is the same as qTsST's.  */
 
 static void
 cmd_qtstmat (char *packet)
 {
   if (!maybe_write_ipa_ust_not_loaded (packet))
-    run_inferior_command (packet);
+    run_inferior_command (packet, strlen (packet) + 1);
 }
 
 /* Return the minimum instruction size needed for fast tracepoints as a
    hexadecimal number.  */
 
 static void
 cmd_qtminftpilen (char *packet)
 {
+  if (current_inferior == NULL)
+    {
+      /* Indicate that the minimum length is currently unknown.  */
+      strcpy (packet, "0");
+      return;
+    }
+
   sprintf (packet, "%x", target_get_min_fast_tracepoint_insn_len ());
 }
 
 /* Respond to qTBuffer packet with a block of raw data from the trace
    buffer.  GDB may ask for a lot, but we are allowed to reply with
    only as much as will fit within packet limits or whatever.  */
 
 static void
 cmd_qtbuffer (char *own_buf)
 {
@@ skipping 38 matching lines @@
 
   /* Trim to available packet size.  */
   if (num >= (PBUFSIZ - 16) / 2 )
     num = (PBUFSIZ - 16) / 2;
 
   convert_int_to_ascii (tbp, own_buf, num);
   own_buf[num] = '\0';
 }
 
 static void
-cmd_bigqtbuffer (char *own_buf)
+cmd_bigqtbuffer_circular (char *own_buf)
 {
   ULONGEST val;
   char *packet = own_buf;
 
-  packet += strlen ("QTBuffer:");
+  packet += strlen ("QTBuffer:circular:");
 
-  if (strncmp ("circular:", packet, strlen ("circular:")) == 0)
-    {
-      packet += strlen ("circular:");
-      unpack_varlen_hex (packet, &val);
-      circular_trace_buffer = val;
-      trace_debug ("Trace buffer is now %s",
-                   circular_trace_buffer ? "circular" : "linear");
-      write_ok (own_buf);
-    }
-  else
-    write_enn (own_buf);
+  unpack_varlen_hex (packet, &val);
+  circular_trace_buffer = val;
+  trace_debug ("Trace buffer is now %s",
+               circular_trace_buffer ? "circular" : "linear");
+  write_ok (own_buf);
 }
 
 static void
 cmd_qtnotes (char *own_buf)
 {
   size_t nbytes;
   char *saved, *user, *notes, *stopnote;
   char *packet = own_buf;
 
   packet += strlen ("QTNotes:");
@@ skipping 98 matching lines @@
                     strlen ("QTDisconnected:")) == 0)
     {
       cmd_qtdisconnected (packet);
       return 1;
     }
   else if (strncmp ("QTFrame:", packet, strlen ("QTFrame:")) == 0)
     {
       cmd_qtframe (packet);
       return 1;
     }
-  else if (strncmp ("QTBuffer:", packet, strlen ("QTBuffer:")) == 0)
+  else if (strncmp ("QTBuffer:circular:", packet, strlen ("QTBuffer:circular:")) == 0)
     {
-      cmd_bigqtbuffer (packet);
+      cmd_bigqtbuffer_circular (packet);
       return 1;
     }
   else if (strncmp ("QTNotes:", packet, strlen ("QTNotes:")) == 0)
     {
       cmd_qtnotes (packet);
       return 1;
     }
 
   return 0;
 }
@@ skipping 135 matching lines @@
 int
 tracepoint_finished_step (struct thread_info *tinfo, CORE_ADDR stop_pc)
 {
   struct tracepoint *tpoint;
   struct wstep_state *wstep;
   struct wstep_state **wstep_link;
   struct trap_tracepoint_ctx ctx;
 
   /* Pull in fast tracepoint trace frames from the inferior lib buffer into
      our buffer.  */
-  if (in_process_agent_loaded ())
+  if (agent_loaded_p ())
     upload_fast_traceframes ();
 
   /* Check if we were indeed collecting data for one of more
      tracepoints with a 'while-stepping' count.  */
   if (tinfo->while_stepping == NULL)
     return 0;
 
   if (!tracing)
     {
       /* We're not even tracing anymore.  Stop this thread from
@@ skipping 80 matching lines @@
 /* Handle any internal tracing control breakpoint hits.  That means,
    pull traceframes from the IPA to our buffer, and syncing both
    tracing agents when the IPA's tracing stops for some reason.  */
 
 int
 handle_tracepoint_bkpts (struct thread_info *tinfo, CORE_ADDR stop_pc)
 {
   /* Pull in fast tracepoint trace frames from the inferior in-process
      agent's buffer into our buffer.  */
 
-  if (!in_process_agent_loaded ())
+  if (!agent_loaded_p ())
     return 0;
 
   upload_fast_traceframes ();
 
   /* Check if the in-process agent had decided we should stop
      tracing.  */
   if (stop_pc == ipa_sym_addrs.addr_stop_tracing)
     {
       int ipa_trace_buffer_is_full;
       CORE_ADDR ipa_stopping_tracepoint;
@@ skipping 73 matching lines @@
   if (!tracing)
     return 0;
 
   ctx.base.type = trap_tracepoint;
   ctx.regcache = get_thread_regcache (tinfo, 1);
 
   for (tpoint = tracepoints; tpoint; tpoint = tpoint->next)
     {
       /* Note that we collect fast tracepoints here as well.  We'll
          step over the fast tracepoint jump later, which avoids the
-         double collect.  */
-      if (tpoint->enabled && stop_pc == tpoint->address)
+         double collect.  However, we don't collect for static
+         tracepoints here, because UST markers are compiled in program,
+         and probes will be executed in program.  So static tracepoints
+         are collected there.   */
+      if (tpoint->enabled && stop_pc == tpoint->address
+          && tpoint->type != static_tracepoint)
         {
           trace_debug ("Thread %s at address of tracepoint %d at 0x%s",
                        target_pid_to_str (tinfo->entry.id),
                        tpoint->number, paddress (tpoint->address));
 
           /* Test the condition if present, and collect if true.  */
           if (!tpoint->cond
               || (condition_true_at_tracepoint
                   ((struct tracepoint_hit_ctx *) &ctx, tpoint)))
             collect_data_at_tracepoint ((struct tracepoint_hit_ctx *) &ctx,
@@ skipping 19 matching lines @@
     }
 
   return ret;
 }
 
 #endif
 
 #if defined IN_PROCESS_AGENT && defined HAVE_UST
 struct ust_marker_data;
 static void collect_ust_data_at_tracepoint (struct tracepoint_hit_ctx *ctx,
-                                            CORE_ADDR stop_pc,
-                                            struct tracepoint *tpoint,
                                             struct traceframe *tframe);
 #endif
 
 /* Create a trace frame for the hit of the given tracepoint in the
    given thread.  */
 
 static void
 collect_data_at_tracepoint (struct tracepoint_hit_ctx *ctx, CORE_ADDR stop_pc,
                             struct tracepoint *tpoint)
 {
   struct traceframe *tframe;
   int acti;
 
   /* Only count it as a hit when we actually collect data.  */
   tpoint->hit_count++;
 
   /* If we've exceeded a defined pass count, record the event for
      later, and finish the collection for this hit.  This test is only
      for nonstepping tracepoints, stepping tracepoints test at the end
      of their while-stepping loop.  */
   if (tpoint->pass_count > 0
       && tpoint->hit_count >= tpoint->pass_count
       && tpoint->step_count == 0
       && stopping_tracepoint == NULL)
     stopping_tracepoint = tpoint;
 
-  trace_debug ("Making new traceframe for tracepoint %d at 0x%s, hit %ld",
+  trace_debug ("Making new traceframe for tracepoint %d at 0x%s, hit %" PRIu64,
                tpoint->number, paddress (tpoint->address), tpoint->hit_count);
 
   tframe = add_traceframe (tpoint);
 
   if (tframe)
     {
       for (acti = 0; acti < tpoint->numactions; ++acti)
         {
 #ifndef IN_PROCESS_AGENT
           trace_debug ("Tracepoint %d at 0x%s about to do action '%s'",
@@ skipping 16 matching lines @@
 
 static void
 collect_data_at_step (struct tracepoint_hit_ctx *ctx,
                       CORE_ADDR stop_pc,
                       struct tracepoint *tpoint, int current_step)
 {
   struct traceframe *tframe;
   int acti;
 
   trace_debug ("Making new step traceframe for "
-               "tracepoint %d at 0x%s, step %d of %ld, hit %ld",
+               "tracepoint %d at 0x%s, step %d of %" PRIu64 ", hit %" PRIu64,
                tpoint->number, paddress (tpoint->address),
                current_step, tpoint->step_count,
                tpoint->hit_count);
 
   tframe = add_traceframe (tpoint);
 
   if (tframe)
     {
       for (acti = 0; acti < tpoint->num_step_actions; ++acti)
         {
@@ skipping 125 matching lines @@
            pointing to the next instruction after the trap, but we
            don't want the user or GDB trying to guess whether the
            saved PC needs adjusting; so always record the adjusted
            stop_pc.  Note that we can't use tpoint->address instead,
            since it will be wrong for while-stepping actions.  This
            adjustment is a nop for fast tracepoints collected from the
            in-process lib (but not if GDBserver is collecting one
            preemptively), since the PC had already been adjusted to
            contain the tracepoint's address by the jump pad.  */
         trace_debug ("Storing stop pc (0x%s) in regblock",
-                     paddress (tpoint->address));
+                     paddress (stop_pc));
 
         /* This changes the regblock, not the thread's
            regcache.  */
         regcache_write_pc (&tregcache, stop_pc);
 #endif
       }
       break;
     case 'X':
       {
         struct eval_expr_action *eaction;
 
         eaction = (struct eval_expr_action *) taction;
 
         trace_debug ("Want to evaluate expression");
 
-        err = eval_agent_expr (ctx, tframe, eaction->expr, NULL);
+        err = eval_tracepoint_agent_expr (ctx, tframe, eaction->expr, NULL);
 
         if (err != expr_eval_no_error)
           {
             record_tracepoint_error (tpoint, "action expression", err);
             return;
           }
       }
       break;
     case 'L':
       {
 #if defined IN_PROCESS_AGENT && defined HAVE_UST
         trace_debug ("Want to collect static trace data");
-        collect_ust_data_at_tracepoint (ctx, stop_pc,
-                                        tpoint, tframe);
+        collect_ust_data_at_tracepoint (ctx, tframe);
 #else
         trace_debug ("warning: collecting static trace data, "
                      "but static tracepoints are not supported");
 #endif
       }
       break;
     default:
       trace_debug ("unknown trace action '%c', ignoring", taction->type);
       break;
     }
@@ skipping 18 matching lines @@
      tracepoints are collected, compared to an alternative where only
      trap tracepoints are collected on stop, and fast tracepoints on
      resume.  When a fast tracepoint is being processed by gdbserver,
      it is always the non-compiled condition expression that is
      used.  */
 #ifdef IN_PROCESS_AGENT
   if (tpoint->compiled_cond)
     err = ((condfn) (uintptr_t) (tpoint->compiled_cond)) (ctx, &value);
   else
 #endif
-    err = eval_agent_expr (ctx, NULL, tpoint->cond, &value);
+    err = eval_tracepoint_agent_expr (ctx, NULL, tpoint->cond, &value);
 
   if (err != expr_eval_no_error)
     {
       record_tracepoint_error (tpoint, "condition", err);
       /* The error case must return false.  */
       return 0;
     }
 
   trace_debug ("Tracepoint %d at 0x%s condition evals to %s",
                tpoint->number, paddress (tpoint->address),
                pulongest (value));
   return (value ? 1 : 0);
 }
 
-#ifndef IN_PROCESS_AGENT
-
-/* The packet form of an agent expression consists of an 'X', number
-   of bytes in expression, a comma, and then the bytes.  */
-
-static struct agent_expr *
-parse_agent_expr (char **actparm)
-{
-  char *act = *actparm;
-  ULONGEST xlen;
-  struct agent_expr *aexpr;
-
-  ++act;  /* skip the X */
-  act = unpack_varlen_hex (act, &xlen);
-  ++act;  /* skip a comma */
-  aexpr = xmalloc (sizeof (struct agent_expr));
-  aexpr->length = xlen;
-  aexpr->bytes = xmalloc (xlen);
-  convert_ascii_to_int (act, aexpr->bytes, xlen);
-  *actparm = act + (xlen * 2);
-  return aexpr;
-}
-
-/* Convert the bytes of an agent expression back into hex digits, so
-   they can be printed or uploaded.  This allocates the buffer,
-   callers should free when they are done with it.  */
-
-static char *
-unparse_agent_expr (struct agent_expr *aexpr)
-{
-  char *rslt;
-
-  rslt = xmalloc (2 * aexpr->length + 1);
-  convert_int_to_ascii (aexpr->bytes, rslt, aexpr->length);
-  return rslt;
-}
-
-#endif
-
-/* A wrapper for gdb_agent_op_names that does some bounds-checking.  */
-
-static const char *
-gdb_agent_op_name (int op)
-{
-  if (op < 0 || op >= gdb_agent_op_last || gdb_agent_op_names[op] == NULL)
-    return "?undef?";
-  return gdb_agent_op_names[op];
-}
-
-/* The agent expression evaluator, as specified by the GDB docs. It
-   returns 0 if everything went OK, and a nonzero error code
-   otherwise.  */
+/* Evaluates a tracepoint agent expression with context CTX,
+   traceframe TFRAME, agent expression AEXPR and store the
+   result in RSLT.  */
 
 static enum eval_result_type
-eval_agent_expr (struct tracepoint_hit_ctx *ctx,
-                 struct traceframe *tframe,
-                 struct agent_expr *aexpr,
-                 ULONGEST *rslt)
+eval_tracepoint_agent_expr (struct tracepoint_hit_ctx *ctx,
+                            struct traceframe *tframe,
+                            struct agent_expr *aexpr,
+                            ULONGEST *rslt)
 {
-  int pc = 0;
-#define STACK_MAX 100
-  ULONGEST stack[STACK_MAX], top;
-  int sp = 0;
-  unsigned char op;
-  int arg;
+  struct regcache *regcache;
+  regcache = get_context_regcache (ctx);
 
-  /* This union is a convenient way to convert representations.  For
-     now, assume a standard architecture where the hardware integer
-     types have 8, 16, 32, 64 bit types.  A more robust solution would
-     be to import stdint.h from gnulib.  */
-  union
-  {
-    union
-    {
-      unsigned char bytes[1];
-      unsigned char val;
-    } u8;
-    union
-    {
-      unsigned char bytes[2];
-      unsigned short val;
-    } u16;
-    union
-    {
-      unsigned char bytes[4];
-      unsigned int val;
-    } u32;
-    union
-    {
-      unsigned char bytes[8];
-      ULONGEST val;
-    } u64;
-  } cnv;
-
-  if (aexpr->length == 0)
-    {
-      trace_debug ("empty agent expression");
-      return expr_eval_empty_expression;
-    }
-
-  /* Cache the stack top in its own variable. Much of the time we can
-     operate on this variable, rather than dinking with the stack. It
-     needs to be copied to the stack when sp changes.  */
-  top = 0;
-
-  while (1)
-    {
-      op = aexpr->bytes[pc++];
-
-      trace_debug ("About to interpret byte 0x%x", op);
-
-      switch (op)
-        {
-        case gdb_agent_op_add:
-          top += stack[--sp];
-          break;
-
-        case gdb_agent_op_sub:
-          top = stack[--sp] - top;
-          break;
-
-        case gdb_agent_op_mul:
-          top *= stack[--sp];
-          break;
-
-        case gdb_agent_op_div_signed:
-          if (top == 0)
-            {
-              trace_debug ("Attempted to divide by zero");
-              return expr_eval_divide_by_zero;
-            }
-          top = ((LONGEST) stack[--sp]) / ((LONGEST) top);
-          break;
-
-        case gdb_agent_op_div_unsigned:
-          if (top == 0)
-            {
-              trace_debug ("Attempted to divide by zero");
-              return expr_eval_divide_by_zero;
-            }
-          top = stack[--sp] / top;
-          break;
-
-        case gdb_agent_op_rem_signed:
-          if (top == 0)
-            {
-              trace_debug ("Attempted to divide by zero");
-              return expr_eval_divide_by_zero;
-            }
-          top = ((LONGEST) stack[--sp]) % ((LONGEST) top);
-          break;
-
-        case gdb_agent_op_rem_unsigned:
-          if (top == 0)
-            {
-              trace_debug ("Attempted to divide by zero");
-              return expr_eval_divide_by_zero;
-            }
-          top = stack[--sp] % top;
-          break;
-
-        case gdb_agent_op_lsh:
-          top = stack[--sp] << top;
-          break;
-
-        case gdb_agent_op_rsh_signed:
-          top = ((LONGEST) stack[--sp]) >> top;
-          break;
-
-        case gdb_agent_op_rsh_unsigned:
-          top = stack[--sp] >> top;
-          break;
-
-        case gdb_agent_op_trace:
-          agent_mem_read (tframe,
-                          NULL, (CORE_ADDR) stack[--sp], (ULONGEST) top);
-          if (--sp >= 0)
-            top = stack[sp];
-          break;
-
-        case gdb_agent_op_trace_quick:
-          arg = aexpr->bytes[pc++];
-          agent_mem_read (tframe, NULL, (CORE_ADDR) top, (ULONGEST) arg);
-          break;
-
-        case gdb_agent_op_log_not:
-          top = !top;
-          break;
-
-        case gdb_agent_op_bit_and:
-          top &= stack[--sp];
-          break;
-
-        case gdb_agent_op_bit_or:
-          top |= stack[--sp];
-          break;
-
-        case gdb_agent_op_bit_xor:
-          top ^= stack[--sp];
-          break;
-
-        case gdb_agent_op_bit_not:
-          top = ~top;
-          break;
-
-        case gdb_agent_op_equal:
-          top = (stack[--sp] == top);
-          break;
-
-        case gdb_agent_op_less_signed:
-          top = (((LONGEST) stack[--sp]) < ((LONGEST) top));
-          break;
-
-        case gdb_agent_op_less_unsigned:
-          top = (stack[--sp] < top);
-          break;
-
-        case gdb_agent_op_ext:
-          arg = aexpr->bytes[pc++];
-          if (arg < (sizeof (LONGEST) * 8))
-            {
-              LONGEST mask = 1 << (arg - 1);
-              top &= ((LONGEST) 1 << arg) - 1;
-              top = (top ^ mask) - mask;
-            }
-          break;
-
-        case gdb_agent_op_ref8:
-          agent_mem_read (tframe, cnv.u8.bytes, (CORE_ADDR) top, 1);
-          top = cnv.u8.val;
-          break;
-
-        case gdb_agent_op_ref16:
-          agent_mem_read (tframe, cnv.u16.bytes, (CORE_ADDR) top, 2);
-          top = cnv.u16.val;
-          break;
-
-        case gdb_agent_op_ref32:
-          agent_mem_read (tframe, cnv.u32.bytes, (CORE_ADDR) top, 4);
-          top = cnv.u32.val;
-          break;
-
-        case gdb_agent_op_ref64:
-          agent_mem_read (tframe, cnv.u64.bytes, (CORE_ADDR) top, 8);
-          top = cnv.u64.val;
-          break;
-
-        case gdb_agent_op_if_goto:
-          if (top)
-            pc = (aexpr->bytes[pc] << 8) + (aexpr->bytes[pc + 1]);
-          else
-            pc += 2;
-          if (--sp >= 0)
-            top = stack[sp];
-          break;
-
-        case gdb_agent_op_goto:
-          pc = (aexpr->bytes[pc] << 8) + (aexpr->bytes[pc + 1]);
-          break;
-
-        case gdb_agent_op_const8:
-          /* Flush the cached stack top.  */
-          stack[sp++] = top;
-          top = aexpr->bytes[pc++];
-          break;
-
-        case gdb_agent_op_const16:
-          /* Flush the cached stack top.  */
-          stack[sp++] = top;
-          top = aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          break;
-
-        case gdb_agent_op_const32:
-          /* Flush the cached stack top.  */
-          stack[sp++] = top;
-          top = aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          break;
-
-        case gdb_agent_op_const64:
-          /* Flush the cached stack top.  */
-          stack[sp++] = top;
-          top = aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          break;
-
-        case gdb_agent_op_reg:
-          /* Flush the cached stack top.  */
-          stack[sp++] = top;
-          arg = aexpr->bytes[pc++];
-          arg = (arg << 8) + aexpr->bytes[pc++];
-          {
-            int regnum = arg;
-            struct regcache *regcache;
-
-            regcache = get_context_regcache (ctx);
-
-            switch (register_size (regnum))
-              {
-              case 8:
-                collect_register (regcache, regnum, cnv.u64.bytes);
-                top = cnv.u64.val;
-                break;
-              case 4:
-                collect_register (regcache, regnum, cnv.u32.bytes);
-                top = cnv.u32.val;
-                break;
-              case 2:
-                collect_register (regcache, regnum, cnv.u16.bytes);
-                top = cnv.u16.val;
-                break;
-              case 1:
-                collect_register (regcache, regnum, cnv.u8.bytes);
-                top = cnv.u8.val;
-                break;
-              default:
-                internal_error (__FILE__, __LINE__,
-                                "unhandled register size");
-              }
-          }
-          break;
-
-        case gdb_agent_op_end:
-          trace_debug ("At end of expression, sp=%d, stack top cache=0x%s",
-                       sp, pulongest (top));
-          if (rslt)
-            {
-              if (sp <= 0)
-                {
-                  /* This should be an error */
-                  trace_debug ("Stack is empty, nothing to return");
-                  return expr_eval_empty_stack;
-                }
-              *rslt = top;
-            }
-          return expr_eval_no_error;
-
-        case gdb_agent_op_dup:
-          stack[sp++] = top;
-          break;
-
-        case gdb_agent_op_pop:
-          if (--sp >= 0)
-            top = stack[sp];
-          break;
-
-        case gdb_agent_op_pick:
-          arg = aexpr->bytes[pc++];
-          stack[sp] = top;
-          top = stack[sp - arg];
-          ++sp;
-          break;
-
-        case gdb_agent_op_rot:
-          {
-            ULONGEST tem = stack[sp - 1];
-
-            stack[sp - 1] = stack[sp - 2];
-            stack[sp - 2] = top;
-            top = tem;
-          }
-          break;
-
-        case gdb_agent_op_zero_ext:
-          arg = aexpr->bytes[pc++];
-          if (arg < (sizeof (LONGEST) * 8))
-            top &= ((LONGEST) 1 << arg) - 1;
-          break;
-
-        case gdb_agent_op_swap:
-          /* Interchange top two stack elements, making sure top gets
-             copied back onto stack.  */
-          stack[sp] = top;
-          top = stack[sp - 1];
-          stack[sp - 1] = stack[sp];
-          break;
-
-        case gdb_agent_op_getv:
-          /* Flush the cached stack top.  */
-          stack[sp++] = top;
-          arg = aexpr->bytes[pc++];
-          arg = (arg << 8) + aexpr->bytes[pc++];
-          top = get_trace_state_variable_value (arg);
-          break;
-
-        case gdb_agent_op_setv:
-          arg = aexpr->bytes[pc++];
-          arg = (arg << 8) + aexpr->bytes[pc++];
-          set_trace_state_variable_value (arg, top);
-          /* Note that we leave the value on the stack, for the
-             benefit of later/enclosing expressions.  */
-          break;
-
-        case gdb_agent_op_tracev:
-          arg = aexpr->bytes[pc++];
-          arg = (arg << 8) + aexpr->bytes[pc++];
-          agent_tsv_read (tframe, arg);
-          break;
-
-        case gdb_agent_op_tracenz:
-          agent_mem_read_string (tframe, NULL, (CORE_ADDR) stack[--sp],
-                                 (ULONGEST) top);
-          if (--sp >= 0)
-            top = stack[sp];
-          break;
-
-          /* GDB never (currently) generates any of these ops.  */
-        case gdb_agent_op_float:
-        case gdb_agent_op_ref_float:
-        case gdb_agent_op_ref_double:
-        case gdb_agent_op_ref_long_double:
-        case gdb_agent_op_l_to_d:
-        case gdb_agent_op_d_to_l:
-        case gdb_agent_op_trace16:
-          trace_debug ("Agent expression op 0x%x valid, but not handled",
-                       op);
-          /* If ever GDB generates any of these, we don't have the
-             option of ignoring.  */
-          return 1;
-
-        default:
-          trace_debug ("Agent expression op 0x%x not recognized", op);
-          /* Don't struggle on, things will just get worse.  */
-          return expr_eval_unrecognized_opcode;
-        }
-
-      /* Check for stack badness.  */
-      if (sp >= (STACK_MAX - 1))
-        {
-          trace_debug ("Expression stack overflow");
-          return expr_eval_stack_overflow;
-        }
-
-      if (sp < 0)
-        {
-          trace_debug ("Expression stack underflow");
-          return expr_eval_stack_underflow;
-        }
-
-      trace_debug ("Op %s -> sp=%d, top=0x%s",
-                   gdb_agent_op_name (op), sp, pulongest (top));
-    }
+  return gdb_eval_agent_expr (regcache, tframe, aexpr, rslt);
 }
 
 /* Do memory copies for bytecodes.  */
 /* Do the recording of memory blocks for actions and bytecodes.  */
 
-static int
+int
 agent_mem_read (struct traceframe *tframe,
                 unsigned char *to, CORE_ADDR from, ULONGEST len)
 {
   unsigned char *mspace;
   ULONGEST remaining = len;
   unsigned short blocklen;
 
   /* If a 'to' buffer is specified, use it.  */
   if (to != NULL)
     {
@@ skipping 21 matching lines @@
       mspace += sizeof (blocklen);
       /* Record the memory block proper.  */
       read_inferior_memory (from, mspace, blocklen);
       trace_debug ("%d bytes recorded", blocklen);
       remaining -= blocklen;
       from += blocklen;
     }
   return 0;
 }
 
-static int
+int
 agent_mem_read_string (struct traceframe *tframe,
                        unsigned char *to, CORE_ADDR from, ULONGEST len)
 {
   unsigned char *buf, *mspace;
   ULONGEST remaining = len;
   unsigned short blocklen, i;
 
   /* To save a bit of space, block lengths are 16-bit, so break large
      requests into multiple blocks.  Bordering on overkill for strings,
      but it could happen that someone specifies a large max length.  */
@@ skipping 41 matching lines @@
       memcpy ((void *) mspace, (void *) buf, blocklen);
       remaining -= blocklen;
       from += blocklen;
       xfree (buf);
     }
   return 0;
 }
 
 /* Record the value of a trace state variable.  */
 
-static int
+int
 agent_tsv_read (struct traceframe *tframe, int n)
 {
   unsigned char *vspace;
   LONGEST val;
 
   vspace = add_traceframe_block (tframe,
                                  1 + sizeof (n) + sizeof (LONGEST));
   if (vspace == NULL)
     return 1;
   /* Identify block as a variable.  */
@@ skipping 772 matching lines @@
               break;
             }
         }
     }
 }
 
 #endif
 
 #ifndef IN_PROCESS_AGENT
 
-/* Bytecode compilation.  */
-
-CORE_ADDR current_insn_ptr;
-
-int emit_error;
-
-struct bytecode_address
-{
-  int pc;
-  CORE_ADDR address;
-  int goto_pc;
-  /* Offset and size of field to be modified in the goto block.  */
-  int from_offset, from_size;
-  struct bytecode_address *next;
-} *bytecode_address_table;
-
 CORE_ADDR
 get_raw_reg_func_addr (void)
 {
   return ipa_sym_addrs.addr_get_raw_reg;
 }
 
-static void
-emit_prologue (void)
+CORE_ADDR
+get_get_tsv_func_addr (void)
 {
-  target_emit_ops ()->emit_prologue ();
+  return ipa_sym_addrs.addr_get_trace_state_variable_value;
 }
 
-static void
-emit_epilogue (void)
+CORE_ADDR
+get_set_tsv_func_addr (void)
 {
-  target_emit_ops ()->emit_epilogue ();
+  return ipa_sym_addrs.addr_set_trace_state_variable_value;
 }
 
 static void
-emit_add (void)
-{
-  target_emit_ops ()->emit_add ();
-}
-
-static void
-emit_sub (void)
-{
-  target_emit_ops ()->emit_sub ();
-}
-
-static void
-emit_mul (void)
-{
-  target_emit_ops ()->emit_mul ();
-}
-
-static void
-emit_lsh (void)
-{
-  target_emit_ops ()->emit_lsh ();
-}
-
-static void
-emit_rsh_signed (void)
-{
-  target_emit_ops ()->emit_rsh_signed ();
-}
-
-static void
-emit_rsh_unsigned (void)
-{
-  target_emit_ops ()->emit_rsh_unsigned ();
-}
-
-static void
-emit_ext (int arg)
-{
-  target_emit_ops ()->emit_ext (arg);
-}
-
-static void
-emit_log_not (void)
-{
-  target_emit_ops ()->emit_log_not ();
-}
-
-static void
-emit_bit_and (void)
-{
-  target_emit_ops ()->emit_bit_and ();
-}
-
-static void
-emit_bit_or (void)
-{
-  target_emit_ops ()->emit_bit_or ();
-}
-
-static void
-emit_bit_xor (void)
-{
-  target_emit_ops ()->emit_bit_xor ();
-}
-
-static void
-emit_bit_not (void)
-{
-  target_emit_ops ()->emit_bit_not ();
-}
-
-static void
-emit_equal (void)
-{
-  target_emit_ops ()->emit_equal ();
-}
-
-static void
-emit_less_signed (void)
-{
-  target_emit_ops ()->emit_less_signed ();
-}
-
-static void
-emit_less_unsigned (void)
-{
-  target_emit_ops ()->emit_less_unsigned ();
-}
-
-static void
-emit_ref (int size)
-{
-  target_emit_ops ()->emit_ref (size);
-}
-
-static void
-emit_if_goto (int *offset_p, int *size_p)
-{
-  target_emit_ops ()->emit_if_goto (offset_p, size_p);
-}
-
-static void
-emit_goto (int *offset_p, int *size_p)
-{
-  target_emit_ops ()->emit_goto (offset_p, size_p);
-}
-
-static void
-write_goto_address (CORE_ADDR from, CORE_ADDR to, int size)
-{
-  target_emit_ops ()->write_goto_address (from, to, size);
-}
-
-static void
-emit_const (LONGEST num)
-{
-  target_emit_ops ()->emit_const (num);
-}
-
-static void
-emit_reg (int reg)
-{
-  target_emit_ops ()->emit_reg (reg);
-}
-
-static void
-emit_pop (void)
-{
-  target_emit_ops ()->emit_pop ();
-}
-
-static void
-emit_stack_flush (void)
-{
-  target_emit_ops ()->emit_stack_flush ();
-}
-
-static void
-emit_zero_ext (int arg)
-{
-  target_emit_ops ()->emit_zero_ext (arg);
-}
-
-static void
-emit_swap (void)
-{
-  target_emit_ops ()->emit_swap ();
-}
-
-static void
-emit_stack_adjust (int n)
-{
-  target_emit_ops ()->emit_stack_adjust (n);
-}
-
-/* FN's prototype is `LONGEST(*fn)(int)'.  */
-
-static void
-emit_int_call_1 (CORE_ADDR fn, int arg1)
-{
-  target_emit_ops ()->emit_int_call_1 (fn, arg1);
-}
-
-/* FN's prototype is `void(*fn)(int,LONGEST)'.  */
-
-static void
-emit_void_call_2 (CORE_ADDR fn, int arg1)
-{
-  target_emit_ops ()->emit_void_call_2 (fn, arg1);
-}
-
-static void
-emit_eq_goto (int *offset_p, int *size_p)
-{
-  target_emit_ops ()->emit_eq_goto (offset_p, size_p);
-}
-
-static void
-emit_ne_goto (int *offset_p, int *size_p)
-{
-  target_emit_ops ()->emit_ne_goto (offset_p, size_p);
-}
-
-static void
-emit_lt_goto (int *offset_p, int *size_p)
-{
-  target_emit_ops ()->emit_lt_goto (offset_p, size_p);
-}
-
-static void
-emit_ge_goto (int *offset_p, int *size_p)
-{
-  target_emit_ops ()->emit_ge_goto (offset_p, size_p);
-}
-
-static void
-emit_gt_goto (int *offset_p, int *size_p)
-{
-  target_emit_ops ()->emit_gt_goto (offset_p, size_p);
-}
-
-static void
-emit_le_goto (int *offset_p, int *size_p)
-{
-  target_emit_ops ()->emit_le_goto (offset_p, size_p);
-}
-
-static enum eval_result_type compile_bytecodes (struct agent_expr *aexpr);
-
-static void
 compile_tracepoint_condition (struct tracepoint *tpoint,
                               CORE_ADDR *jump_entry)
 {
   CORE_ADDR entry_point = *jump_entry;
   enum eval_result_type err;
 
   trace_debug ("Starting condition compilation for tracepoint %d\n",
                tpoint->number);
 
   /* Initialize the global pointer to the code being built.  */
@@ skipping 26 matching lines @@
 
   /* Update the code pointer passed in.  Note that we do this even if
      the compile fails, so that we can look at the partial results
      instead of letting them be overwritten.  */
   *jump_entry = current_insn_ptr;
 
   /* Leave a gap, to aid dump decipherment.  */
   *jump_entry += 16;
 }
 
-/* Scan an agent expression for any evidence that the given PC is the
-   target of a jump bytecode in the expression.  */
-
-int
-is_goto_target (struct agent_expr *aexpr, int pc)
-{
-  int i;
-  unsigned char op;
-
-  for (i = 0; i < aexpr->length; i += 1 + gdb_agent_op_sizes[op])
-    {
-      op = aexpr->bytes[i];
-
-      if (op == gdb_agent_op_goto || op == gdb_agent_op_if_goto)
-        {
-          int target = (aexpr->bytes[i + 1] << 8) + aexpr->bytes[i + 2];
-          if (target == pc)
-            return 1;
-        }
-    }
-
-  return 0;
-}
-
-/* Given an agent expression, turn it into native code.  */
-
-static enum eval_result_type
-compile_bytecodes (struct agent_expr *aexpr)
-{
-  int pc = 0;
-  int done = 0;
-  unsigned char op, next_op;
-  int arg;
-  /* This is only used to build 64-bit value for constants.  */
-  ULONGEST top;
-  struct bytecode_address *aentry, *aentry2;
-
-#define UNHANDLED                                       \
-  do                                                    \
-    {                                                   \
-      trace_debug ("Cannot compile op 0x%x\n", op);     \
-      return expr_eval_unhandled_opcode;                \
-    } while (0)
-
-  if (aexpr->length == 0)
-    {
-      trace_debug ("empty agent expression\n");
-      return expr_eval_empty_expression;
-    }
-
-  bytecode_address_table = NULL;
-
-  while (!done)
-    {
-      op = aexpr->bytes[pc];
-
-      trace_debug ("About to compile op 0x%x, pc=%d\n", op, pc);
-
-      /* Record the compiled-code address of the bytecode, for use by
-         jump instructions.  */
-      aentry = xmalloc (sizeof (struct bytecode_address));
-      aentry->pc = pc;
-      aentry->address = current_insn_ptr;
-      aentry->goto_pc = -1;
-      aentry->from_offset = aentry->from_size = 0;
-      aentry->next = bytecode_address_table;
-      bytecode_address_table = aentry;
-
-      ++pc;
-
-      emit_error = 0;
-
-      switch (op)
-        {
-        case gdb_agent_op_add:
-          emit_add ();
-          break;
-
-        case gdb_agent_op_sub:
-          emit_sub ();
-          break;
-
-        case gdb_agent_op_mul:
-          emit_mul ();
-          break;
-
-        case gdb_agent_op_div_signed:
-          UNHANDLED;
-          break;
-
-        case gdb_agent_op_div_unsigned:
-          UNHANDLED;
-          break;
-
-        case gdb_agent_op_rem_signed:
-          UNHANDLED;
-          break;
-
-        case gdb_agent_op_rem_unsigned:
-          UNHANDLED;
-          break;
-
-        case gdb_agent_op_lsh:
-          emit_lsh ();
-          break;
-
-        case gdb_agent_op_rsh_signed:
-          emit_rsh_signed ();
-          break;
-
-        case gdb_agent_op_rsh_unsigned:
-          emit_rsh_unsigned ();
-          break;
-
-        case gdb_agent_op_trace:
-          UNHANDLED;
-          break;
-
-        case gdb_agent_op_trace_quick:
-          UNHANDLED;
-          break;
-
-        case gdb_agent_op_log_not:
-          emit_log_not ();
-          break;
-
-        case gdb_agent_op_bit_and:
-          emit_bit_and ();
-          break;
-
-        case gdb_agent_op_bit_or:
-          emit_bit_or ();
-          break;
-
-        case gdb_agent_op_bit_xor:
-          emit_bit_xor ();
-          break;
-
-        case gdb_agent_op_bit_not:
-          emit_bit_not ();
-          break;
-
-        case gdb_agent_op_equal:
-          next_op = aexpr->bytes[pc];
-          if (next_op == gdb_agent_op_if_goto
-              && !is_goto_target (aexpr, pc)
-              && target_emit_ops ()->emit_eq_goto)
-            {
-              trace_debug ("Combining equal & if_goto");
-              pc += 1;
-              aentry->pc = pc;
-              arg = aexpr->bytes[pc++];
-              arg = (arg << 8) + aexpr->bytes[pc++];
-              aentry->goto_pc = arg;
-              emit_eq_goto (&(aentry->from_offset), &(aentry->from_size));
-            }
-          else if (next_op == gdb_agent_op_log_not
-                   && (aexpr->bytes[pc + 1] == gdb_agent_op_if_goto)
-                   && !is_goto_target (aexpr, pc + 1)
-                   && target_emit_ops ()->emit_ne_goto)
-            {
-              trace_debug ("Combining equal & log_not & if_goto");
-              pc += 2;
-              aentry->pc = pc;
-              arg = aexpr->bytes[pc++];
-              arg = (arg << 8) + aexpr->bytes[pc++];
-              aentry->goto_pc = arg;
-              emit_ne_goto (&(aentry->from_offset), &(aentry->from_size));
-            }
-          else
-            emit_equal ();
-          break;
-
-        case gdb_agent_op_less_signed:
-          next_op = aexpr->bytes[pc];
-          if (next_op == gdb_agent_op_if_goto
-              && !is_goto_target (aexpr, pc))
-            {
-              trace_debug ("Combining less_signed & if_goto");
-              pc += 1;
-              aentry->pc = pc;
-              arg = aexpr->bytes[pc++];
-              arg = (arg << 8) + aexpr->bytes[pc++];
-              aentry->goto_pc = arg;
-              emit_lt_goto (&(aentry->from_offset), &(aentry->from_size));
-            }
-          else if (next_op == gdb_agent_op_log_not
-                   && !is_goto_target (aexpr, pc)
-                   && (aexpr->bytes[pc + 1] == gdb_agent_op_if_goto)
-                   && !is_goto_target (aexpr, pc + 1))
-            {
-              trace_debug ("Combining less_signed & log_not & if_goto");
-              pc += 2;
-              aentry->pc = pc;
-              arg = aexpr->bytes[pc++];
-              arg = (arg << 8) + aexpr->bytes[pc++];
-              aentry->goto_pc = arg;
-              emit_ge_goto (&(aentry->from_offset), &(aentry->from_size));
-            }
-          else
-            emit_less_signed ();
-          break;
-
-        case gdb_agent_op_less_unsigned:
-          emit_less_unsigned ();
-          break;
-
-        case gdb_agent_op_ext:
-          arg = aexpr->bytes[pc++];
-          if (arg < (sizeof (LONGEST) * 8))
-            emit_ext (arg);
-          break;
-
-        case gdb_agent_op_ref8:
-          emit_ref (1);
-          break;
-
-        case gdb_agent_op_ref16:
-          emit_ref (2);
-          break;
-
-        case gdb_agent_op_ref32:
-          emit_ref (4);
-          break;
-
-        case gdb_agent_op_ref64:
-          emit_ref (8);
-          break;
-
-        case gdb_agent_op_if_goto:
-          arg = aexpr->bytes[pc++];
-          arg = (arg << 8) + aexpr->bytes[pc++];
-          aentry->goto_pc = arg;
-          emit_if_goto (&(aentry->from_offset), &(aentry->from_size));
-          break;
-
-        case gdb_agent_op_goto:
-          arg = aexpr->bytes[pc++];
-          arg = (arg << 8) + aexpr->bytes[pc++];
-          aentry->goto_pc = arg;
-          emit_goto (&(aentry->from_offset), &(aentry->from_size));
-          break;
-
-        case gdb_agent_op_const8:
-          emit_stack_flush ();
-          top = aexpr->bytes[pc++];
-          emit_const (top);
-          break;
-
-        case gdb_agent_op_const16:
-          emit_stack_flush ();
-          top = aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          emit_const (top);
-          break;
-
-        case gdb_agent_op_const32:
-          emit_stack_flush ();
-          top = aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          emit_const (top);
-          break;
-
-        case gdb_agent_op_const64:
-          emit_stack_flush ();
-          top = aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          top = (top << 8) + aexpr->bytes[pc++];
-          emit_const (top);
-          break;
-
-        case gdb_agent_op_reg:
-          emit_stack_flush ();
-          arg = aexpr->bytes[pc++];
-          arg = (arg << 8) + aexpr->bytes[pc++];
-          emit_reg (arg);
-          break;
-
-        case gdb_agent_op_end:
-          trace_debug ("At end of expression\n");
-
-          /* Assume there is one stack element left, and that it is
-             cached in "top" where emit_epilogue can get to it.  */
-          emit_stack_adjust (1);
-
-          done = 1;
-          break;
-
-        case gdb_agent_op_dup:
-          /* In our design, dup is equivalent to stack flushing.  */
-          emit_stack_flush ();
-          break;
-
-        case gdb_agent_op_pop:
-          emit_pop ();
-          break;
-
-        case gdb_agent_op_zero_ext:
-          arg = aexpr->bytes[pc++];
-          if (arg < (sizeof (LONGEST) * 8))
-            emit_zero_ext (arg);
-          break;
-
-        case gdb_agent_op_swap:
-          next_op = aexpr->bytes[pc];
-          /* Detect greater-than comparison sequences.  */
-          if (next_op == gdb_agent_op_less_signed
-              && !is_goto_target (aexpr, pc)
-              && (aexpr->bytes[pc + 1] == gdb_agent_op_if_goto)
-              && !is_goto_target (aexpr, pc + 1))
-            {
-              trace_debug ("Combining swap & less_signed & if_goto");
-              pc += 2;
-              aentry->pc = pc;
-              arg = aexpr->bytes[pc++];
-              arg = (arg << 8) + aexpr->bytes[pc++];
-              aentry->goto_pc = arg;
-              emit_gt_goto (&(aentry->from_offset), &(aentry->from_size));
-            }
-          else if (next_op == gdb_agent_op_less_signed
-                   && !is_goto_target (aexpr, pc)
-                   && (aexpr->bytes[pc + 1] == gdb_agent_op_log_not)
-                   && !is_goto_target (aexpr, pc + 1)
-                   && (aexpr->bytes[pc + 2] == gdb_agent_op_if_goto)
-                   && !is_goto_target (aexpr, pc + 2))
-            {
-              trace_debug ("Combining swap & less_signed & log_not & if_goto");
-              pc += 3;
-              aentry->pc = pc;
-              arg = aexpr->bytes[pc++];
-              arg = (arg << 8) + aexpr->bytes[pc++];
-              aentry->goto_pc = arg;
-              emit_le_goto (&(aentry->from_offset), &(aentry->from_size));
-            }
-          else
-            emit_swap ();
-          break;
-
-        case gdb_agent_op_getv:
-          emit_stack_flush ();
-          arg = aexpr->bytes[pc++];
-          arg = (arg << 8) + aexpr->bytes[pc++];
-          emit_int_call_1 (ipa_sym_addrs.addr_get_trace_state_variable_value,
-                           arg);
-          break;
-
-        case gdb_agent_op_setv:
-          arg = aexpr->bytes[pc++];
-          arg = (arg << 8) + aexpr->bytes[pc++];
-          emit_void_call_2 (ipa_sym_addrs.addr_set_trace_state_variable_value,
-                            arg);
-          break;
-
-        case gdb_agent_op_tracev:
-          UNHANDLED;
-          break;
-
-          /* GDB never (currently) generates any of these ops.  */
-        case gdb_agent_op_float:
-        case gdb_agent_op_ref_float:
-        case gdb_agent_op_ref_double:
-        case gdb_agent_op_ref_long_double:
-        case gdb_agent_op_l_to_d:
-        case gdb_agent_op_d_to_l:
-        case gdb_agent_op_trace16:
-          UNHANDLED;
-          break;
-
-        default:
-          trace_debug ("Agent expression op 0x%x not recognized\n", op);
-          /* Don't struggle on, things will just get worse.  */
-          return expr_eval_unrecognized_opcode;
-        }
-
-      /* This catches errors that occur in target-specific code
-         emission.  */
-      if (emit_error)
-        {
-          trace_debug ("Error %d while emitting code for %s\n",
-                       emit_error, gdb_agent_op_name (op));
-          return expr_eval_unhandled_opcode;
-        }
-
-      trace_debug ("Op %s compiled\n", gdb_agent_op_name (op));
-    }
-
-  /* Now fill in real addresses as goto destinations.  */
-  for (aentry = bytecode_address_table; aentry; aentry = aentry->next)
-    {
-      int written = 0;
-
-      if (aentry->goto_pc < 0)
-        continue;
-
-      /* Find the location that we are going to, and call back into
-         target-specific code to write the actual address or
-         displacement.  */
-      for (aentry2 = bytecode_address_table; aentry2; aentry2 = aentry2->next)
-        {
-          if (aentry2->pc == aentry->goto_pc)
-            {
-              trace_debug ("Want to jump from %s to %s\n",
-                           paddress (aentry->address),
-                           paddress (aentry2->address));
-              write_goto_address (aentry->address + aentry->from_offset,
-                                  aentry2->address, aentry->from_size);
-              written = 1;
-              break;
-            }
-        }
-
-      /* Error out if we didn't find a destination.  */
-      if (!written)
-        {
-          trace_debug ("Destination of goto %d not found\n",
-                       aentry->goto_pc);
-          return expr_eval_invalid_goto;
-        }
-    }
-
-  return expr_eval_no_error;
-}
-
 /* 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 *));
 }
 
@@ skipping 110 matching lines @@
       /* The pointers array.  */
       actions_array
         = target_malloc (sizeof (*tpoint->actions) * tpoint->numactions);
       write_inferior_data_ptr (tpptr + offsetof (struct tracepoint,
                                                  actions),
                                actions_array);
 
       /* Now for each pointer, download the action.  */
       for (i = 0; i < tpoint->numactions; i++)
         {
-          CORE_ADDR ipa_action = 0;
           struct tracepoint_action *action = tpoint->actions[i];
-
-          switch (action->type)
-            {
-            case 'M':
-              ipa_action
-                = target_malloc (sizeof (struct collect_memory_action));
-              write_inferior_memory (ipa_action,
-                                     (unsigned char *) action,
-                                     sizeof (struct collect_memory_action));
-              break;
-            case 'R':
-              ipa_action
-                = target_malloc (sizeof (struct collect_registers_action));
-              write_inferior_memory (ipa_action,
-                                     (unsigned char *) action,
-                                     sizeof (struct collect_registers_action));
-              break;
-            case 'X':
-              {
-                CORE_ADDR expr;
-                struct eval_expr_action *eaction
-                  = (struct eval_expr_action *) action;
-
-                ipa_action = target_malloc (sizeof (*eaction));
-                write_inferior_memory (ipa_action,
-                                       (unsigned char *) eaction,
-                                       sizeof (*eaction));
-
-                expr = download_agent_expr (eaction->expr);
-                write_inferior_data_ptr
-                  (ipa_action + offsetof (struct eval_expr_action, expr),
-                   expr);
-                break;
-              }
-            case 'L':
-              ipa_action = target_malloc
-                (sizeof (struct collect_static_trace_data_action));
-              write_inferior_memory
-                (ipa_action,
-                 (unsigned char *) action,
-                 sizeof (struct collect_static_trace_data_action));
-              break;
-            default:
-              trace_debug ("unknown trace action '%c', ignoring",
-                           action->type);
-              break;
-            }
+          CORE_ADDR ipa_action = action->ops->download (action);
 
           if (ipa_action != 0)
             write_inferior_data_ptr
               (actions_array + i * sizeof (sizeof (*tpoint->actions)),
                ipa_action);
         }
     }
 }
 
+#define IPA_PROTO_FAST_TRACE_FLAG 0
+#define IPA_PROTO_FAST_TRACE_ADDR_ON_TARGET 2
+#define IPA_PROTO_FAST_TRACE_JUMP_PAD 10
+#define IPA_PROTO_FAST_TRACE_FJUMP_SIZE 18
+#define IPA_PROTO_FAST_TRACE_FJUMP_INSN 22
+
+/* Send a command to agent to download and install tracepoint TPOINT.  */
+
+static int
+tracepoint_send_agent (struct tracepoint *tpoint)
+{
+  char buf[IPA_CMD_BUF_SIZE];
+  char *p;
+  int i, ret;
+
+  p = buf;
+  strcpy (p, "FastTrace:");
+  p += 10;
+
+  COPY_FIELD_TO_BUF (p, tpoint, number);
+  COPY_FIELD_TO_BUF (p, tpoint, address);
+  COPY_FIELD_TO_BUF (p, tpoint, type);
+  COPY_FIELD_TO_BUF (p, tpoint, enabled);
+  COPY_FIELD_TO_BUF (p, tpoint, step_count);
+  COPY_FIELD_TO_BUF (p, tpoint, pass_count);
+  COPY_FIELD_TO_BUF (p, tpoint, numactions);
+  COPY_FIELD_TO_BUF (p, tpoint, hit_count);
+  COPY_FIELD_TO_BUF (p, tpoint, traceframe_usage);
+  COPY_FIELD_TO_BUF (p, tpoint, compiled_cond);
+  COPY_FIELD_TO_BUF (p, tpoint, orig_size);
+
+  /* condition */
+  p = agent_expr_send (p, tpoint->cond);
+
+  /* tracepoint_action */
+  for (i = 0; i < tpoint->numactions; i++)
+    {
+      struct tracepoint_action *action = tpoint->actions[i];
+
+      p[0] = action->type;
+      p = action->ops->send (&p[1], action);
+    }
+
+  get_jump_space_head ();
+  /* Copy the value of GDB_JUMP_PAD_HEAD to command buffer, so that
+     agent can use jump pad from it.  */
+  if (tpoint->type == fast_tracepoint)
+    {
+      memcpy (p, &gdb_jump_pad_head, 8);
+      p += 8;
+    }
+
+  ret = run_inferior_command (buf, (int) (ptrdiff_t) (p - buf));
+  if (ret)
+    return ret;
+
+  if (strncmp (buf, "OK", 2) != 0)
+    return 1;
+
+  /* The value of tracepoint's target address is stored in BUF.  */
+  memcpy (&tpoint->obj_addr_on_target,
+          &buf[IPA_PROTO_FAST_TRACE_ADDR_ON_TARGET], 8);
+
+  if (tpoint->type == fast_tracepoint)
+    {
+      unsigned char *insn
+        = (unsigned char *) &buf[IPA_PROTO_FAST_TRACE_FJUMP_INSN];
+      int fjump_size;
+
+     trace_debug ("agent: read from cmd_buf 0x%x 0x%x\n",
+                  (unsigned int) tpoint->obj_addr_on_target,
+                  (unsigned int) gdb_jump_pad_head);
+
+      memcpy (&gdb_jump_pad_head, &buf[IPA_PROTO_FAST_TRACE_JUMP_PAD], 8);
+
+      /* This has been done in agent.  We should also set up record for it.  */
+      memcpy (&fjump_size, &buf[IPA_PROTO_FAST_TRACE_FJUMP_SIZE], 4);
+      /* Wire it in.  */
+      tpoint->handle
+        = set_fast_tracepoint_jump (tpoint->address, insn, fjump_size);
+    }
+
+  return 0;
+}
+
 static void
 download_tracepoint (struct tracepoint *tpoint)
 {
   struct tracepoint *tp, *tp_prev;
 
   if (tpoint->type != fast_tracepoint
       && tpoint->type != static_tracepoint)
     return;
 
   download_tracepoint_1 (tpoint);
@@ skipping 28 matching lines @@
     }
   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);
 
 }
 
 static void
-download_tracepoints (void)
-{
-  CORE_ADDR tpptr = 0, prev_tpptr = 0;
-  struct tracepoint *tpoint;
-
-  /* Start out empty.  */
-  write_inferior_data_ptr (ipa_sym_addrs.addr_tracepoints, 0);
-
-  for (tpoint = tracepoints; tpoint; tpoint = tpoint->next)
-    {
-      if (tpoint->type != fast_tracepoint
-          && tpoint->type != static_tracepoint)
-        continue;
-
-      prev_tpptr = tpptr;
-
-      download_tracepoint_1 (tpoint);
-
-      tpptr = tpoint->obj_addr_on_target;
-
-      if (tpoint == tracepoints)
-        {
-          /* First object in list, set the head pointer in the
-             inferior.  */
-          write_inferior_data_ptr (ipa_sym_addrs.addr_tracepoints, tpptr);
-        }
-      else
-        {
-          write_inferior_data_ptr (prev_tpptr + offsetof (struct tracepoint,
-                                                          next),
-                                   tpptr);
-        }
-    }
-}
-
-static void
 download_trace_state_variables (void)
 {
   CORE_ADDR ptr = 0, prev_ptr = 0;
   struct trace_state_variable *tsv;
 
   /* Start out empty.  */
   write_inferior_data_ptr (ipa_sym_addrs.addr_trace_state_variables, 0);
 
   for (tsv = trace_state_variables; tsv != NULL; tsv = tsv->next)
     {
@@ skipping 315 matching lines @@
   unpause_all (1);
 
   if (trace_buffer_is_full)
     stop_tracing ();
 }
 #endif
 
 #ifdef IN_PROCESS_AGENT
 
 IP_AGENT_EXPORT int ust_loaded;
-IP_AGENT_EXPORT char cmd_buf[CMD_BUF_SIZE];
+IP_AGENT_EXPORT char cmd_buf[IPA_CMD_BUF_SIZE];
 
 #ifdef HAVE_UST
 
 /* Static tracepoints.  */
 
 /* UST puts a "struct tracepoint" in the global namespace, which
    conflicts with our tracepoint.  Arguably, being a library, it
    shouldn't take ownership of such a generic name.  We work around it
    here.  */
 #define tracepoint ust_tracepoint
@@ skipping 172 matching lines @@
    tracing library by the user, at the time of the tracepoint marker
    call.  E.g., in the UST marker call:
 
      trace_mark (ust, bar33, "str %s", "FOOBAZ");
 
    the collected data is "str FOOBAZ".
 */
 
 static void
 collect_ust_data_at_tracepoint (struct tracepoint_hit_ctx *ctx,
-                                CORE_ADDR stop_pc,
-                                struct tracepoint *tpoint,
                                 struct traceframe *tframe)
 {
   struct static_tracepoint_ctx *umd = (struct static_tracepoint_ctx *) ctx;
   unsigned char *bufspace;
   int size;
   va_list copy;
   unsigned short blocklen;
 
   if (umd == NULL)
     {
@@ skipping 36 matching lines @@
 static struct ltt_available_probe gdb_ust_probe =
   {
     GDB_PROBE_NAME,
     NULL,
     gdb_probe,
   };
 
 #endif /* HAVE_UST */
 #endif /* IN_PROCESS_AGENT */
 
-#ifdef HAVE_UST
-
-#include <sys/socket.h>
-#include <sys/un.h>
-
-#ifndef UNIX_PATH_MAX
-#define UNIX_PATH_MAX sizeof(((struct sockaddr_un *) NULL)->sun_path)
-#endif
-
-/* Where we put the socked used for synchronization.  */
-#define SOCK_DIR P_tmpdir
-
-#endif /* HAVE_UST */
-
 #ifndef IN_PROCESS_AGENT
 
-#ifdef HAVE_UST
-
-static int
-gdb_ust_connect_sync_socket (int pid)
-{
-  struct sockaddr_un addr;
-  int res, fd;
-  char path[UNIX_PATH_MAX];
-
-  res = xsnprintf (path, UNIX_PATH_MAX, "%s/gdb_ust%d", SOCK_DIR, pid);
-  if (res >= UNIX_PATH_MAX)
-    {
-      trace_debug ("string overflow allocating socket name");
-      return -1;
-    }
-
-  res = fd = socket (PF_UNIX, SOCK_STREAM, 0);
-  if (res == -1)
-    {
-      warning ("error opening sync socket: %s\n", strerror (errno));
-      return -1;
-    }
-
-  addr.sun_family = AF_UNIX;
-
-  res = xsnprintf (addr.sun_path, UNIX_PATH_MAX, "%s", path);
-  if (res >= UNIX_PATH_MAX)
-    {
-      warning ("string overflow allocating socket name\n");
-      close (fd);
-      return -1;
-    }
-
-  res = connect (fd, (struct sockaddr *) &addr, sizeof (addr));
-  if (res == -1)
-    {
-      warning ("error connecting sync socket (%s): %s. "
-               "Make sure the directory exists and that it is writable.",
-               path, strerror (errno));
-      close (fd);
-      return -1;
-    }
-
-  return fd;
-}
-
-/* Resume thread PTID.  */
-
-static void
-resume_thread (ptid_t ptid)
-{
-  struct thread_resume resume_info;
-
-  resume_info.thread = ptid;
-  resume_info.kind = resume_continue;
-  resume_info.sig = TARGET_SIGNAL_0;
-  (*the_target->resume) (&resume_info, 1);
-}
-
-/* Stop thread PTID.  */
-
-static void
-stop_thread (ptid_t ptid)
-{
-  struct thread_resume resume_info;
-
-  resume_info.thread = ptid;
-  resume_info.kind = resume_stop;
-  resume_info.sig = TARGET_SIGNAL_0;
-  (*the_target->resume) (&resume_info, 1);
-}
-
 /* Ask the in-process agent to run a command.  Since we don't want to
    have to handle the IPA hitting breakpoints while running the
    command, we pause all threads, remove all breakpoints, and then set
    the helper thread re-running.  We communicate with the helper
    thread by means of direct memory xfering, and a socket for
    synchronization.  */
 
 static int
-run_inferior_command (char *cmd)
+run_inferior_command (char *cmd, int len)
 {
   int err = -1;
-  int fd = -1;
   int pid = ptid_get_pid (current_inferior->entry.id);
-  int tid;
-  ptid_t ptid = null_ptid;
 
   trace_debug ("run_inferior_command: running: %s", cmd);
 
   pause_all (0);
   uninsert_all_breakpoints ();
 
-  if (read_inferior_integer (ipa_sym_addrs.addr_helper_thread_id, &tid))
-    {
-      warning ("Error reading helper thread's id in lib");
-      goto out;
-    }
-
-  if (tid == 0)
-    {
-      warning ("helper thread not initialized yet");
-      goto out;
-    }
-
-  if (write_inferior_memory (ipa_sym_addrs.addr_cmd_buf,
-                             (unsigned char *) cmd, strlen (cmd) + 1))
-    {
-      warning ("Error writing command");
-      goto out;
-    }
-
-  ptid = ptid_build (pid, tid, 0);
-
-  resume_thread (ptid);
-
-  fd = gdb_ust_connect_sync_socket (pid);
-  if (fd >= 0)
-    {
-      char buf[1] = "";
-      int ret;
-
-      trace_debug ("signalling helper thread");
-
-      do
-        {
-          ret = write (fd, buf, 1);
-        } while (ret == -1 && errno == EINTR);
-
-      trace_debug ("waiting for helper thread's response");
-
-      do
-        {
-          ret = read (fd, buf, 1);
-        } while (ret == -1 && errno == EINTR);
-
-      close (fd);
-
-      trace_debug ("helper thread's response received");
-    }
-
- out:
-
-  /* Need to read response with the inferior stopped.  */
-  if (!ptid_equal (ptid, null_ptid))
-    {
-      int was_non_stop = non_stop;
-      struct target_waitstatus status;
-
-      stop_thread (ptid);
-      non_stop = 1;
-      mywait (ptid, &status, 0, 0);
-      non_stop = was_non_stop;
-    }
-
-  if (fd >= 0)
-    {
-      if (read_inferior_memory (ipa_sym_addrs.addr_cmd_buf,
-                                (unsigned char *) cmd, CMD_BUF_SIZE))
-        {
-          warning ("Error reading command response");
-        }
-      else
-        {
-          err = 0;
-          trace_debug ("run_inferior_command: response: %s", cmd);
-        }
-    }
+  err = agent_run_command (pid, (const char *) cmd, len);
 
   reinsert_all_breakpoints ();
   unpause_all (0);
 
   return err;
 }
 
-#else /* HAVE_UST */
+#else /* !IN_PROCESS_AGENT */
 
-static int
-run_inferior_command (char *cmd)
-{
-  return -1;
-}
+#include <sys/socket.h>
+#include <sys/un.h>
 
-#endif /* HAVE_UST */
+#ifndef UNIX_PATH_MAX
+#define UNIX_PATH_MAX sizeof(((struct sockaddr_un *) NULL)->sun_path)
+#endif
 
-#else /* !IN_PROCESS_AGENT */
+/* Where we put the socked used for synchronization.  */
+#define SOCK_DIR P_tmpdir
 
 /* 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;
 
-#ifdef HAVE_UST
-
 static int
 init_named_socket (const char *name)
 {
   int result, fd;
   struct sockaddr_un addr;
 
   result = fd = socket (PF_UNIX, SOCK_STREAM, 0);
   if (result == -1)
     {
       warning ("socket creation failed: %s", strerror (errno));
@@ skipping 32 matching lines @@
     {
       warning ("listen: %s", strerror (errno));
       close (fd);
       return -1;
     }
 
   return fd;
 }
 
 static int
-gdb_ust_socket_init (void)
+gdb_agent_socket_init (void)
 {
   int result, fd;
   char name[UNIX_PATH_MAX];
 
   result = xsnprintf (name, UNIX_PATH_MAX, "%s/gdb_ust%d",
                       SOCK_DIR, getpid ());
   if (result >= UNIX_PATH_MAX)
     {
       trace_debug ("string overflow allocating socket name");
       return -1;
     }
 
   fd = init_named_socket (name);
   if (fd < 0)
     warning ("Error initializing named socket (%s) for communication with the "
              "ust helper thread. Check that directory exists and that it "
              "is writable.", name);
 
   return fd;
 }
 
-/* Return an hexstr version of the STR C string, fit for sending to
-   GDB.  */
-
-static char *
-cstr_to_hexstr (const char *str)
-{
-  int len = strlen (str);
-  char *hexstr = xmalloc (len * 2 + 1);
-  convert_int_to_ascii ((gdb_byte *) str, hexstr, len);
-  return hexstr;
-}
+#ifdef HAVE_UST
 
 /* The next marker to be returned on a qTsSTM command.  */
 static const struct marker *next_st;
 
 /* Returns the first known marker.  */
 
 struct marker *
 first_marker (void)
 {
   struct marker_iter iter;
@@ skipping 19 matching lines @@
       if (iter.marker == m)
         {
           USTF(marker_iter_next) (&iter);
           return iter.marker;
         }
     }
 
   return NULL;
 }
 
+/* Return an hexstr version of the STR C string, fit for sending to
+   GDB.  */
+
+static char *
+cstr_to_hexstr (const char *str)
+{
+  int len = strlen (str);
+  char *hexstr = xmalloc (len * 2 + 1);
+  convert_int_to_ascii ((gdb_byte *) str, hexstr, len);
+  return hexstr;
+}
+
 /* Compose packet that is the response to the qTsSTM/qTfSTM/qTSTMat
    packets.  */
 
 static void
 response_ust_marker (char *packet, const struct marker *st)
 {
   char *strid, *format, *tmp;
 
   next_st = next_marker (st);
 
@@ skipping 140 matching lines @@
     if ((uintptr_t ) m->location == address)
       {
         response_ust_marker (packet, m);
         return 0;
       }
 
   strcpy (packet, "l");
   return -1;
 }
 
+static void
+gdb_ust_init (void)
+{
+  if (!dlsym_ust ())
+    return;
+
+  USTF(ltt_probe_register) (&gdb_ust_probe);
+}
+
+#endif /* HAVE_UST */
+
+#include <sys/syscall.h>
+
+/* Helper thread of agent.  */
+
 static void *
-gdb_ust_thread (void *arg)
+gdb_agent_helper_thread (void *arg)
 {
   int listen_fd;
 
   while (1)
     {
-      listen_fd = gdb_ust_socket_init ();
+      listen_fd = gdb_agent_socket_init ();
 
-#ifdef SYS_gettid
       if (helper_thread_id == 0)
         helper_thread_id = syscall (SYS_gettid);
-#endif
 
       if (listen_fd == -1)
         {
           warning ("could not create sync socket\n");
           break;
         }
 
       while (1)
         {
           socklen_t tmp;
@@ skipping 26 matching lines @@
           if (ret == -1)
             {
               warning ("reading socket (fd=%d) failed with %s",
                        fd, strerror (errno));
               close (fd);
               break;
             }
 
           if (cmd_buf[0])
             {
+#ifdef HAVE_UST
               if (strcmp ("qTfSTM", cmd_buf) == 0)
                 {
                   cmd_qtfstm (cmd_buf);
                 }
               else if (strcmp ("qTsSTM", cmd_buf) == 0)
                 {
                   cmd_qtsstm (cmd_buf);
                 }
               else if (strncmp ("unprobe_marker_at:",
                                 cmd_buf,
                                 sizeof ("unprobe_marker_at:") - 1) == 0)
                 {
                   unprobe_marker_at (cmd_buf);
                 }
               else if (strncmp ("probe_marker_at:",
                                 cmd_buf,
                                 sizeof ("probe_marker_at:") - 1) == 0)
                 {
                   probe_marker_at (cmd_buf);
                 }
               else if (strncmp ("qTSTMat:",
                                 cmd_buf,
                                 sizeof ("qTSTMat:") - 1) == 0)
                 {
                   cmd_qtstmat (cmd_buf);
                 }
-              else if (strcmp (cmd_buf, "help") == 0)
-                {
-                  strcpy (cmd_buf, "for help, press F1\n");
-                }
-              else
-                strcpy (cmd_buf, "");
+#endif /* HAVE_UST */
             }
 
-          write (fd, buf, 1);
+          /* Fix compiler's warning: ignoring return value of 'write'.  */
+          ret = write (fd, buf, 1);
           close (fd);
         }
     }
 
   return NULL;
 }
 
 #include <signal.h>
+#include <pthread.h>
+
+IP_AGENT_EXPORT int gdb_agent_capability = AGENT_CAPA_STATIC_TRACE;
 
 static void
-gdb_ust_init (void)
+gdb_agent_init (void)
 {
   int res;
   pthread_t thread;
   sigset_t new_mask;
   sigset_t orig_mask;
 
-  if (!dlsym_ust ())
-    return;
-
   /* We want the helper thread to be as transparent as possible, so
      have it inherit an all-signals-blocked mask.  */
 
   sigfillset (&new_mask);
   res = pthread_sigmask (SIG_SETMASK, &new_mask, &orig_mask);
   if (res)
     fatal ("pthread_sigmask (1) failed: %s", strerror (res));
 
   res = pthread_create (&thread,
                         NULL,
-                        gdb_ust_thread,
+                        gdb_agent_helper_thread,
                         NULL);
 
   res = pthread_sigmask (SIG_SETMASK, &orig_mask, NULL);
   if (res)
     fatal ("pthread_sigmask (2) failed: %s", strerror (res));
 
   while (helper_thread_id == 0)
     usleep (1);
 
-  USTF(ltt_probe_register) (&gdb_ust_probe);
+#ifdef HAVE_UST
+  gdb_ust_init ();
+#endif
 }
 
-#endif /* HAVE_UST */
-
 #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;
 
@@ skipping 10 matching lines @@
     strncpy (gdb_trampoline_buffer_error, errmsg, 99);
   else
     strcpy (gdb_trampoline_buffer_error, "no buffer passed");
 }
 
 static void __attribute__ ((constructor))
 initialize_tracepoint_ftlib (void)
 {
   initialize_tracepoint ();
 
-#ifdef HAVE_UST
-  gdb_ust_init ();
-#endif
+  gdb_agent_init ();
 }
 
 #endif /* IN_PROCESS_AGENT */
 
 /* Return a timestamp, expressed as microseconds of the usual Unix
    time.  (As the result is a 64-bit number, it will not overflow any
    time soon.)  */
 
 static LONGEST
 get_timestamp (void)
@@ skipping 17 matching lines @@
   /* Wire trace state variable 1 to be the timestamp.  This will be
      uploaded to GDB upon connection and become one of its trace state
      variables.  (In case you're wondering, if GDB already has a trace
      variable numbered 1, it will be renumbered.)  */
   create_trace_state_variable (1, 0);
   set_trace_state_variable_name (1, "trace_timestamp");
   set_trace_state_variable_getter (1, get_timestamp);
 
 #ifdef IN_PROCESS_AGENT
   {
+    uintptr_t addr;
     int pagesize;
+
     pagesize = sysconf (_SC_PAGE_SIZE);
     if (pagesize == -1)
       fatal ("sysconf");
 
     gdb_tp_heap_buffer = xmalloc (5 * 1024 * 1024);
 
-    /* Allocate scratch buffer aligned on a page boundary.  */
-    gdb_jump_pad_buffer = memalign (pagesize, pagesize * 20);
-    gdb_jump_pad_buffer_end = gdb_jump_pad_buffer + pagesize * 20;
+#define SCRATCH_BUFFER_NPAGES 20
 
-    /* Make it writable and executable.  */
-    if (mprotect (gdb_jump_pad_buffer, pagesize * 20,
-                  PROT_READ | PROT_WRITE | PROT_EXEC) != 0)
+    /* 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: mprotect(%p, %d, PROT_READ|PROT_EXEC) failed with %s",
-             gdb_jump_pad_buffer, pagesize * 20, strerror (errno));
+initialize_tracepoint: mmap'ing jump pad buffer failed with %s",
+             strerror (errno));
+
+    gdb_jump_pad_buffer_end = gdb_jump_pad_buffer + pagesize * SCRATCH_BUFFER_NPAGES;
   }
 
   gdb_trampoline_buffer = gdb_trampoline_buffer_end = 0;
 
   /* It's not a fatal error for something to go wrong with trampoline
      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);
 
   strcpy (gdb_trampoline_buffer_error, "No errors reported");
 
   initialize_low_tracepoint ();
 #endif
 }