Convert SystemTap probe interface to C++ (and perform some cleanups)

This patch converts the SystemTap probe
interface (gdb/stap-probe.[ch]) to C++, and also performs some
cleanups that were on my TODO list for a while.

The main changes were the conversion of 'struct stap_probe' to 'class
stap_probe', and a new 'class stap_static_probe_ops' to replace the
use of 'stap_probe_ops'.  Both classes implement the virtual methods
exported by their parents, 'class probe' and 'class static_probe_ops',
respectively.  I believe it's now a bit simpler to understand the
logic behind the stap-probe interface.

There are several helper functions used to parse parts of a stap
probe, and since they are generic and don't need to know about the
probe they're working on, I decided to leave them as simple static
functions (instead of e.g. converting them to class methods).

I've also converted a few uses of "VEC" to "std::vector", which makes
the code simpler and easier to maintain.  And, as usual, some cleanups
here and there.

Even though I'm sending a series of patches, they need to be tested
and committed as a single unit, because of inter-dependencies.  But it
should be easier to review in separate logical units.

I've regtested this patch on BuildBot, no regressions found.

gdb/ChangeLog:
2017-11-22  Sergio Durigan Junior  <sergiodj@redhat.com>
	    Simon Marchi  <simark@simark.ca>

	* stap-probe.c (struct probe_ops stap_probe_ops): Delete
	variable.
	(struct stap_probe_arg) <stap_probe_arg>: New constructor.
	<aexpr>: Change type to 'expression_up'.
	(stap_probe_arg_s): Delete type and VEC.
	(struct stap_probe): Delete.  Replace by...
	(class stap_static_probe_ops): ...this and...
	(class stap_probe): ...this.  Rename variables to add 'm_'
	prefix.  Do not use 'union' for arguments anymore.
	(stap_get_expected_argument_type): Receive probe name instead
	of 'struct stap_probe'.  Adjust code.
	(stap_parse_probe_arguments): Rename to...
	(stap_probe::parse_arguments): ...this.  Adjust code to
	reflect change.
	(stap_get_probe_address): Rename to...
	(stap_probe::get_relocated_address): ...this.  Adjust code
	to reflect change.
	(stap_get_probe_argument_count): Rename to...
	(stap_probe::get_argument_count): ...this.  Adjust code
	to reflect change.
	(stap_get_arg): Rename to...
	(stap_probe::get_arg_by_number'): ...this. Adjust code to
	reflect change.
	(can_evaluate_probe_arguments): Rename to...
	(stap_probe::can_evaluate_arguments): ...this.  Adjust code
	to reflect change.
	(stap_evaluate_probe_argument): Rename to...
	(stap_probe::evaluate_argument): ...this.  Adjust code
	to reflect change.
	(stap_compile_to_ax): Rename to...
	(stap_probe::compile_to_ax): ...this.  Adjust code to
	reflect change.
	(stap_probe_destroy): Delete.
	(stap_modify_semaphore): Adjust comment.
	(stap_set_semaphore): Rename to...
	(stap_probe::set_semaphore): ...this.  Adjust code to reflect
	change.
	(stap_clear_semaphore): Rename to...
	(stap_probe::clear_semaphore): ...this.  Adjust code to
	reflect	change.
	(stap_probe::get_static_ops): New method.
	(handle_stap_probe): Adjust code to create instance of
	'stap_probe'.
	(stap_get_probes): Rename to...
	(stap_static_probe_ops::get_probes): ...this.  Adjust code to
	reflect change.
	(stap_probe_is_linespec): Rename to...
	(stap_static_probe_ops::is_linespec): ...this.  Adjust code to
	reflect change.
	(stap_type_name): Rename to...
	(stap_static_probe_ops::type_name): ...this.  Adjust code to
	reflect change.
	(stap_gen_info_probes_table_header): Rename to...
	(stap_static_probe_ops::gen_info_probes_table_header):
	...this.  Adjust code to reflect change.
	(stap_gen_info_probes_table_values): Rename to...
	(stap_probe::gen_info_probes_table_values): ...this.  Adjust
	code to reflect change.
	(struct probe_ops stap_probe_ops): Delete.
	(info_probes_stap_command): Use 'info_probes_for_spops'
	instead of 'info_probes_for_ops'.
	(_initialize_stap_probe): Use 'all_static_probe_ops' instead
	of 'all_probe_ops'.

2 files changed, 328 insertions, 273 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 2121e3e..b385f54 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,4 +1,71 @@
 2017-11-22  Sergio Durigan Junior  <sergiodj@redhat.com>
+	    Simon Marchi  <simark@simark.ca>
+
+	* stap-probe.c (struct probe_ops stap_probe_ops): Delete
+	variable.
+	(struct stap_probe_arg) <stap_probe_arg>: New constructor.
+	<aexpr>: Change type to 'expression_up'.
+	(stap_probe_arg_s): Delete type and VEC.
+	(struct stap_probe): Delete.  Replace by...
+	(class stap_static_probe_ops): ...this and...
+	(class stap_probe): ...this.  Rename variables to add 'm_'
+	prefix.  Do not use 'union' for arguments anymore.
+	(stap_get_expected_argument_type): Receive probe name instead
+	of 'struct stap_probe'.  Adjust code.
+	(stap_parse_probe_arguments): Rename to...
+	(stap_probe::parse_arguments): ...this.  Adjust code to
+	reflect change.
+	(stap_get_probe_address): Rename to...
+	(stap_probe::get_relocated_address): ...this.  Adjust code
+	to reflect change.
+	(stap_get_probe_argument_count): Rename to...
+	(stap_probe::get_argument_count): ...this.  Adjust code
+	to reflect change.
+	(stap_get_arg): Rename to...
+	(stap_probe::get_arg_by_number'): ...this. Adjust code to
+	reflect change.
+	(can_evaluate_probe_arguments): Rename to...
+	(stap_probe::can_evaluate_arguments): ...this.  Adjust code
+	to reflect change.
+	(stap_evaluate_probe_argument): Rename to...
+	(stap_probe::evaluate_argument): ...this.  Adjust code
+	to reflect change.
+	(stap_compile_to_ax): Rename to...
+	(stap_probe::compile_to_ax): ...this.  Adjust code to
+	reflect change.
+	(stap_probe_destroy): Delete.
+	(stap_modify_semaphore): Adjust comment.
+	(stap_set_semaphore): Rename to...
+	(stap_probe::set_semaphore): ...this.  Adjust code to reflect
+	change.
+	(stap_clear_semaphore): Rename to...
+	(stap_probe::clear_semaphore): ...this.  Adjust code to
+	reflect	change.
+	(stap_probe::get_static_ops): New method.
+	(handle_stap_probe): Adjust code to create instance of
+	'stap_probe'.
+	(stap_get_probes): Rename to...
+	(stap_static_probe_ops::get_probes): ...this.  Adjust code to
+	reflect change.
+	(stap_probe_is_linespec): Rename to...
+	(stap_static_probe_ops::is_linespec): ...this.  Adjust code to
+	reflect change.
+	(stap_type_name): Rename to...
+	(stap_static_probe_ops::type_name): ...this.  Adjust code to
+	reflect change.
+	(stap_gen_info_probes_table_header): Rename to...
+	(stap_static_probe_ops::gen_info_probes_table_header):
+	...this.  Adjust code to reflect change.
+	(stap_gen_info_probes_table_values): Rename to...
+	(stap_probe::gen_info_probes_table_values): ...this.  Adjust
+	code to reflect change.
+	(struct probe_ops stap_probe_ops): Delete.
+	(info_probes_stap_command): Use 'info_probes_for_spops'
+	instead of 'info_probes_for_ops'.
+	(_initialize_stap_probe): Use 'all_static_probe_ops' instead
+	of 'all_probe_ops'.
+
+2017-11-22  Sergio Durigan Junior  <sergiodj@redhat.com>
 
 	* break-catch-throw.c (fetch_probe_arguments): Use
 	'probe.prob' instead of 'probe.probe'.
diff --git a/gdb/stap-probe.c b/gdb/stap-probe.c
index 6fa0d20..63100c9 100644
--- a/gdb/stap-probe.c
+++ b/gdb/stap-probe.c
@@ -45,10 +45,6 @@
 
 #define STAP_BASE_SECTION_NAME ".stapsdt.base"
 
-/* Forward declaration. */
-
-extern const struct probe_ops stap_probe_ops;
-
 /* Should we display debug information for the probe's argument expression
    parsing?  */
 
@@ -85,6 +81,12 @@ enum stap_arg_bitness
 
 struct stap_probe_arg
 {
+  /* Constructor for stap_probe_arg.  */
+  stap_probe_arg (enum stap_arg_bitness bitness_, struct type *atype_,
+		  expression_up &&aexpr_)
+  : bitness (bitness_), atype (atype_), aexpr (std::move (aexpr_))
+  {}
+
   /* The bitness of this argument.  */
   enum stap_arg_bitness bitness;
 
@@ -92,35 +94,134 @@ struct stap_probe_arg
   struct type *atype;
 
   /* The argument converted to an internal GDB expression.  */
-  struct expression *aexpr;
+  expression_up aexpr;
 };
 
-typedef struct stap_probe_arg stap_probe_arg_s;
-DEF_VEC_O (stap_probe_arg_s);
+/* Class that implements the static probe methods for "stap" probes.  */
 
-struct stap_probe
+class stap_static_probe_ops : public static_probe_ops
 {
-  /* Generic information about the probe.  This shall be the first element
-     of this struct, in order to maintain binary compatibility with the
-     `struct probe' and be able to fully abstract it.  */
-  struct probe p;
+public:
+  /* See probe.h.  */
+  bool is_linespec (const char **linespecp) const override;
 
+  /* See probe.h.  */
+  void get_probes (std::vector<probe *> *probesp,
+		   struct objfile *objfile) const override;
+
+  /* See probe.h.  */
+  const char *type_name () const override;
+
+  /* See probe.h.  */
+  std::vector<struct info_probe_column> gen_info_probes_table_header
+    () const override;
+};
+
+/* SystemTap static_probe_ops.  */
+
+const stap_static_probe_ops stap_static_probe_ops;
+
+class stap_probe : public probe
+{
+public:
+  /* Constructor for stap_probe.  */
+  stap_probe (std::string &&name_, std::string &&provider_, CORE_ADDR address_,
+	      struct gdbarch *arch_, CORE_ADDR sem_addr, const char *args_text)
+    : probe (std::move (name_), std::move (provider_), address_, arch_),
+      m_sem_addr (sem_addr),
+      m_have_parsed_args (false), m_unparsed_args_text (args_text)
+  {}
+
+  /* See probe.h.  */
+  CORE_ADDR get_relocated_address (struct objfile *objfile) override;
+
+  /* See probe.h.  */
+  unsigned get_argument_count (struct frame_info *frame) override;
+
+  /* See probe.h.  */
+  bool can_evaluate_arguments () const override;
+
+  /* See probe.h.  */
+  struct value *evaluate_argument (unsigned n,
+				   struct frame_info *frame) override;
+
+  /* See probe.h.  */
+  void compile_to_ax (struct agent_expr *aexpr,
+		      struct axs_value *axs_value,
+		      unsigned n) override;
+
+  /* See probe.h.  */
+  void set_semaphore (struct objfile *objfile,
+		      struct gdbarch *gdbarch) override;
+
+  /* See probe.h.  */
+  void clear_semaphore (struct objfile *objfile,
+			struct gdbarch *gdbarch) override;
+
+  /* See probe.h.  */
+  const static_probe_ops *get_static_ops () const override;
+
+  /* See probe.h.  */
+  std::vector<const char *> gen_info_probes_table_values () const override;
+
+  /* Return argument N of probe.
+
+     If the probe's arguments have not been parsed yet, parse them.  If
+     there are no arguments, throw an exception (error).  Otherwise,
+     return the requested argument.  */
+  struct stap_probe_arg *get_arg_by_number (unsigned n,
+					    struct gdbarch *gdbarch)
+  {
+    if (!m_have_parsed_args)
+      this->parse_arguments (gdbarch);
+
+    gdb_assert (m_have_parsed_args);
+    if (m_parsed_args.empty ())
+      internal_error (__FILE__, __LINE__,
+		      _("Probe '%s' apparently does not have arguments, but \n"
+			"GDB is requesting its argument number %u anyway.  "
+			"This should not happen.  Please report this bug."),
+		      this->get_name ().c_str (), n);
+
+    if (n > m_parsed_args.size ())
+      internal_error (__FILE__, __LINE__,
+		      _("Probe '%s' has %d arguments, but GDB is requesting\n"
+			"argument %u.  This should not happen.  Please\n"
+			"report this bug."),
+		      this->get_name ().c_str (),
+		      (int) m_parsed_args.size (), n);
+
+    return &m_parsed_args[n];
+  }
+
+  /* Function which parses an argument string from the probe,
+     correctly splitting the arguments and storing their information
+     in properly ways.
+
+     Consider the following argument string (x86 syntax):
+
+     `4@%eax 4@$10'
+
+     We have two arguments, `%eax' and `$10', both with 32-bit
+     unsigned bitness.  This function basically handles them, properly
+     filling some structures with this information.  */
+  void parse_arguments (struct gdbarch *gdbarch);
+
+private:
   /* If the probe has a semaphore associated, then this is the value of
      it, relative to SECT_OFF_DATA.  */
-  CORE_ADDR sem_addr;
+  CORE_ADDR m_sem_addr;
 
-  /* One if the arguments have been parsed.  */
-  unsigned int args_parsed : 1;
+  /* True if the arguments have been parsed.  */
+  bool m_have_parsed_args;
 
-  union
-    {
-      const char *text;
+  /* The text version of the probe's arguments, unparsed.  */
+  const char *m_unparsed_args_text;
 
-      /* Information about each argument.  This is an array of `stap_probe_arg',
-	 with each entry representing one argument.  */
-      VEC (stap_probe_arg_s) *vec;
-    }
-  args_u;
+  /* Information about each argument.  This is an array of `stap_probe_arg',
+     with each entry representing one argument.  This is only valid if
+     M_ARGS_PARSED is true.  */
+  std::vector<struct stap_probe_arg> m_parsed_args;
 };
 
 /* When parsing the arguments, we have to establish different precedences
@@ -326,7 +427,7 @@ stap_get_opcode (const char **s)
 static struct type *
 stap_get_expected_argument_type (struct gdbarch *gdbarch,
 				 enum stap_arg_bitness b,
-				 const struct stap_probe *probe)
+				 const char *probe_name)
 {
   switch (b)
     {
@@ -361,8 +462,7 @@ stap_get_expected_argument_type (struct gdbarch *gdbarch,
       return builtin_type (gdbarch)->builtin_uint64;
 
     default:
-      error (_("Undefined bitness for probe '%s'."),
-	     probe->p.name);
+      error (_("Undefined bitness for probe '%s'."), probe_name);
       break;
     }
 }
@@ -1039,10 +1139,10 @@ stap_parse_argument_1 (struct stap_parse_info *p, int has_lhs,
    - If we find an operator, we skip it.
 
    This function can also call a special function that will try to match
-   unknown tokens.  It will return 1 if the argument has been parsed
-   successfully, or zero otherwise.  */
+   unknown tokens.  It will return the expression_up generated from
+   parsing the argument.  */
 
-static struct expression *
+static expression_up
 stap_parse_argument (const char **arg, struct type *atype,
 		     struct gdbarch *gdbarch)
 {
@@ -1078,41 +1178,27 @@ stap_parse_argument (const char **arg, struct type *atype,
   *arg = p.arg;
 
   /* We can safely return EXPOUT here.  */
-  return p.pstate.expout;
+  return expression_up (p.pstate.expout);
 }
 
-/* Function which parses an argument string from PROBE, correctly splitting
-   the arguments and storing their information in properly ways.
-
-   Consider the following argument string (x86 syntax):
-
-   `4@%eax 4@$10'
+/* Implementation of 'parse_arguments' method.  */
 
-   We have two arguments, `%eax' and `$10', both with 32-bit unsigned bitness.
-   This function basically handles them, properly filling some structures with
-   this information.  */
-
-static void
-stap_parse_probe_arguments (struct stap_probe *probe, struct gdbarch *gdbarch)
+void
+stap_probe::parse_arguments (struct gdbarch *gdbarch)
 {
   const char *cur;
 
-  gdb_assert (!probe->args_parsed);
-  cur = probe->args_u.text;
-  probe->args_parsed = 1;
-  probe->args_u.vec = NULL;
+  gdb_assert (!m_have_parsed_args);
+  cur = m_unparsed_args_text;
+  m_have_parsed_args = true;
 
   if (cur == NULL || *cur == '\0' || *cur == ':')
     return;
 
   while (*cur != '\0')
     {
-      struct stap_probe_arg arg;
-      enum stap_arg_bitness b;
-      int got_minus = 0;
-      struct expression *expr;
-
-      memset (&arg, 0, sizeof (arg));
+      enum stap_arg_bitness bitness;
+      bool got_minus = false;
 
       /* We expect to find something like:
 
@@ -1128,30 +1214,30 @@ stap_parse_probe_arguments (struct stap_probe *probe, struct gdbarch *gdbarch)
 	    {
 	      /* Discard the `-'.  */
 	      ++cur;
-	      got_minus = 1;
+	      got_minus = true;
 	    }
 
 	  /* Defining the bitness.  */
 	  switch (*cur)
 	    {
 	    case '1':
-	      b = (got_minus ? STAP_ARG_BITNESS_8BIT_SIGNED
-		   : STAP_ARG_BITNESS_8BIT_UNSIGNED);
+	      bitness = (got_minus ? STAP_ARG_BITNESS_8BIT_SIGNED
+			 : STAP_ARG_BITNESS_8BIT_UNSIGNED);
 	      break;
 
 	    case '2':
-	      b = (got_minus ? STAP_ARG_BITNESS_16BIT_SIGNED
-		   : STAP_ARG_BITNESS_16BIT_UNSIGNED);
+	      bitness = (got_minus ? STAP_ARG_BITNESS_16BIT_SIGNED
+			 : STAP_ARG_BITNESS_16BIT_UNSIGNED);
 	      break;
 
 	    case '4':
-	      b = (got_minus ? STAP_ARG_BITNESS_32BIT_SIGNED
-		   : STAP_ARG_BITNESS_32BIT_UNSIGNED);
+	      bitness = (got_minus ? STAP_ARG_BITNESS_32BIT_SIGNED
+			 : STAP_ARG_BITNESS_32BIT_UNSIGNED);
 	      break;
 
 	    case '8':
-	      b = (got_minus ? STAP_ARG_BITNESS_64BIT_SIGNED
-		   : STAP_ARG_BITNESS_64BIT_UNSIGNED);
+	      bitness = (got_minus ? STAP_ARG_BITNESS_64BIT_SIGNED
+			 : STAP_ARG_BITNESS_64BIT_UNSIGNED);
 	      break;
 
 	    default:
@@ -1159,67 +1245,60 @@ stap_parse_probe_arguments (struct stap_probe *probe, struct gdbarch *gdbarch)
 		/* We have an error, because we don't expect anything
 		   except 1, 2, 4 and 8.  */
 		warning (_("unrecognized bitness %s%c' for probe `%s'"),
-			 got_minus ? "`-" : "`", *cur, probe->p.name);
+			 got_minus ? "`-" : "`", *cur,
+			 this->get_name ().c_str ());
 		return;
 	      }
 	    }
-
-	  arg.bitness = b;
-
 	  /* Discard the number and the `@' sign.  */
 	  cur += 2;
 	}
       else
-	arg.bitness = STAP_ARG_BITNESS_UNDEFINED;
+	bitness = STAP_ARG_BITNESS_UNDEFINED;
 
-      arg.atype = stap_get_expected_argument_type (gdbarch, arg.bitness,
-						   probe);
+      struct type *atype
+	= stap_get_expected_argument_type (gdbarch, bitness,
+					   this->get_name ().c_str ());
 
-      expr = stap_parse_argument (&cur, arg.atype, gdbarch);
+      expression_up expr = stap_parse_argument (&cur, atype, gdbarch);
 
       if (stap_expression_debug)
-	dump_raw_expression (expr, gdb_stdlog,
+	dump_raw_expression (expr.get (), gdb_stdlog,
 			     "before conversion to prefix form");
 
-      prefixify_expression (expr);
+      prefixify_expression (expr.get ());
 
       if (stap_expression_debug)
-	dump_prefix_expression (expr, gdb_stdlog);
+	dump_prefix_expression (expr.get (), gdb_stdlog);
 
-      arg.aexpr = expr;
+      m_parsed_args.emplace_back (bitness, atype, std::move (expr));
 
       /* Start it over again.  */
       cur = skip_spaces (cur);
-
-      VEC_safe_push (stap_probe_arg_s, probe->args_u.vec, &arg);
     }
 }
 
-/* Implementation of the get_probe_address method.  */
+/* Implementation of the get_relocated_address method.  */
 
-static CORE_ADDR
-stap_get_probe_address (struct probe *probe, struct objfile *objfile)
+CORE_ADDR
+stap_probe::get_relocated_address (struct objfile *objfile)
 {
-  return probe->address + ANOFFSET (objfile->section_offsets,
-				    SECT_OFF_DATA (objfile));
+  return this->get_address () + ANOFFSET (objfile->section_offsets,
+					  SECT_OFF_DATA (objfile));
 }
 
 /* Given PROBE, returns the number of arguments present in that probe's
    argument string.  */
 
-static unsigned
-stap_get_probe_argument_count (struct probe *probe_generic,
-			       struct frame_info *frame)
+unsigned
+stap_probe::get_argument_count (struct frame_info *frame)
 {
-  struct stap_probe *probe = (struct stap_probe *) probe_generic;
   struct gdbarch *gdbarch = get_frame_arch (frame);
 
-  gdb_assert (probe_generic->pops == &stap_probe_ops);
-
-  if (!probe->args_parsed)
+  if (!m_have_parsed_args)
     {
-      if (can_evaluate_probe_arguments (probe_generic))
-	stap_parse_probe_arguments (probe, gdbarch);
+      if (this->can_evaluate_arguments ())
+	this->parse_arguments (gdbarch);
       else
 	{
 	  static int have_warned_stap_incomplete = 0;
@@ -1234,13 +1313,12 @@ stap_get_probe_argument_count (struct probe *probe_generic,
 	    }
 
 	  /* Marking the arguments as "already parsed".  */
-	  probe->args_u.vec = NULL;
-	  probe->args_parsed = 1;
+	  m_have_parsed_args = true;
 	}
     }
 
-  gdb_assert (probe->args_parsed);
-  return VEC_length (stap_probe_arg_s, probe->args_u.vec);
+  gdb_assert (m_have_parsed_args);
+  return m_parsed_args.size ();
 }
 
 /* Return 1 if OP is a valid operator inside a probe argument, or zero
@@ -1279,36 +1357,12 @@ stap_is_operator (const char *op)
   return ret;
 }
 
-/* Return argument N of probe PROBE.
+/* Implement the `can_evaluate_arguments' method.  */
 
-   If the probe's arguments have not been parsed yet, parse them.  If
-   there are no arguments, throw an exception (error).  Otherwise,
-   return the requested argument.  */
-
-static struct stap_probe_arg *
-stap_get_arg (struct stap_probe *probe, unsigned n, struct gdbarch *gdbarch)
-{
-  if (!probe->args_parsed)
-    stap_parse_probe_arguments (probe, gdbarch);
-
-  gdb_assert (probe->args_parsed);
-  if (probe->args_u.vec == NULL)
-    internal_error (__FILE__, __LINE__,
-		    _("Probe '%s' apparently does not have arguments, but \n"
-		      "GDB is requesting its argument number %u anyway.  "
-		      "This should not happen.  Please report this bug."),
-		    probe->p.name, n);
-
-  return VEC_index (stap_probe_arg_s, probe->args_u.vec, n);
-}
-
-/* Implement the `can_evaluate_probe_arguments' method of probe_ops.  */
-
-static int
-stap_can_evaluate_probe_arguments (struct probe *probe_generic)
+bool
+stap_probe::can_evaluate_arguments () const
 {
-  struct stap_probe *stap_probe = (struct stap_probe *) probe_generic;
-  struct gdbarch *gdbarch = stap_probe->p.arch;
+  struct gdbarch *gdbarch = this->get_gdbarch ();
 
   /* For SystemTap probes, we have to guarantee that the method
      stap_is_single_operand is defined on gdbarch.  If it is not, then it
@@ -1319,71 +1373,42 @@ stap_can_evaluate_probe_arguments (struct probe *probe_generic)
 /* Evaluate the probe's argument N (indexed from 0), returning a value
    corresponding to it.  Assertion is thrown if N does not exist.  */
 
-static struct value *
-stap_evaluate_probe_argument (struct probe *probe_generic, unsigned n,
-			      struct frame_info *frame)
+struct value *
+stap_probe::evaluate_argument (unsigned n, struct frame_info *frame)
 {
-  struct stap_probe *stap_probe = (struct stap_probe *) probe_generic;
-  struct gdbarch *gdbarch = get_frame_arch (frame);
   struct stap_probe_arg *arg;
   int pos = 0;
+  struct gdbarch *gdbarch = get_frame_arch (frame);
 
-  gdb_assert (probe_generic->pops == &stap_probe_ops);
-
-  arg = stap_get_arg (stap_probe, n, gdbarch);
-  return evaluate_subexp_standard (arg->atype, arg->aexpr, &pos, EVAL_NORMAL);
+  arg = this->get_arg_by_number (n, gdbarch);
+  return evaluate_subexp_standard (arg->atype, arg->aexpr.get (), &pos,
+				   EVAL_NORMAL);
 }
 
 /* Compile the probe's argument N (indexed from 0) to agent expression.
    Assertion is thrown if N does not exist.  */
 
-static void
-stap_compile_to_ax (struct probe *probe_generic, struct agent_expr *expr,
-		    struct axs_value *value, unsigned n)
+void
+stap_probe::compile_to_ax (struct agent_expr *expr, struct axs_value *value,
+			   unsigned n)
 {
-  struct stap_probe *stap_probe = (struct stap_probe *) probe_generic;
   struct stap_probe_arg *arg;
   union exp_element *pc;
 
-  gdb_assert (probe_generic->pops == &stap_probe_ops);
-
-  arg = stap_get_arg (stap_probe, n, expr->gdbarch);
+  arg = this->get_arg_by_number (n, expr->gdbarch);
 
   pc = arg->aexpr->elts;
-  gen_expr (arg->aexpr, &pc, expr, value);
+  gen_expr (arg->aexpr.get (), &pc, expr, value);
 
   require_rvalue (expr, value);
   value->type = arg->atype;
 }
-
-/* Destroy (free) the data related to PROBE.  PROBE memory itself is not feed
-   as it is allocated on an obstack.  */
-
-static void
-stap_probe_destroy (struct probe *probe_generic)
-{
-  struct stap_probe *probe = (struct stap_probe *) probe_generic;
-
-  gdb_assert (probe_generic->pops == &stap_probe_ops);
-
-  if (probe->args_parsed)
-    {
-      struct stap_probe_arg *arg;
-      int ix;
-
-      for (ix = 0; VEC_iterate (stap_probe_arg_s, probe->args_u.vec, ix, arg);
-	   ++ix)
-	xfree (arg->aexpr);
-      VEC_free (stap_probe_arg_s, probe->args_u.vec);
-    }
-}
-
 
 
 /* Set or clear a SystemTap semaphore.  ADDRESS is the semaphore's
-   address.  SET is zero if the semaphore should be cleared, or one
-   if it should be set.  This is a helper function for `stap_semaphore_down'
-   and `stap_semaphore_up'.  */
+   address.  SET is zero if the semaphore should be cleared, or one if
+   it should be set.  This is a helper function for
+   'stap_probe::set_semaphore' and 'stap_probe::clear_semaphore'.  */
 
 static void
 stap_modify_semaphore (CORE_ADDR address, int set, struct gdbarch *gdbarch)
@@ -1419,41 +1444,47 @@ stap_modify_semaphore (CORE_ADDR address, int set, struct gdbarch *gdbarch)
     warning (_("Could not write the value of a SystemTap semaphore."));
 }
 
-/* Set a SystemTap semaphore.  SEM is the semaphore's address.  Semaphores
-   act as reference counters, so calls to this function must be paired with
-   calls to `stap_semaphore_down'.
+/* Implementation of the 'set_semaphore' method.
 
-   This function and `stap_semaphore_down' race with another tool changing
-   the probes, but that is too rare to care.  */
+   SystemTap semaphores act as reference counters, so calls to this
+   function must be paired with calls to 'clear_semaphore'.
 
-static void
-stap_set_semaphore (struct probe *probe_generic, struct objfile *objfile,
-		    struct gdbarch *gdbarch)
+   This function and 'clear_semaphore' race with another tool
+   changing the probes, but that is too rare to care.  */
+
+void
+stap_probe::set_semaphore (struct objfile *objfile, struct gdbarch *gdbarch)
 {
-  struct stap_probe *probe = (struct stap_probe *) probe_generic;
-  CORE_ADDR addr;
+  stap_modify_semaphore (this->get_relocated_address (objfile), 1, gdbarch);
+}
 
-  gdb_assert (probe_generic->pops == &stap_probe_ops);
+/* Implementation of the 'clear_semaphore' method.  */
 
-  addr = (probe->sem_addr
-	  + ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)));
-  stap_modify_semaphore (addr, 1, gdbarch);
+void
+stap_probe::clear_semaphore (struct objfile *objfile, struct gdbarch *gdbarch)
+{
+  stap_modify_semaphore (this->get_relocated_address (objfile), 0, gdbarch);
 }
 
-/* Clear a SystemTap semaphore.  SEM is the semaphore's address.  */
+/* Implementation of the 'get_static_ops' method.  */
 
-static void
-stap_clear_semaphore (struct probe *probe_generic, struct objfile *objfile,
-		      struct gdbarch *gdbarch)
+const static_probe_ops *
+stap_probe::get_static_ops () const
+{
+  return &stap_static_probe_ops;
+}
+
+/* Implementation of the 'gen_info_probes_table_values' method.  */
+
+std::vector<const char *>
+stap_probe::gen_info_probes_table_values () const
 {
-  struct stap_probe *probe = (struct stap_probe *) probe_generic;
-  CORE_ADDR addr;
+  const char *val = NULL;
 
-  gdb_assert (probe_generic->pops == &stap_probe_ops);
+  if (m_sem_addr != 0)
+    val = print_core_address (this->get_gdbarch (), m_sem_addr);
 
-  addr = (probe->sem_addr
-	  + ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)));
-  stap_modify_semaphore (addr, 0, gdbarch);
+  return std::vector<const char *> { val };
 }
 
 /* Helper function that parses the information contained in a
@@ -1478,21 +1509,14 @@ handle_stap_probe (struct objfile *objfile, struct sdt_note *el,
   int size = bfd_get_arch_size (abfd) / 8;
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
   struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
-  CORE_ADDR base_ref;
-  const char *probe_args = NULL;
-  struct stap_probe *ret;
-
-  ret = XOBNEW (&objfile->per_bfd->storage_obstack, struct stap_probe);
-  ret->p.pops = &stap_probe_ops;
-  ret->p.arch = gdbarch;
 
   /* Provider and the name of the probe.  */
-  ret->p.provider = (char *) &el->data[3 * size];
-  ret->p.name = ((const char *)
-		 memchr (ret->p.provider, '\0',
-			 (char *) el->data + el->size - ret->p.provider));
+  const char *provider = (const char *) &el->data[3 * size];
+  const char *name = ((const char *)
+		      memchr (provider, '\0',
+			      (char *) el->data + el->size - provider));
   /* Making sure there is a name.  */
-  if (ret->p.name == NULL)
+  if (name == NULL)
     {
       complaint (&symfile_complaints, _("corrupt probe name when "
 					"reading `%s'"),
@@ -1503,32 +1527,32 @@ handle_stap_probe (struct objfile *objfile, struct sdt_note *el,
       return;
     }
   else
-    ++ret->p.name;
+    ++name;
 
   /* Retrieving the probe's address.  */
-  ret->p.address = extract_typed_address (&el->data[0], ptr_type);
+  CORE_ADDR address = extract_typed_address (&el->data[0], ptr_type);
 
   /* Link-time sh_addr of `.stapsdt.base' section.  */
-  base_ref = extract_typed_address (&el->data[size], ptr_type);
+  CORE_ADDR base_ref = extract_typed_address (&el->data[size], ptr_type);
 
   /* Semaphore address.  */
-  ret->sem_addr = extract_typed_address (&el->data[2 * size], ptr_type);
+  CORE_ADDR sem_addr = extract_typed_address (&el->data[2 * size], ptr_type);
 
-  ret->p.address += base - base_ref;
-  if (ret->sem_addr != 0)
-    ret->sem_addr += base - base_ref;
+  address += base - base_ref;
+  if (sem_addr != 0)
+    sem_addr += base - base_ref;
 
   /* Arguments.  We can only extract the argument format if there is a valid
      name for this probe.  */
-  probe_args = ((const char*)
-		memchr (ret->p.name, '\0',
-			(char *) el->data + el->size - ret->p.name));
+  const char *probe_args = ((const char*)
+			    memchr (name, '\0',
+				    (char *) el->data + el->size - name));
 
   if (probe_args != NULL)
     ++probe_args;
 
   if (probe_args == NULL
-      || (memchr (probe_args, '\0', (char *) el->data + el->size - ret->p.name)
+      || (memchr (probe_args, '\0', (char *) el->data + el->size - name)
 	  != el->data + el->size - 1))
     {
       complaint (&symfile_complaints, _("corrupt probe argument when "
@@ -1539,11 +1563,11 @@ handle_stap_probe (struct objfile *objfile, struct sdt_note *el,
       return;
     }
 
-  ret->args_parsed = 0;
-  ret->args_u.text = probe_args;
+  stap_probe *ret = new stap_probe (std::string (name), std::string (provider),
+				    address, gdbarch, sem_addr, probe_args);
 
   /* Successfully created probe.  */
-  probesp->push_back ((struct probe *) ret);
+  probesp->push_back (ret);
 }
 
 /* Helper function which tries to find the base address of the SystemTap
@@ -1584,11 +1608,21 @@ get_stap_base_address (bfd *obfd, bfd_vma *base)
   return 1;
 }
 
-/* Helper function for `elf_get_probes', which gathers information about all
-   SystemTap probes from OBJFILE.  */
+/* Implementation of the 'is_linespec' method.  */
 
-static void
-stap_get_probes (std::vector<probe *> *probesp, struct objfile *objfile)
+bool
+stap_static_probe_ops::is_linespec (const char **linespecp) const
+{
+  static const char *const keywords[] = { "-pstap", "-probe-stap", NULL };
+
+  return probe_is_linespec_by_keyword (linespecp, keywords);
+}
+
+/* Implementation of the 'get_probes' method.  */
+
+void
+stap_static_probe_ops::get_probes (std::vector<probe *> *probesp,
+				   struct objfile *objfile) const
 {
   /* If we are here, then this is the first time we are parsing the
      SystemTap probe's information.  We basically have to count how many
@@ -1640,83 +1674,37 @@ stap_get_probes (std::vector<probe *> *probesp, struct objfile *objfile)
 
 /* Implementation of the type_name method.  */
 
-static const char *
-stap_type_name (struct probe *probe)
+const char *
+stap_static_probe_ops::type_name () const
 {
-  gdb_assert (probe->pops == &stap_probe_ops);
   return "stap";
 }
 
-static int
-stap_probe_is_linespec (const char **linespecp)
-{
-  static const char *const keywords[] = { "-pstap", "-probe-stap", NULL };
+/* Implementation of the 'gen_info_probes_table_header' method.  */
 
-  return probe_is_linespec_by_keyword (linespecp, keywords);
-}
-
-static void
-stap_gen_info_probes_table_header (VEC (info_probe_column_s) **heads)
+std::vector<struct info_probe_column>
+stap_static_probe_ops::gen_info_probes_table_header () const
 {
-  info_probe_column_s stap_probe_column;
+  struct info_probe_column stap_probe_column;
 
   stap_probe_column.field_name = "semaphore";
   stap_probe_column.print_name = _("Semaphore");
 
-  VEC_safe_push (info_probe_column_s, *heads, &stap_probe_column);
+  return std::vector<struct info_probe_column> { stap_probe_column };
 }
 
-static void
-stap_gen_info_probes_table_values (struct probe *probe_generic,
-				   VEC (const_char_ptr) **ret)
-{
-  struct stap_probe *probe = (struct stap_probe *) probe_generic;
-  struct gdbarch *gdbarch;
-  const char *val = NULL;
-
-  gdb_assert (probe_generic->pops == &stap_probe_ops);
-
-  gdbarch = probe->p.arch;
-
-  if (probe->sem_addr != 0)
-    val = print_core_address (gdbarch, probe->sem_addr);
-
-  VEC_safe_push (const_char_ptr, *ret, val);
-}
-
-/* SystemTap probe_ops.  */
-
-const struct probe_ops stap_probe_ops =
-{
-  stap_probe_is_linespec,
-  stap_get_probes,
-  stap_get_probe_address,
-  stap_get_probe_argument_count,
-  stap_can_evaluate_probe_arguments,
-  stap_evaluate_probe_argument,
-  stap_compile_to_ax,
-  stap_set_semaphore,
-  stap_clear_semaphore,
-  stap_probe_destroy,
-  stap_type_name,
-  stap_gen_info_probes_table_header,
-  stap_gen_info_probes_table_values,
-  NULL,  /* enable_probe  */
-  NULL   /* disable_probe  */
-};
-
 /* Implementation of the `info probes stap' command.  */
 
 static void
 info_probes_stap_command (const char *arg, int from_tty)
 {
-  info_probes_for_ops (arg, from_tty, &stap_probe_ops);
+  info_probes_for_spops (arg, from_tty, &stap_static_probe_ops);
 }
 
 void
 _initialize_stap_probe (void)
 {
-  all_probe_ops.push_back (&stap_probe_ops);
+  all_static_probe_ops.push_back (&stap_static_probe_ops);
 
   add_setshow_zuinteger_cmd ("stap-expression", class_maintenance,
 			     &stap_expression_debug,