diff --git a/gdb/break-catch-throw.c b/gdb/break-catch-throw.c
index fd8a113803..ffc100bb24 100644
--- a/gdb/break-catch-throw.c
+++ b/gdb/break-catch-throw.c
@@ -106,20 +106,20 @@ fetch_probe_arguments (struct value **arg0, struct value **arg1)
   unsigned n_args;
 
   pc_probe = find_probe_by_pc (pc);
-  if (pc_probe.probe == NULL
-      || strcmp (pc_probe.probe->provider, "libstdcxx") != 0
-      || (strcmp (pc_probe.probe->name, "catch") != 0
-	  && strcmp (pc_probe.probe->name, "throw") != 0
-	  && strcmp (pc_probe.probe->name, "rethrow") != 0))
+  if (pc_probe.prob == NULL
+      || strcmp (pc_probe.prob->get_provider (), "libstdcxx") != 0
+      || (strcmp (pc_probe.prob->get_name (), "catch") != 0
+	  && strcmp (pc_probe.prob->get_name (), "throw") != 0
+	  && strcmp (pc_probe.prob->get_name (), "rethrow") != 0))
     error (_("not stopped at a C++ exception catchpoint"));
 
-  n_args = get_probe_argument_count (pc_probe.probe, frame);
+  n_args = pc_probe.prob->get_argument_count (frame);
   if (n_args < 2)
     error (_("C++ exception catchpoint has too few arguments"));
 
   if (arg0 != NULL)
-    *arg0 = evaluate_probe_argument (pc_probe.probe, 0, frame);
-  *arg1 = evaluate_probe_argument (pc_probe.probe, 1, frame);
+    *arg0 = pc_probe.prob->evaluate_argument (0, frame);
+  *arg1 = pc_probe.prob->evaluate_argument (1, frame);
 
   if ((arg0 != NULL && *arg0 == NULL) || *arg1 == NULL)
     error (_("error computing probe argument at c++ exception catchpoint"));
diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index b170a14cb5..1728aee838 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -3309,7 +3309,7 @@ create_longjmp_master_breakpoint (void)
 	      /* We are only interested in checking one element.  */
 	      probe *p = ret[0];
 
-	      if (!can_evaluate_probe_arguments (p))
+	      if (!p->can_evaluate_arguments ())
 		{
 		  /* We cannot use the probe interface here, because it does
 		     not know how to evaluate arguments.  */
@@ -3329,7 +3329,7 @@ create_longjmp_master_breakpoint (void)
 	      struct breakpoint *b;
 
 	      b = create_internal_breakpoint (gdbarch,
-					      get_probe_address (p, objfile),
+					      p->get_relocated_address (objfile),
 					      bp_longjmp_master,
 					      &internal_breakpoint_ops);
 	      b->location = new_probe_location ("-probe-stap libc:longjmp");
@@ -3462,7 +3462,7 @@ create_exception_master_breakpoint (void)
 	      /* We are only interested in checking one element.  */
 	      probe *p = ret[0];
 
-	      if (!can_evaluate_probe_arguments (p))
+	      if (!p->can_evaluate_arguments ())
 		{
 		  /* We cannot use the probe interface here, because it does
 		     not know how to evaluate arguments.  */
@@ -3482,7 +3482,7 @@ create_exception_master_breakpoint (void)
 	      struct breakpoint *b;
 
 	      b = create_internal_breakpoint (gdbarch,
-					      get_probe_address (p, objfile),
+					      p->get_relocated_address (objfile),
 					      bp_exception_master,
 					      &internal_breakpoint_ops);
 	      b->location = new_probe_location ("-probe-stap libgcc:unwind");
@@ -8694,7 +8694,7 @@ add_location_to_breakpoint (struct breakpoint *b,
   loc->requested_address = sal->pc;
   loc->address = adjusted_address;
   loc->pspace = sal->pspace;
-  loc->probe.probe = sal->probe;
+  loc->probe.prob = sal->prob;
   loc->probe.objfile = sal->objfile;
   gdb_assert (loc->pspace != NULL);
   loc->section = sal->section;
@@ -12879,10 +12879,7 @@ bkpt_probe_insert_location (struct bp_location *bl)
     {
       /* The insertion was successful, now let's set the probe's semaphore
 	 if needed.  */
-      if (bl->probe.probe->pops->set_semaphore != NULL)
-	bl->probe.probe->pops->set_semaphore (bl->probe.probe,
-					      bl->probe.objfile,
-					      bl->gdbarch);
+      bl->probe.prob->set_semaphore (bl->probe.objfile, bl->gdbarch);
     }
 
   return v;
@@ -12893,10 +12890,7 @@ bkpt_probe_remove_location (struct bp_location *bl,
 			    enum remove_bp_reason reason)
 {
   /* Let's clear the semaphore before removing the location.  */
-  if (bl->probe.probe->pops->clear_semaphore != NULL)
-    bl->probe.probe->pops->clear_semaphore (bl->probe.probe,
-					    bl->probe.objfile,
-					    bl->gdbarch);
+  bl->probe.prob->clear_semaphore (bl->probe.objfile, bl->gdbarch);
 
   return bkpt_remove_location (bl, reason);
 }
diff --git a/gdb/elfread.c b/gdb/elfread.c
index cdef5a8c59..f2483025ba 100644
--- a/gdb/elfread.c
+++ b/gdb/elfread.c
@@ -1324,7 +1324,7 @@ elf_get_probes (struct objfile *objfile)
 
       /* Here we try to gather information about all types of probes from the
 	 objfile.  */
-      for (const probe_ops *ops : all_probe_ops)
+      for (const static_probe_ops *ops : all_static_probe_ops)
 	ops->get_probes (probes_per_bfd, objfile);
 
       set_bfd_data (objfile->obfd, probe_key, probes_per_bfd);
@@ -1342,7 +1342,7 @@ probe_key_free (bfd *abfd, void *d)
   std::vector<probe *> *probes = (std::vector<probe *> *) d;
 
   for (probe *p : *probes)
-    p->pops->destroy (p);
+    delete p;
 
   delete probes;
 }
diff --git a/gdb/infrun.c b/gdb/infrun.c
index e2d1248e75..4592100962 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -7583,7 +7583,7 @@ check_exception_resume (struct execution_control_state *ecs,
      CFA and the HANDLER.  We ignore the CFA, extract the handler, and
      set a breakpoint there.  */
   probe = find_probe_by_pc (get_frame_pc (frame));
-  if (probe.probe)
+  if (probe.prob)
     {
       insert_exception_resume_from_probe (ecs->event_thread, &probe, frame);
       return;
diff --git a/gdb/location.c b/gdb/location.c
index c78778edc1..5ed3623f0a 100644
--- a/gdb/location.c
+++ b/gdb/location.c
@@ -844,7 +844,7 @@ string_to_event_location_basic (const char **stringp,
 
   /* Try the input as a probe spec.  */
   cs = *stringp;
-  if (cs != NULL && probe_linespec_to_ops (&cs) != NULL)
+  if (cs != NULL && probe_linespec_to_static_ops (&cs) != NULL)
     {
       location = new_probe_location (*stringp);
       *stringp += strlen (*stringp);
diff --git a/gdb/probe.c b/gdb/probe.c
index 829f6d18d7..0c47f904cb 100644
--- a/gdb/probe.c
+++ b/gdb/probe.c
@@ -38,11 +38,38 @@
 #include <algorithm>
 #include "common/gdb_optional.h"
 
+/* Class that implements the static probe methods for "any" probe.  */
+
+class any_static_probe_ops : public static_probe_ops
+{
+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.  */
+  bool emit_info_probes_extra_fields () const override;
+
+  /* See probe.h.  */
+  void gen_info_probes_table_header
+    (std::vector<struct info_probe_column> *heads) const override;
+};
+
+/* Static operations associated with a generic probe.  */
+
+const any_static_probe_ops any_static_probe_ops;
+
 /* A helper for parse_probes that decodes a probe specification in
    SEARCH_PSPACE.  It appends matching SALs to RESULT.  */
 
 static void
-parse_probes_in_pspace (const struct probe_ops *probe_ops,
+parse_probes_in_pspace (const static_probe_ops *spops,
 			struct program_space *search_pspace,
 			const char *objfile_namestr,
 			const char *provider,
@@ -67,21 +94,21 @@ parse_probes_in_pspace (const struct probe_ops *probe_ops,
 
       for (probe *p : probes)
 	{
-	  if (probe_ops != &probe_ops_any && p->pops != probe_ops)
+	  if (spops != &any_static_probe_ops && p->get_static_ops () != spops)
 	    continue;
 
-	  if (provider && strcmp (p->provider, provider) != 0)
+	  if (provider && strcmp (p->get_provider (), provider) != 0)
 	    continue;
 
-	  if (strcmp (p->name, name) != 0)
+	  if (strcmp (p->get_name (), name) != 0)
 	    continue;
 
 	  symtab_and_line sal;
-	  sal.pc = get_probe_address (p, objfile);
+	  sal.pc = p->get_relocated_address (objfile);
 	  sal.explicit_pc = 1;
 	  sal.section = find_pc_overlay (sal.pc);
 	  sal.pspace = search_pspace;
-	  sal.probe = p;
+	  sal.prob = p;
 	  sal.objfile = objfile;
 
 	  result->push_back (std::move (sal));
@@ -98,15 +125,14 @@ parse_probes (const struct event_location *location,
 {
   char *arg_end, *arg;
   char *objfile_namestr = NULL, *provider = NULL, *name, *p;
-  const struct probe_ops *probe_ops;
   const char *arg_start, *cs;
 
   gdb_assert (event_location_type (location) == PROBE_LOCATION);
   arg_start = get_probe_location (location);
 
   cs = arg_start;
-  probe_ops = probe_linespec_to_ops (&cs);
-  if (probe_ops == NULL)
+  const static_probe_ops *spops = probe_linespec_to_static_ops (&cs);
+  if (spops == NULL)
     error (_("'%s' is not a probe linespec"), arg_start);
 
   arg = (char *) cs;
@@ -159,7 +185,7 @@ parse_probes (const struct event_location *location,
   std::vector<symtab_and_line> result;
   if (search_pspace != NULL)
     {
-      parse_probes_in_pspace (probe_ops, search_pspace, objfile_namestr,
+      parse_probes_in_pspace (spops, search_pspace, objfile_namestr,
 			      provider, name, &result);
     }
   else
@@ -167,7 +193,7 @@ parse_probes (const struct event_location *location,
       struct program_space *pspace;
 
       ALL_PSPACES (pspace)
-	parse_probes_in_pspace (probe_ops, pspace, objfile_namestr,
+	parse_probes_in_pspace (spops, pspace, objfile_namestr,
 				provider, name, &result);
     }
 
@@ -206,10 +232,10 @@ find_probes_in_objfile (struct objfile *objfile, const char *provider,
     = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
   for (probe *p : probes)
     {
-      if (strcmp (p->provider, provider) != 0)
+      if (strcmp (p->get_provider (), provider) != 0)
 	continue;
 
-      if (strcmp (p->name, name) != 0)
+      if (strcmp (p->get_name (), name) != 0)
 	continue;
 
       result.push_back (p);
@@ -227,7 +253,7 @@ find_probe_by_pc (CORE_ADDR pc)
   struct bound_probe result;
 
   result.objfile = NULL;
-  result.probe = NULL;
+  result.prob = NULL;
 
   ALL_OBJFILES (objfile)
   {
@@ -239,10 +265,10 @@ find_probe_by_pc (CORE_ADDR pc)
     const std::vector<probe *> &probes
       = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
     for (probe *p : probes)
-      if (get_probe_address (p, objfile) == pc)
+      if (p->get_relocated_address (objfile) == pc)
 	{
 	  result.objfile = objfile;
-	  result.probe = p;
+	  result.prob = p;
 	  return result;
 	}
   }
@@ -253,12 +279,13 @@ find_probe_by_pc (CORE_ADDR pc)
 
 
 /* Make a vector of probes matching OBJNAME, PROVIDER, and PROBE_NAME.
-   If POPS is not NULL, only probes of this certain probe_ops will match.
-   Each argument is a regexp, or NULL, which matches anything.  */
+   If SPOPS is not &any_static_probe_ops, only probes related to this
+   specific static probe ops will match.  Each argument is a regexp,
+   or NULL, which matches anything.  */
 
 static std::vector<bound_probe>
 collect_probes (const std::string &objname, const std::string &provider,
-		const std::string &probe_name, const struct probe_ops *pops)
+		const std::string &probe_name, const static_probe_ops *spops)
 {
   struct objfile *objfile;
   std::vector<bound_probe> result;
@@ -290,15 +317,15 @@ collect_probes (const std::string &objname, const std::string &provider,
 
       for (probe *p : probes)
 	{
-	  if (pops != NULL && p->pops != pops)
+	  if (spops != &any_static_probe_ops && p->get_static_ops () != spops)
 	    continue;
 
 	  if (prov_pat
-	      && prov_pat->exec (p->provider, 0, NULL, 0) != 0)
+	      && prov_pat->exec (p->get_provider (), 0, NULL, 0) != 0)
 	    continue;
 
 	  if (probe_pat
-	      && probe_pat->exec (p->name, 0, NULL, 0) != 0)
+	      && probe_pat->exec (p->get_name (), 0, NULL, 0) != 0)
 	    continue;
 
 	  result.emplace_back (p, objfile);
@@ -315,16 +342,16 @@ compare_probes (const bound_probe &a, const bound_probe &b)
 {
   int v;
 
-  v = strcmp (a.probe->provider, b.probe->provider);
+  v = strcmp (a.prob->get_provider (), b.prob->get_provider ());
   if (v != 0)
     return v < 0;
 
-  v = strcmp (a.probe->name, b.probe->name);
+  v = strcmp (a.prob->get_name (), b.prob->get_name ());
   if (v != 0)
     return v < 0;
 
-  if (a.probe->address != b.probe->address)
-    return a.probe->address < b.probe->address;
+  if (a.prob->get_address () != b.prob->get_address ())
+    return a.prob->get_address () < b.prob->get_address ();
 
   return strcmp (objfile_name (a.objfile), objfile_name (b.objfile)) < 0;
 }
@@ -334,56 +361,37 @@ compare_probes (const bound_probe &a, const bound_probe &b)
 
 static void
 gen_ui_out_table_header_info (const std::vector<bound_probe> &probes,
-			      const struct probe_ops *p)
+			      const static_probe_ops *spops)
 {
   /* `headings' refers to the names of the columns when printing `info
      probes'.  */
-  VEC (info_probe_column_s) *headings = NULL;
-  struct cleanup *c;
-  info_probe_column_s *column;
-  size_t headings_size;
-  int ix;
+  std::vector<struct info_probe_column> headings;
 
-  gdb_assert (p != NULL);
+  gdb_assert (spops != NULL);
 
-  if (p->gen_info_probes_table_header == NULL
-      && p->gen_info_probes_table_values == NULL)
+  if (!spops->emit_info_probes_extra_fields ())
     return;
 
-  gdb_assert (p->gen_info_probes_table_header != NULL
-	      && p->gen_info_probes_table_values != NULL);
-
-  c = make_cleanup (VEC_cleanup (info_probe_column_s), &headings);
-  p->gen_info_probes_table_header (&headings);
-
-  headings_size = VEC_length (info_probe_column_s, headings);
+  spops->gen_info_probes_table_header (&headings);
 
-  for (ix = 0;
-       VEC_iterate (info_probe_column_s, headings, ix, column);
-       ++ix)
+  for (struct info_probe_column column : headings)
     {
-      size_t size_max = strlen (column->print_name);
+      size_t size_max = strlen (column.print_name);
 
       for (const bound_probe &probe : probes)
 	{
 	  /* `probe_fields' refers to the values of each new field that this
 	     probe will display.  */
-	  VEC (const_char_ptr) *probe_fields = NULL;
-	  struct cleanup *c2;
-	  const char *val;
-	  int kx;
+	  std::vector<const char *> probe_fields;
 
-	  if (probe.probe->pops != p)
+	  if (probe.prob->get_static_ops () != spops)
 	    continue;
 
-	  c2 = make_cleanup (VEC_cleanup (const_char_ptr), &probe_fields);
-	  p->gen_info_probes_table_values (probe.probe, &probe_fields);
+	  probe.prob->gen_info_probes_table_values (&probe_fields);
 
-	  gdb_assert (VEC_length (const_char_ptr, probe_fields)
-		      == headings_size);
+	  gdb_assert (probe_fields.size () == headings.size ());
 
-	  for (kx = 0; VEC_iterate (const_char_ptr, probe_fields, kx, val);
-	       ++kx)
+	  for (const char *val : probe_fields)
 	    {
 	      /* It is valid to have a NULL value here, which means that the
 		 backend does not have something to write and this particular
@@ -393,128 +401,92 @@ gen_ui_out_table_header_info (const std::vector<bound_probe> &probes,
 
 	      size_max = std::max (strlen (val), size_max);
 	    }
-	  do_cleanups (c2);
 	}
 
       current_uiout->table_header (size_max, ui_left,
-				   column->field_name, column->print_name);
+				   column.field_name, column.print_name);
     }
-
-  do_cleanups (c);
 }
 
 /* Helper function to print not-applicable strings for all the extra
-   columns defined in a probe_ops.  */
+   columns defined in a static_probe_ops.  */
 
 static void
-print_ui_out_not_applicables (const struct probe_ops *pops)
+print_ui_out_not_applicables (const static_probe_ops *spops)
 {
   struct cleanup *c;
-  VEC (info_probe_column_s) *headings = NULL;
-  info_probe_column_s *column;
-  int ix;
+  std::vector<struct info_probe_column> headings;
 
-  if (pops->gen_info_probes_table_header == NULL)
+  if (!spops->emit_info_probes_extra_fields ())
     return;
 
-  c = make_cleanup (VEC_cleanup (info_probe_column_s), &headings);
-  pops->gen_info_probes_table_header (&headings);
-
-  for (ix = 0;
-       VEC_iterate (info_probe_column_s, headings, ix, column);
-       ++ix)
-    current_uiout->field_string (column->field_name, _("n/a"));
+  spops->gen_info_probes_table_header (&headings);
 
-  do_cleanups (c);
+  for (struct info_probe_column column : headings)
+    current_uiout->field_string (column.field_name, _("n/a"));
 }
 
 /* Helper function to print extra information about a probe and an objfile
    represented by PROBE.  */
 
 static void
-print_ui_out_info (struct probe *probe)
+print_ui_out_info (probe *probe)
 {
-  int ix;
-  int j = 0;
   /* `values' refers to the actual values of each new field in the output
      of `info probe'.  `headings' refers to the names of each new field.  */
-  VEC (const_char_ptr) *values = NULL;
-  VEC (info_probe_column_s) *headings = NULL;
-  info_probe_column_s *column;
-  struct cleanup *c;
+  std::vector<struct info_probe_column> headings;
+  std::vector<const char *> values;
+  struct info_probe_column *column;
 
   gdb_assert (probe != NULL);
-  gdb_assert (probe->pops != NULL);
 
-  if (probe->pops->gen_info_probes_table_header == NULL
-      && probe->pops->gen_info_probes_table_values == NULL)
-    return;
+  probe->get_static_ops ()->gen_info_probes_table_header (&headings);
+  probe->gen_info_probes_table_values (&values);
 
-  gdb_assert (probe->pops->gen_info_probes_table_header != NULL
-	      && probe->pops->gen_info_probes_table_values != NULL);
+  gdb_assert (headings.size () == values.size ());
 
-  c = make_cleanup (VEC_cleanup (info_probe_column_s), &headings);
-  make_cleanup (VEC_cleanup (const_char_ptr), &values);
-
-  probe->pops->gen_info_probes_table_header (&headings);
-  probe->pops->gen_info_probes_table_values (probe, &values);
-
-  gdb_assert (VEC_length (info_probe_column_s, headings)
-	      == VEC_length (const_char_ptr, values));
-
-  for (ix = 0;
-       VEC_iterate (info_probe_column_s, headings, ix, column);
-       ++ix)
+  for (int ix = 0; ix < headings.size (); ++ix)
     {
-      const char *val = VEC_index (const_char_ptr, values, j++);
+      struct info_probe_column column = headings[ix];
+      const char *val = values[ix];
 
       if (val == NULL)
-	current_uiout->field_skip (column->field_name);
+	current_uiout->field_skip (column.field_name);
       else
-	current_uiout->field_string (column->field_name, val);
+	current_uiout->field_string (column.field_name, val);
     }
-
-  do_cleanups (c);
 }
 
 /* Helper function that returns the number of extra fields which POPS will
    need.  */
 
 static int
-get_number_extra_fields (const struct probe_ops *pops)
+get_number_extra_fields (const static_probe_ops *spops)
 {
-  VEC (info_probe_column_s) *headings = NULL;
-  struct cleanup *c;
-  int n;
+  std::vector<info_probe_column> headings;
 
-  if (pops->gen_info_probes_table_header == NULL)
+  if (!spops->emit_info_probes_extra_fields ())
     return 0;
 
-  c = make_cleanup (VEC_cleanup (info_probe_column_s), &headings);
-  pops->gen_info_probes_table_header (&headings);
-
-  n = VEC_length (info_probe_column_s, headings);
+  spops->gen_info_probes_table_header (&headings);
 
-  do_cleanups (c);
-
-  return n;
+  return headings.size ();
 }
 
-/* Helper function that returns 1 if there is a probe in PROBES
-   featuring the given POPS.  It returns 0 otherwise.  */
+/* Helper function that returns true if there is a probe in PROBES
+   featuring the given SPOPS.  It returns false otherwise.  */
 
-static int
-exists_probe_with_pops (const std::vector<bound_probe> &probes,
-			const struct probe_ops *pops)
+static bool
+exists_probe_with_spops (const std::vector<bound_probe> &probes,
+			 const static_probe_ops *spops)
 {
   struct bound_probe *probe;
-  int ix;
 
   for (const bound_probe &probe : probes)
-    if (probe.probe->pops == pops)
-      return 1;
+    if (probe.prob->get_static_ops () == spops)
+      return true;
 
-  return 0;
+  return false;
 }
 
 /* Helper function that parses a probe linespec of the form [PROVIDER
@@ -538,8 +510,8 @@ parse_probe_linespec (const char *str, std::string *provider,
 /* See comment in probe.h.  */
 
 void
-info_probes_for_ops (const char *arg, int from_tty,
-		     const struct probe_ops *pops)
+info_probes_for_spops (const char *arg, int from_tty,
+		       const static_probe_ops *spops)
 {
   std::string provider, probe_name, objname;
   int any_found;
@@ -554,26 +526,28 @@ info_probes_for_ops (const char *arg, int from_tty,
   parse_probe_linespec (arg, &provider, &probe_name, &objname);
 
   std::vector<bound_probe> probes
-    = collect_probes (objname, provider, probe_name, pops);
+    = collect_probes (objname, provider, probe_name, spops);
 
-  if (pops == NULL)
+  if (spops == &any_static_probe_ops)
     {
-      /* If the probe_ops is NULL, it means the user has requested a "simple"
-	 `info probes', i.e., she wants to print all information about all
-	 probes.  For that, we have to identify how many extra fields we will
-	 need to add in the ui_out table.
-
-	 To do that, we iterate over all probe_ops, querying each one about
-	 its extra fields, and incrementing `ui_out_extra_fields' to reflect
-	 that number.  But note that we ignore the probe_ops for which no probes
-	 are defined with the given search criteria.  */
-
-      for (const probe_ops *po : all_probe_ops)
-	if (exists_probe_with_pops (probes, po))
+      /* If SPOPS is &any_static_probe_ops, it means the user has
+	 requested a "simple" `info probes', i.e., she wants to print
+	 all information about all probes.  For that, we have to
+	 identify how many extra fields we will need to add in the
+	 ui_out table.
+
+	 To do that, we iterate over all static_probe_ops, querying
+	 each one about its extra fields, and incrementing
+	 `ui_out_extra_fields' to reflect that number.  But note that
+	 we ignore the static_probe_ops for which no probes are
+	 defined with the given search criteria.  */
+
+      for (const static_probe_ops *po : all_static_probe_ops)
+	if (exists_probe_with_spops (probes, po))
 	  ui_out_extra_fields += get_number_extra_fields (po);
     }
   else
-    ui_out_extra_fields = get_number_extra_fields (pops);
+    ui_out_extra_fields = get_number_extra_fields (spops);
 
   {
     ui_out_emit_table table_emitter (current_uiout,
@@ -589,11 +563,12 @@ info_probes_for_ops (const char *arg, int from_tty,
        `name' and `objname').  */
     for (const bound_probe &probe : probes)
       {
-	const char *probe_type = probe.probe->pops->type_name (probe.probe);
+	const char *probe_type = probe.prob->get_static_ops ()->type_name ();
 
 	size_type = std::max (strlen (probe_type), size_type);
-	size_name = std::max (strlen (probe.probe->name), size_name);
-	size_provider = std::max (strlen (probe.probe->provider), size_provider);
+	size_name = std::max (strlen (probe.prob->get_name ()), size_name);
+	size_provider = std::max (strlen (probe.prob->get_provider ()),
+				  size_provider);
 	size_objname = std::max (strlen (objfile_name (probe.objfile)),
 				 size_objname);
       }
@@ -604,44 +579,46 @@ info_probes_for_ops (const char *arg, int from_tty,
     current_uiout->table_header (size_name, ui_left, "name", _("Name"));
     current_uiout->table_header (size_addr, ui_left, "addr", _("Where"));
 
-    if (pops == NULL)
+    if (spops == &any_static_probe_ops)
       {
 	/* We have to generate the table header for each new probe type
 	   that we will print.  Note that this excludes probe types not
 	   having any defined probe with the search criteria.  */
-	for (const probe_ops *po : all_probe_ops)
-	  if (exists_probe_with_pops (probes, po))
+	for (const static_probe_ops *po : all_static_probe_ops)
+	  if (exists_probe_with_spops (probes, po))
 	    gen_ui_out_table_header_info (probes, po);
       }
     else
-      gen_ui_out_table_header_info (probes, pops);
+      gen_ui_out_table_header_info (probes, spops);
 
     current_uiout->table_header (size_objname, ui_left, "object", _("Object"));
     current_uiout->table_body ();
 
     for (const bound_probe &probe : probes)
       {
-	const char *probe_type = probe.probe->pops->type_name (probe.probe);
+	const char *probe_type = probe.prob->get_static_ops ()->type_name ();
 
 	ui_out_emit_tuple tuple_emitter (current_uiout, "probe");
 
-	current_uiout->field_string ("type",probe_type);
-	current_uiout->field_string ("provider", probe.probe->provider);
-	current_uiout->field_string ("name", probe.probe->name);
-	current_uiout->field_core_addr ("addr", probe.probe->arch,
-					get_probe_address (probe.probe,
-							   probe.objfile));
+	current_uiout->field_string ("type", probe_type);
+	current_uiout->field_string ("provider", probe.prob->get_provider ());
+	current_uiout->field_string ("name", probe.prob->get_name ());
+	current_uiout->field_core_addr ("addr", probe.prob->get_gdbarch (),
+					probe.prob->get_relocated_address
+					(probe.objfile));
 
-	if (pops == NULL)
+	if (spops == &any_static_probe_ops)
 	  {
-	    for (const probe_ops *po : all_probe_ops)
-	      if (probe.probe->pops == po)
-		print_ui_out_info (probe.probe);
-	      else if (exists_probe_with_pops (probes, po))
-		print_ui_out_not_applicables (po);
+	    for (const static_probe_ops *po : all_static_probe_ops)
+	      {
+		if (probe.prob->get_static_ops () == po)
+		  print_ui_out_info (probe.prob);
+		else if (exists_probe_with_spops (probes, po))
+		  print_ui_out_not_applicables (po);
+	      }
 	  }
 	else
-	  print_ui_out_info (probe.probe);
+	  print_ui_out_info (probe.prob);
 
 	current_uiout->field_string ("object",
 				     objfile_name (probe.objfile));
@@ -660,7 +637,7 @@ info_probes_for_ops (const char *arg, int from_tty,
 static void
 info_probes_command (const char *arg, int from_tty)
 {
-  info_probes_for_ops (arg, from_tty, NULL);
+  info_probes_for_spops (arg, from_tty, &any_static_probe_ops);
 }
 
 /* Implementation of the `enable probes' command.  */
@@ -673,7 +650,7 @@ enable_probes_command (const char *arg, int from_tty)
   parse_probe_linespec ((const char *) arg, &provider, &probe_name, &objname);
 
   std::vector<bound_probe> probes
-    = collect_probes (objname, provider, probe_name, NULL);
+    = collect_probes (objname, provider, probe_name, &any_static_probe_ops);
   if (probes.empty ())
     {
       current_uiout->message (_("No probes matched.\n"));
@@ -684,17 +661,17 @@ enable_probes_command (const char *arg, int from_tty)
      notion of enabling a probe.  */
   for (const bound_probe &probe: probes)
     {
-      const struct probe_ops *pops = probe.probe->pops;
-
-      if (pops->enable_probe != NULL)
+      if (probe.prob->can_enable ())
 	{
-	  pops->enable_probe (probe.probe);
+	  probe.prob->enable ();
 	  current_uiout->message (_("Probe %s:%s enabled.\n"),
-				  probe.probe->provider, probe.probe->name);
+				  probe.prob->get_provider (),
+				  probe.prob->get_name ());
 	}
       else
 	current_uiout->message (_("Probe %s:%s cannot be enabled.\n"),
-				probe.probe->provider, probe.probe->name);
+				probe.prob->get_provider (),
+				probe.prob->get_name ());
     }
 }
 
@@ -708,7 +685,7 @@ disable_probes_command (const char *arg, int from_tty)
   parse_probe_linespec ((const char *) arg, &provider, &probe_name, &objname);
 
   std::vector<bound_probe> probes
-    = collect_probes (objname, provider, probe_name, NULL /* pops */);
+    = collect_probes (objname, provider, probe_name, &any_static_probe_ops);
   if (probes.empty ())
     {
       current_uiout->message (_("No probes matched.\n"));
@@ -719,55 +696,22 @@ disable_probes_command (const char *arg, int from_tty)
      notion of enabling a probe.  */
   for (const bound_probe &probe : probes)
     {
-      const struct probe_ops *pops = probe.probe->pops;
-
-      if (pops->disable_probe != NULL)
+      if (probe.prob->can_enable ())
 	{
-	  pops->disable_probe (probe.probe);
+	  probe.prob->disable ();
 	  current_uiout->message (_("Probe %s:%s disabled.\n"),
-				  probe.probe->provider, probe.probe->name);
+				  probe.prob->get_provider (),
+				  probe.prob->get_name ());
 	}
       else
 	current_uiout->message (_("Probe %s:%s cannot be disabled.\n"),
-				probe.probe->provider, probe.probe->name);
+				probe.prob->get_provider (),
+				probe.prob->get_name ());
     }
 }
 
 /* See comments in probe.h.  */
 
-CORE_ADDR
-get_probe_address (struct probe *probe, struct objfile *objfile)
-{
-  return probe->pops->get_probe_address (probe, objfile);
-}
-
-/* See comments in probe.h.  */
-
-unsigned
-get_probe_argument_count (struct probe *probe, struct frame_info *frame)
-{
-  return probe->pops->get_probe_argument_count (probe, frame);
-}
-
-/* See comments in probe.h.  */
-
-int
-can_evaluate_probe_arguments (struct probe *probe)
-{
-  return probe->pops->can_evaluate_probe_arguments (probe);
-}
-
-/* See comments in probe.h.  */
-
-struct value *
-evaluate_probe_argument (struct probe *probe, unsigned n,
-			 struct frame_info *frame)
-{
-  return probe->pops->evaluate_probe_argument (probe, n, frame);
-}
-
-/* See comments in probe.h.  */
-
 struct value *
 probe_safe_evaluate_at_pc (struct frame_info *frame, unsigned n)
 {
@@ -775,22 +719,22 @@ probe_safe_evaluate_at_pc (struct frame_info *frame, unsigned n)
   unsigned n_args;
 
   probe = find_probe_by_pc (get_frame_pc (frame));
-  if (!probe.probe)
+  if (!probe.prob)
     return NULL;
 
-  n_args = get_probe_argument_count (probe.probe, frame);
+  n_args = probe.prob->get_argument_count (frame);
   if (n >= n_args)
     return NULL;
 
-  return evaluate_probe_argument (probe.probe, n, frame);
+  return probe.prob->evaluate_argument (n, frame);
 }
 
 /* See comment in probe.h.  */
 
-const struct probe_ops *
-probe_linespec_to_ops (const char **linespecp)
+const struct static_probe_ops *
+probe_linespec_to_static_ops (const char **linespecp)
 {
-  for (const probe_ops *ops : all_probe_ops)
+  for (const static_probe_ops *ops : all_static_probe_ops)
     if (ops->is_linespec (linespecp))
       return ops;
 
@@ -820,31 +764,48 @@ probe_is_linespec_by_keyword (const char **linespecp, const char *const *keyword
   return 0;
 }
 
-/* Implementation of `is_linespec' method for `struct probe_ops'.  */
+/* Implementation of `is_linespec' method.  */
 
-static int
-probe_any_is_linespec (const char **linespecp)
+bool
+any_static_probe_ops::is_linespec (const char **linespecp) const
 {
   static const char *const keywords[] = { "-p", "-probe", NULL };
 
   return probe_is_linespec_by_keyword (linespecp, keywords);
 }
 
-/* Dummy method used for `probe_ops_any'.  */
+/* Implementation of 'get_probes' method.  */
 
-static void
-probe_any_get_probes (std::vector<probe *> *probesp, struct objfile *objfile)
+void
+any_static_probe_ops::get_probes (std::vector<probe *> *probesp,
+				  struct objfile *objfile) const
 {
   /* No probes can be provided by this dummy backend.  */
 }
 
-/* Operations associated with a generic probe.  */
+/* Implementation of the 'type_name' method.  */
 
-const struct probe_ops probe_ops_any =
+const char *
+any_static_probe_ops::type_name () const
 {
-  probe_any_is_linespec,
-  probe_any_get_probes,
-};
+  return NULL;
+}
+
+/* Implementation of the 'emit_info_probes_extra_fields' method.  */
+
+bool
+any_static_probe_ops::emit_info_probes_extra_fields () const
+{
+  return false;
+}
+
+/* Implementation of the 'gen_info_probes_table_header' method.  */
+
+void
+any_static_probe_ops::gen_info_probes_table_header
+  (std::vector<struct info_probe_column> *heads) const
+{
+}
 
 /* See comments in probe.h.  */
 
@@ -890,10 +851,10 @@ compute_probe_arg (struct gdbarch *arch, struct internalvar *ivar,
   gdb_assert (sel >= -1);
 
   pc_probe = find_probe_by_pc (pc);
-  if (pc_probe.probe == NULL)
+  if (pc_probe.prob == NULL)
     error (_("No probe at PC %s"), core_addr_to_string (pc));
 
-  n_args = get_probe_argument_count (pc_probe.probe, frame);
+  n_args = pc_probe.prob->get_argument_count (frame);
   if (sel == -1)
     return value_from_longest (builtin_type (arch)->builtin_int, n_args);
 
@@ -901,7 +862,7 @@ compute_probe_arg (struct gdbarch *arch, struct internalvar *ivar,
     error (_("Invalid probe argument %d -- probe has %u arguments available"),
 	   sel, n_args);
 
-  return evaluate_probe_argument (pc_probe.probe, sel, frame);
+  return pc_probe.prob->evaluate_argument (sel, frame);
 }
 
 /* This is called to compile one of the $_probe_arg* convenience
@@ -922,10 +883,10 @@ compile_probe_arg (struct internalvar *ivar, struct agent_expr *expr,
   gdb_assert (sel >= -1);
 
   pc_probe = find_probe_by_pc (pc);
-  if (pc_probe.probe == NULL)
+  if (pc_probe.prob == NULL)
     error (_("No probe at PC %s"), core_addr_to_string (pc));
 
-  n_args = get_probe_argument_count (pc_probe.probe, frame);
+  n_args = pc_probe.prob->get_argument_count (frame);
 
   if (sel == -1)
     {
@@ -940,7 +901,7 @@ compile_probe_arg (struct internalvar *ivar, struct agent_expr *expr,
     error (_("Invalid probe argument %d -- probe has %d arguments available"),
 	   sel, n_args);
 
-  pc_probe.probe->pops->compile_to_ax (pc_probe.probe, expr, value, sel);
+  pc_probe.prob->compile_to_ax (expr, value, sel);
 }
 
 static const struct internalvar_funcs probe_funcs =
@@ -951,12 +912,12 @@ static const struct internalvar_funcs probe_funcs =
 };
 
 
-std::vector<const probe_ops *> all_probe_ops;
+std::vector<const static_probe_ops *> all_static_probe_ops;
 
 void
 _initialize_probe (void)
 {
-  all_probe_ops.push_back (&probe_ops_any);
+  all_static_probe_ops.push_back (&any_static_probe_ops);
 
   create_internalvar_type_lazy ("_probe_argc", &probe_funcs,
 				(void *) (uintptr_t) -1);
diff --git a/gdb/probe.h b/gdb/probe.h
index 822e5c89a9..9ad183013b 100644
--- a/gdb/probe.h
+++ b/gdb/probe.h
@@ -30,7 +30,6 @@ struct info_probe_column
   {
     /* The internal name of the field.  This string cannot be capitalized nor
        localized, e.g., "extra_field".  */
-
     const char *field_name;
 
     /* The field name to be printed in the `info probes' command.  This
@@ -38,165 +37,206 @@ struct info_probe_column
     const char *print_name;
   };
 
-typedef struct info_probe_column info_probe_column_s;
-DEF_VEC_O (info_probe_column_s);
-
-/* Operations associated with a probe.  */
-
-struct probe_ops
-  {
-    /* Method responsible for verifying if LINESPECP is a valid linespec for
-       a probe breakpoint.  It should return 1 if it is, or zero if it is not.
-       It also should update LINESPECP in order to discard the breakpoint
-       option associated with this linespec.  For example, if the option is
-       `-probe', and the LINESPECP is `-probe abc', the function should
-       return 1 and set LINESPECP to `abc'.  */
-
-    int (*is_linespec) (const char **linespecp);
-
-    /* Function that should fill PROBES with known probes from OBJFILE.  */
-
-    void (*get_probes) (std::vector<probe *> *probes, struct objfile *objfile);
-
-    /* Compute the probe's relocated address.  OBJFILE is the objfile
-       in which the probe originated.  */
-
-    CORE_ADDR (*get_probe_address) (struct probe *probe,
-				    struct objfile *objfile);
-
-    /* Return the number of arguments of PROBE.  This function can
-       throw an exception.  */
-
-    unsigned (*get_probe_argument_count) (struct probe *probe,
-					  struct frame_info *frame);
-
-    /* Return 1 if the probe interface can evaluate the arguments of probe
-       PROBE, zero otherwise.  See the comments on
-       sym_probe_fns:can_evaluate_probe_arguments for more details.  */
-
-    int (*can_evaluate_probe_arguments) (struct probe *probe);
-
-    /* Evaluate the Nth argument from the PROBE, returning a value
-       corresponding to it.  The argument number is represented N.
-       This function can throw an exception.  */
-
-    struct value *(*evaluate_probe_argument) (struct probe *probe,
-					      unsigned n,
-					      struct frame_info *frame);
-
-    /* Compile the Nth argument of the PROBE to an agent expression.
-       The argument number is represented by N.  */
-
-    void (*compile_to_ax) (struct probe *probe, struct agent_expr *aexpr,
-			   struct axs_value *axs_value, unsigned n);
+/* Operations that act on probes, but are specific to each backend.
+   These methods do not go into the 'class probe' because they do not
+   act on a single probe; instead, they are used to operate on many
+   probes at once, or to provide information about the probe backend
+   itself, instead of a single probe.
 
-    /* Set the semaphore associated with the PROBE.  This function only makes
-       sense if the probe has a concept of semaphore associated to a
-       probe, otherwise it can be set to NULL.  */
+   Each probe backend needs to inherit this class and implement all of
+   the virtual functions specified here.  Then, an object shall be
+   instantiated and added (or "registered") to the
+   ALL_STATIC_PROBE_OPS vector so that the frontend probe interface
+   can use it in the generic probe functions.  */
 
-    void (*set_semaphore) (struct probe *probe, struct objfile *objfile,
-			   struct gdbarch *gdbarch);
-
-    /* Clear the semaphore associated with the PROBE.  This function only
-       makes sense if the probe has a concept of semaphore associated to
-       a probe, otherwise it can be set to NULL.  */
-
-    void (*clear_semaphore) (struct probe *probe, struct objfile *objfile,
-			     struct gdbarch *gdbarch);
-
-    /* Function called to destroy PROBE's specific data.  This function
-       shall not free PROBE itself.  */
-
-    void (*destroy) (struct probe *probe);
-
-    /* Return a pointer to a name identifying the probe type.  This is
-       the string that will be displayed in the "Type" column of the
-       `info probes' command.  */
+class static_probe_ops
+{
+public:
+  /* Method responsible for verifying if LINESPECP is a valid linespec
+     for a probe breakpoint.  It should return true if it is, or false
+     if it is not.  It also should update LINESPECP in order to
+     discard the breakpoint option associated with this linespec.  For
+     example, if the option is `-probe', and the LINESPECP is `-probe
+     abc', the function should return 1 and set LINESPECP to
+     `abc'.  */
+  virtual bool is_linespec (const char **linespecp) const = 0;
+
+  /* Function that should fill PROBES with known probes from OBJFILE.  */
+  virtual void get_probes (std::vector<probe *> *probes,
+			    struct objfile *objfile) const = 0;
+
+  /* Return a pointer to a name identifying the probe type.  This is
+     the string that will be displayed in the "Type" column of the
+     `info probes' command.  */
+  virtual const char *type_name () const = 0;
+
+  /* Return true if the probe type will emit extra fields when the
+     user issues a "info probes" command.  If this function returns
+     false, then GEN_INFO_PROBES_TABLE_HEADER and
+     GEN_INFO_PROBES_TABLE_VALUES are not used.  */
+  virtual bool emit_info_probes_extra_fields () const = 0;
+
+  /* Function responsible for providing the extra fields that will be
+     printed in the `info probes' command.  It should fill HEADS
+     with whatever extra fields it needs.  If no extra fields are
+     required by the probe backend, the method EMIT_INFO_PROBES_FIELDS
+     should return false.  */
+  virtual void gen_info_probes_table_header
+    (std::vector<struct info_probe_column> *heads) const = 0;
+};
 
-    const char *(*type_name) (struct probe *probe);
+/* Definition of a vector of static_probe_ops.  */
 
-    /* Function responsible for providing the extra fields that will be
-       printed in the `info probes' command.  It should fill HEADS
-       with whatever extra fields it needs.  If the backend doesn't need
-       to print extra fields, it can set this method to NULL.  */
+extern std::vector<const static_probe_ops *> all_static_probe_ops;
 
-    void (*gen_info_probes_table_header) (VEC (info_probe_column_s) **heads);
+/* Helper function that, given KEYWORDS, iterate over it trying to match
+   each keyword with LINESPECP.  If it succeeds, it updates the LINESPECP
+   pointer and returns 1.  Otherwise, nothing is done to LINESPECP and zero
+   is returned.  */
 
-    /* Function that will fill VALUES with the values of the extra fields
-       to be printed for PROBE.  If the backend implements the
-       `gen_ui_out_table_header' method, then it should implement
-       this method as well.  The backend should also guarantee that the
-       order and the number of values in the vector is exactly the same
-       as the order of the extra fields provided in the method
-       `gen_ui_out_table_header'.  If a certain field is to be skipped
-       when printing the information, you can push a NULL value in that
-       position in the vector.  */
+extern int probe_is_linespec_by_keyword (const char **linespecp,
+					 const char *const *keywords);
 
-    void (*gen_info_probes_table_values) (struct probe *probe,
-					  VEC (const_char_ptr) **values);
+/* Return specific STATIC_PROBE_OPS * matching *LINESPECP and possibly
+   updating LINESPECP to skip its "-probe-type " prefix.  Return
+   &static_probe_ops_any if LINESPECP matches "-probe ", that is any
+   unspecific probe.  Return NULL if LINESPECP is not identified as
+   any known probe type, *LINESPECP is not modified in such case.  */
 
-    /* Enable a probe.  The semantics of "enabling" a probe depend on
-       the specific backend and the field can be NULL in case enabling
-       probes is not supported.  This function can throw an
-       exception.  */
+extern const static_probe_ops *
+  probe_linespec_to_static_ops (const char **linespecp);
 
-    void (*enable_probe) (struct probe *probe);
+/* The probe itself.  The class contains generic information about the
+   probe.  */
 
-    /* Disable a probe.  The semantics of "disabling" a probe depend
-       on the specific backend and the field can be NULL in case
-       disabling probes is not supported.  This function can throw an
-       exception.  */
+class probe
+{
+public:
+  /* Default constructor for a probe.  */
+  probe (std::string &&name_, std::string &&provider_, CORE_ADDR address_,
+	 struct gdbarch *arch_)
+    : m_name (std::move (name_)), m_provider (std::move (provider_)),
+      m_address (address_), m_arch (arch_)
+  {}
 
-    void (*disable_probe) (struct probe *probe);
-  };
+  /* Virtual destructor.  */
+  virtual ~probe ()
+  {}
 
-/* Definition of a vector of probe_ops.  */
+  /* Compute the probe's relocated address.  OBJFILE is the objfile
+     in which the probe originated.  */
+  virtual CORE_ADDR get_relocated_address (struct objfile *objfile) = 0;
+
+  /* Return the number of arguments of the probe.  This function can
+     throw an exception.  */
+  virtual unsigned get_argument_count (struct frame_info *frame) = 0;
+
+  /* Return 1 if the probe interface can evaluate the arguments of
+     probe, zero otherwise.  See the comments on
+     sym_probe_fns:can_evaluate_probe_arguments for more
+     details.  */
+  virtual int can_evaluate_arguments () const = 0;
+
+  /* Evaluate the Nth argument from the probe, returning a value
+     corresponding to it.  The argument number is represented N.
+     This function can throw an exception.  */
+  virtual struct value *evaluate_argument (unsigned n,
+					   struct frame_info *frame) = 0;
+
+  /* Compile the Nth argument of the probe to an agent expression.
+     The argument number is represented by N.  */
+  virtual void compile_to_ax (struct agent_expr *aexpr,
+			      struct axs_value *axs_value,
+			      unsigned n) = 0;
+
+  /* Set the semaphore associated with the probe.  This function only
+     makes sense if the probe has a concept of semaphore associated to
+     a probe.  */
+  virtual void set_semaphore (struct objfile *objfile,
+			      struct gdbarch *gdbarch)
+  {}
 
-extern std::vector<const probe_ops *> all_probe_ops;
+  /* Clear the semaphore associated with the probe.  This function
+     only makes sense if the probe has a concept of semaphore
+     associated to a probe.  */
+  virtual void clear_semaphore (struct objfile *objfile,
+				struct gdbarch *gdbarch)
+  {}
 
-/* The probe_ops associated with the generic probe.  */
+  /* Return the pointer to the static_probe_ops instance related to
+     the probe type.  */
+  virtual const static_probe_ops *get_static_ops () const = 0;
+
+  /* Function that will fill VALUES with the values of the extra
+     fields to be printed for the probe.
+
+     If the backend implements the `gen_ui_out_table_header' method,
+     then it should implement this method as well.  The backend should
+     also guarantee that the order and the number of values in the
+     vector is exactly the same as the order of the extra fields
+     provided in the method `gen_ui_out_table_header'.  If a certain
+     field is to be skipped when printing the information, you can
+     push a NULL value in that position in the vector.  */
+  virtual void gen_info_probes_table_values
+    (std::vector<const char *> *values) const
+  {}
 
-extern const struct probe_ops probe_ops_any;
+  /* Return true if the probe can be enabled; false otherwise.  */
+  virtual bool can_enable () const
+  {
+    return false;
+  }
 
-/* Helper function that, given KEYWORDS, iterate over it trying to match
-   each keyword with LINESPECP.  If it succeeds, it updates the LINESPECP
-   pointer and returns 1.  Otherwise, nothing is done to LINESPECP and zero
-   is returned.  */
+  /* Enable the probe.  The semantics of "enabling" a probe depend on
+     the specific backend.  This function can throw an exception.  */
+  virtual void enable ()
+  {}
 
-extern int probe_is_linespec_by_keyword (const char **linespecp,
-					 const char *const *keywords);
+  /* Disable the probe.  The semantics of "disabling" a probe depend
+     on the specific backend.  This function can throw an
+     exception.  */
+  virtual void disable ()
+  {}
 
-/* Return specific PROBE_OPS * matching *LINESPECP and possibly updating
-   *LINESPECP to skip its "-probe-type " prefix.  Return &probe_ops_any if
-   *LINESPECP matches "-probe ", that is any unspecific probe.  Return NULL if
-   *LINESPECP is not identified as any known probe type, *LINESPECP is not
-   modified in such case.  */
+  /* Getter for M_NAME.  */
+  const char *get_name () const
+  {
+    return m_name.c_str ();
+  }
 
-extern const struct probe_ops *probe_linespec_to_ops (const char **linespecp);
+  /* Getter for M_PROVIDER.  */
+  const char *get_provider () const
+  {
+    return m_provider.c_str ();
+  }
 
-/* The probe itself.  The struct contains generic information about the
-   probe, and then some specific information which should be stored in
-   the `probe_info' field.  */
+  /* Getter for M_ADDRESS.  */
+  CORE_ADDR get_address () const
+  {
+    return m_address;
+  }
 
-struct probe
+  /* Getter for M_ARCH.  */
+  struct gdbarch *get_gdbarch () const
   {
-    /* The operations associated with this probe.  */
-    const struct probe_ops *pops;
+    return m_arch;
+  }
 
-    /* The probe's architecture.  */
-    struct gdbarch *arch;
+private:
+  /* The name of the probe.  */
+  std::string m_name;
 
-    /* The name of the probe.  */
-    const char *name;
+  /* The provider of the probe.  It generally defaults to the name of
+     the objfile which contains the probe.  */
+  std::string m_provider;
 
-    /* The provider of the probe.  It generally defaults to the name of
-       the objfile which contains the probe.  */
-    const char *provider;
+  /* The address where the probe is inserted, relative to
+     SECT_OFF_TEXT.  */
+  CORE_ADDR m_address;
 
-    /* The address where the probe is inserted, relative to
-       SECT_OFF_TEXT.  */
-    CORE_ADDR address;
-  };
+  /* The probe's architecture.  */
+  struct gdbarch *m_arch;
+};
 
 /* A bound probe holds a pointer to a probe and a pointer to the
    probe's defining objfile.  This is needed because probes are
@@ -206,22 +246,18 @@ struct probe
 struct bound_probe
 {
   /* Create an empty bound_probe object.  */
-
   bound_probe ()
   {}
 
   /* Create and initialize a bound_probe object using PROBE and OBJFILE.  */
-
-  bound_probe (struct probe *probe_, struct objfile *objfile_)
-  : probe (probe_), objfile (objfile_)
+  bound_probe (probe *probe_, struct objfile *objfile_)
+  : prob (probe_), objfile (objfile_)
   {}
 
   /* The probe.  */
-
-  struct probe *probe = NULL;
+  probe *prob = NULL;
 
   /* The objfile in which the probe originated.  */
-
   struct objfile *objfile = NULL;
 };
 
@@ -234,11 +270,6 @@ extern std::vector<symtab_and_line> parse_probes
    struct program_space *pspace,
    struct linespec_result *canon);
 
-/* Helper function to register the proper probe_ops to a newly created probe.
-   This function is mainly called from `sym_get_probes'.  */
-
-extern void register_probe_ops (struct probe *probe);
-
 /* Given a PC, find an associated probe.  If a probe is found, return
    it.  If no probe is found, return a bound probe whose fields are
    both NULL.  */
@@ -253,13 +284,13 @@ extern std::vector<probe *> find_probes_in_objfile (struct objfile *objfile,
 						    const char *provider,
 						    const char *name);
 
-/* Generate a `info probes' command output for probe_ops represented by
-   POPS.  If POPS is NULL it considers any probes types.  It is a helper
-   function that can be used by the probe backends to print their
-   `info probe TYPE'.  */
+/* Generate a `info probes' command output for probes associated with
+   SPOPS.  If SPOPS is related to the "any probe" type, then all probe
+   types are considered.  It is a helper function that can be used by
+   the probe backends to print their `info probe TYPE'.  */
 
-extern void info_probes_for_ops (const char *arg, int from_tty,
-				 const struct probe_ops *pops);
+extern void info_probes_for_spops (const char *arg, int from_tty,
+				   const static_probe_ops *spops);
 
 /* Return the `cmd_list_element' associated with the `info probes' command,
    or create a new one if it doesn't exist.  Helper function that serves the
@@ -268,34 +299,6 @@ extern void info_probes_for_ops (const char *arg, int from_tty,
 
 extern struct cmd_list_element **info_probes_cmdlist_get (void);
 
-/* Compute the probe's relocated address.  OBJFILE is the objfile in
-   which the probe originated.  */
-
-extern CORE_ADDR get_probe_address (struct probe *probe,
-				    struct objfile *objfile);
-
-/* Return the argument count of the specified probe.
-
-   This function can throw an exception.  */
-
-extern unsigned get_probe_argument_count (struct probe *probe,
-					  struct frame_info *frame);
-
-/* Return 1 if the probe interface associated with PROBE can evaluate
-   arguments, zero otherwise.  See the comments on the definition of
-   sym_probe_fns:can_evaluate_probe_arguments for more details.  */
-
-extern int can_evaluate_probe_arguments (struct probe *probe);
-
-/* Evaluate argument N of the specified probe.  N must be between 0
-   inclusive and get_probe_argument_count exclusive.
-
-   This function can throw an exception.  */
-
-extern struct value *evaluate_probe_argument (struct probe *probe,
-					      unsigned n,
-					      struct frame_info *frame);
-
 /* A convenience function that finds a probe at the PC in FRAME and
    evaluates argument N, with 0 <= N < number_of_args.  If there is no
    probe at that location, or if the probe does not have enough arguments,
diff --git a/gdb/solib-svr4.c b/gdb/solib-svr4.c
index 5ec606de43..6e834fb5d7 100644
--- a/gdb/solib-svr4.c
+++ b/gdb/solib-svr4.c
@@ -351,7 +351,7 @@ struct svr4_info
   /* Table of struct probe_and_action instances, used by the
      probes-based interface to map breakpoint addresses to probes
      and their associated actions.  Lookup is performed using
-     probe_and_action->probe->address.  */
+     probe_and_action->prob->address.  */
   htab_t probes_table;
 
   /* List of objects loaded into the inferior, used by the probes-
@@ -1664,7 +1664,7 @@ exec_entry_point (struct bfd *abfd, struct target_ops *targ)
 struct probe_and_action
 {
   /* The probe.  */
-  struct probe *probe;
+  probe *prob;
 
   /* The relocated address of the probe.  */
   CORE_ADDR address;
@@ -1699,7 +1699,7 @@ equal_probe_and_action (const void *p1, const void *p2)
    probes table.  */
 
 static void
-register_solib_event_probe (struct probe *probe, CORE_ADDR address,
+register_solib_event_probe (probe *prob, CORE_ADDR address,
 			    enum probe_action action)
 {
   struct svr4_info *info = get_svr4_info ();
@@ -1712,13 +1712,13 @@ register_solib_event_probe (struct probe *probe, CORE_ADDR address,
 					    equal_probe_and_action,
 					    xfree, xcalloc, xfree);
 
-  lookup.probe = probe;
+  lookup.prob = prob;
   lookup.address = address;
   slot = htab_find_slot (info->probes_table, &lookup, INSERT);
   gdb_assert (*slot == HTAB_EMPTY_ENTRY);
 
   pa = XCNEW (struct probe_and_action);
-  pa->probe = probe;
+  pa->prob = prob;
   pa->address = address;
   pa->action = action;
 
@@ -1767,7 +1767,7 @@ solib_event_probe_action (struct probe_and_action *pa)
        arg2: struct link_map *new (optional, for incremental updates)  */
   TRY
     {
-      probe_argc = get_probe_argument_count (pa->probe, frame);
+      probe_argc = pa->prob->get_argument_count (frame);
     }
   CATCH (ex, RETURN_MASK_ERROR)
     {
@@ -1776,11 +1776,11 @@ solib_event_probe_action (struct probe_and_action *pa)
     }
   END_CATCH
 
-  /* If get_probe_argument_count throws an exception, probe_argc will
-     be set to zero.  However, if pa->probe does not have arguments,
-     then get_probe_argument_count will succeed but probe_argc will
-     also be zero.  Both cases happen because of different things, but
-     they are treated equally here: action will be set to
+  /* If get_argument_count throws an exception, probe_argc will be set
+     to zero.  However, if pa->prob does not have arguments, then
+     get_argument_count will succeed but probe_argc will also be zero.
+     Both cases happen because of different things, but they are
+     treated equally here: action will be set to
      PROBES_INTERFACE_FAILED.  */
   if (probe_argc == 2)
     action = FULL_RELOAD;
@@ -1922,7 +1922,7 @@ svr4_handle_solib_event (void)
       return;
     }
 
-  /* evaluate_probe_argument looks up symbols in the dynamic linker
+  /* evaluate_argument looks up symbols in the dynamic linker
      using find_pc_section.  find_pc_section is accelerated by a cache
      called the section map.  The section map is invalidated every
      time a shared library is loaded or unloaded, and if the inferior
@@ -1931,14 +1931,14 @@ svr4_handle_solib_event (void)
      We called find_pc_section in svr4_create_solib_event_breakpoints,
      so we can guarantee that the dynamic linker's sections are in the
      section map.  We can therefore inhibit section map updates across
-     these calls to evaluate_probe_argument and save a lot of time.  */
+     these calls to evaluate_argument and save a lot of time.  */
   inhibit_section_map_updates (current_program_space);
   usm_chain = make_cleanup (resume_section_map_updates_cleanup,
 			    current_program_space);
 
   TRY
     {
-      val = evaluate_probe_argument (pa->probe, 1, frame);
+      val = pa->prob->evaluate_argument (1, frame);
     }
   CATCH (ex, RETURN_MASK_ERROR)
     {
@@ -1979,7 +1979,7 @@ svr4_handle_solib_event (void)
     {
       TRY
 	{
-	  val = evaluate_probe_argument (pa->probe, 2, frame);
+	  val = pa->prob->evaluate_argument (2, frame);
 	}
       CATCH (ex, RETURN_MASK_ERROR)
 	{
@@ -2084,7 +2084,7 @@ svr4_create_probe_breakpoints (struct gdbarch *gdbarch,
 
       for (probe *p : probes[i])
 	{
-	  CORE_ADDR address = get_probe_address (p, objfile);
+	  CORE_ADDR address = p->get_relocated_address (objfile);
 
 	  create_solib_event_breakpoint (gdbarch, address);
 	  register_solib_event_probe (p, address, action);
@@ -2126,7 +2126,7 @@ svr4_create_solib_event_breakpoints (struct gdbarch *gdbarch,
 	  for (int i = 0; i < NUM_PROBES; i++)
 	    {
 	      const char *name = probe_info[i].name;
-	      struct probe *p;
+	      probe *p;
 	      char buf[32];
 
 	      /* Fedora 17 and Red Hat Enterprise Linux 6.2-6.4
@@ -2160,7 +2160,7 @@ svr4_create_solib_event_breakpoints (struct gdbarch *gdbarch,
 	      if (!checked_can_use_probe_arguments)
 		{
 		  p = probes[i][0];
-		  if (!can_evaluate_probe_arguments (p))
+		  if (!p->can_evaluate_arguments ())
 		    {
 		      all_probes_found = 0;
 		      break;
diff --git a/gdb/symfile.h b/gdb/symfile.h
index 3472aa0e7b..10b1504937 100644
--- a/gdb/symfile.h
+++ b/gdb/symfile.h
@@ -34,11 +34,11 @@ struct objfile;
 struct obj_section;
 struct obstack;
 struct block;
-struct probe;
 struct value;
 struct frame_info;
 struct agent_expr;
 struct axs_value;
+class probe;
 
 /* Comparison function for symbol look ups.  */
 
diff --git a/gdb/symtab.h b/gdb/symtab.h
index 7b8b5cc640..8bf9f3994f 100644
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -41,10 +41,10 @@ struct axs_value;
 struct agent_expr;
 struct program_space;
 struct language_defn;
-struct probe;
 struct common_block;
 struct obj_section;
 struct cmd_list_element;
+class probe;
 struct lookup_name_info;
 
 /* How to match a lookup name against a symbol search name.  */
@@ -1702,7 +1702,7 @@ struct symtab_and_line
   bool explicit_line = false;
 
   /* The probe associated with this symtab_and_line.  */
-  struct probe *probe = NULL;
+  probe *prob = NULL;
   /* If PROBE is not NULL, then this is the objfile in which the probe
      originated.  */
   struct objfile *objfile = NULL;
diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c
index 59a7b64ae8..76d05dfc13 100644
--- a/gdb/tracepoint.c
+++ b/gdb/tracepoint.c
@@ -1654,11 +1654,9 @@ start_tracing (const char *notes)
       t->number_on_target = b->number;
 
       for (loc = b->loc; loc; loc = loc->next)
-	if (loc->probe.probe != NULL
-	    && loc->probe.probe->pops->set_semaphore != NULL)
-	  loc->probe.probe->pops->set_semaphore (loc->probe.probe,
-						 loc->probe.objfile,
-						 loc->gdbarch);
+	if (loc->probe.prob != NULL)
+	  loc->probe.prob->set_semaphore (loc->probe.objfile,
+					  loc->gdbarch);
 
       if (bp_location_downloaded)
 	observer_notify_breakpoint_modified (b);
@@ -1754,11 +1752,9 @@ stop_tracing (const char *note)
 	     but we don't really care if this semaphore goes out of sync.
 	     That's why we are decrementing it here, but not taking care
 	     in other places.  */
-	  if (loc->probe.probe != NULL
-	      && loc->probe.probe->pops->clear_semaphore != NULL)
-	    loc->probe.probe->pops->clear_semaphore (loc->probe.probe,
-						     loc->probe.objfile,
-						     loc->gdbarch);
+	  if (loc->probe.prob != NULL)
+	    loc->probe.prob->clear_semaphore (loc->probe.objfile,
+					      loc->gdbarch);
 	}
     }
 
