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

This patch converts the generic probe interface (gdb/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 probe' to 'class
probe', and 'struct probe_ops' to 'class static_probe_ops'.  The
former now contains all the "dynamic", generic methods that act on a
probe + the generic data related to it; the latter encapsulates a
bunch of "static" methods that relate to the probe type, but not to a
specific probe itself.

I've had to do a few renamings (e.g., on 'struct bound_probe' the
field is called 'probe *prob' now, instead of 'struct probe *probe')
because GCC was complaining about naming the field using the same name
as the class.  Nothing major, though.  Generally speaking, the logic
behind and the design behind the code are the same.

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>

	* break-catch-throw.c (fetch_probe_arguments): Use
	'probe.prob' instead of 'probe.probe'.
	* breakpoint.c (create_longjmp_master_breakpoint): Call
	'can_evaluate_arguments' and 'get_relocated_address' methods
	from probe.
	(create_exception_master_breakpoint): Likewise.
	(add_location_to_breakpoint): Use 'sal->prob' instead of
	'sal->probe'.
	(bkpt_probe_insert_location): Call 'set_semaphore' method from
	probe.
	(bkpt_probe_remove_location): Likewise, for 'clear_semaphore'.
	* elfread.c (elf_get_probes): Use 'static_probe_ops' instead
	of 'probe_ops'.
	(probe_key_free): Call 'delete' on probe.
	(check_exception_resume): Use 'probe.prob' instead of
	'probe.probe'.
	* location.c (string_to_event_location_basic): Call
	'probe_linespec_to_static_ops'.
	* probe.c (class any_static_probe_ops): New class.
	(any_static_probe_ops any_static_probe_ops): New variable.
	(parse_probes_in_pspace): Receive 'static_probe_ops' as
	argument.  Adjust code to reflect change.
	(parse_probes): Use 'static_probe_ops' instead of
	'probe_ops'.  Adjust code to reflect change.
	(find_probes_in_objfile): Call methods to get name and
	provider from probe.
	(find_probe_by_pc): Use 'result.prob' instead of
	'result.probe'.  Call 'get_relocated_address' method from
	probe.
	(collect_probes): Adjust comment and argument list to receive
	'static_probe_ops' instead of 'probe_ops'.  Adjust code to
	reflect change.  Call necessary methods from probe.
	(compare_probes): Call methods to get name and provider from
	probes.
	(gen_ui_out_table_header_info): Receive 'static_probe_ops'
	instead of 'probe_ops'.  Use 'std::vector' instead of VEC,
	adjust code accordingly.
	(print_ui_out_not_applicables): Likewise.
	(info_probes_for_ops): Rename to...
	(info_probes_for_spops): ...this.  Receive 'static_probe_ops'
	as argument instead of 'probe_ops'.  Adjust code.  Call
	necessary methods from probe.
	(info_probes_command): Use 'info_probes_for_spops'.
	(enable_probes_command): Pass correct argument to
	'collect_probes'.  Call methods from probe.
	(disable_probes_command): Likewise.
	(get_probe_address): Move to 'any_static_probe_ops::get_address'.
	(get_probe_argument_count): Move to
	'any_static_probe_ops::get_argument_count'.
	(can_evaluate_probe_arguments): Move to
	'any_static_probe_ops::can_evaluate_arguments'.
	(evaluate_probe_argument): Move to
	'any_static_probe_ops::evaluate_argument'.
	(probe_safe_evaluate_at_pc): Use 'probe.prob' instead of
	'probe.probe'.
	(probe_linespec_to_ops): Rename to...
	(probe_linespec_to_static_ops): ...this.  Adjust code.
	(probe_any_is_linespec): Rename to...
	(any_static_probe_ops::is_linespec): ...this.
	(probe_any_get_probes): Rename to...
	(any_static_probe_ops::get_probes): ...this.
	(any_static_probe_ops::type_name): New method.
	(any_static_probe_ops::gen_info_probes_table_header): New
	method.
	(compute_probe_arg): Use 'pc_probe.prob' instead of
	'pc_probe.probe'.  Call methods from probe.
	(compile_probe_arg): Likewise.
	(std::vector<const probe_ops *> all_probe_ops): Delete.
	(std::vector<const static_probe_ops *> all_static_probe_ops):
	New variable.
	(_initialize_probe): Use 'all_static_probe_ops' instead of
	'all_probe_ops'.
	* probe.h (struct info_probe_column) <field_name>: Delete
	extraneous newline
	(info_probe_column_s): Delete type and VEC.
	(struct probe_ops): Delete.  Replace with...
	(class static_probe_ops): ...this and...
	(clas probe): ...this.
	(struct bound_probe) <bound_probe>: Delete extraneous
	newline.  Adjust constructor to receive 'probe' instead of
	'struct probe'.
	<probe>: Rename to...
	<prob>: ...this.  Delete extraneous newline.
	<objfile>: Delete extraneous newline.
	(register_probe_ops): Delete unused prototype.
	(info_probes_for_ops): Rename to...
	(info_probes_for_spops): ...this.  Adjust comment.
	(get_probe_address): Move to 'probe::get_address'.
	(get_probe_argument_count): Move to
	'probe::get_argument_count'.
	(can_evaluate_probe_arguments): Move to
	'probe::can_evaluate_arguments'.
	(evaluate_probe_argument): Move to 'probe::evaluate_argument'.
	* solib-svr4.c (struct svr4_info): Adjust comment.
	(struct probe_and_action) <probe>: Rename to...
	<prob>: ...this.
	(register_solib_event_probe): Receive 'probe' instead of
	'struct probe' as argument.  Use 'prob' instead of 'probe'
	when applicable.
	(solib_event_probe_action): Call 'get_argument_count' method
	from probe.  Adjust comment.
	(svr4_handle_solib_event): Adjust comment.  Call
	'evaluate_argument' method from probe.
	(svr4_create_probe_breakpoints): Call 'get_relocated_address'
	from probe.
	(svr4_create_solib_event_breakpoints): Use 'probe' instead of
	'struct probe'.  Call 'can_evaluate_arguments' from probe.
	* symfile.h: Forward declare 'class probe' instead of 'struct
	probe'.
	* symtab.h: Likewise.
	(struct symtab_and_line) <probe>: Rename to...
	<prob>: ...this.
	* tracepoint.c (start_tracing): Use 'prob' when applicable.
	Call probe methods.
	(stop_tracing): Likewise.

1 files changed, 178 insertions, 180 deletions

diff --git a/gdb/probe.h b/gdb/probe.h
index 822e5c8..9586774 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,201 @@ 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 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.
 
-/* Operations associated with a probe.  */
+   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.  */
 
-struct probe_ops
+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 can be enabled; false otherwise.  */
+  virtual bool can_enable () const
   {
-    /* 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);
-
-    /* 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.  */
-
-    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.  */
-
-    const char *(*type_name) (struct probe *probe);
+    return false;
+  }
+
+  /* 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 std::vector<struct info_probe_column>
+    gen_info_probes_table_header () 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 the backend doesn't need
-       to print extra fields, it can set this method to NULL.  */
+/* Definition of a vector of static_probe_ops.  */
 
-    void (*gen_info_probes_table_header) (VEC (info_probe_column_s) **heads);
+extern std::vector<const static_probe_ops *> all_static_probe_ops;
 
-    /* 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.  */
+/* 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.  */
 
-    void (*gen_info_probes_table_values) (struct probe *probe,
-					  VEC (const_char_ptr) **values);
+extern int probe_is_linespec_by_keyword (const char **linespecp,
+					 const char *const *keywords);
 
-    /* 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.  */
+/* 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.  */
 
-    void (*enable_probe) (struct probe *probe);
+extern const static_probe_ops *
+  probe_linespec_to_static_ops (const char **linespecp);
 
-    /* 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.  */
+/* The probe itself.  The class contains generic information about the
+   probe.  */
 
-    void (*disable_probe) (struct probe *probe);
-  };
+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_)
+  {}
 
-/* Definition of a vector of probe_ops.  */
+  /* Virtual destructor.  */
+  virtual ~probe ()
+  {}
 
-extern std::vector<const probe_ops *> all_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 bool 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)
+  {}
 
-/* The probe_ops associated with the generic probe.  */
+  /* 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)
+  {}
 
-extern const struct probe_ops probe_ops_any;
+  /* 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 std::vector<const char *> gen_info_probes_table_values () const
+  {
+    return std::vector<const char *> ();
+  }
 
-/* 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 std::string &get_name () const
+  {
+    return m_name;
+  }
 
-extern const struct probe_ops *probe_linespec_to_ops (const char **linespecp);
+  /* Getter for M_PROVIDER.  */
+  const std::string &get_provider () const
+  {
+    return m_provider;
+  }
 
-/* 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 +241,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 +265,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 +279,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 +294,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,