diff options
| -rw-r--r-- | gdb/ChangeLog | 118 | ||||
| -rw-r--r-- | gdb/break-catch-throw.c | 16 | ||||
| -rw-r--r-- | gdb/breakpoint.c | 20 | ||||
| -rw-r--r-- | gdb/elfread.c | 4 | ||||
| -rw-r--r-- | gdb/infrun.c | 2 | ||||
| -rw-r--r-- | gdb/location.c | 2 | ||||
| -rw-r--r-- | gdb/probe.c | 436 | ||||
| -rw-r--r-- | gdb/probe.h | 358 | ||||
| -rw-r--r-- | gdb/solib-svr4.c | 36 | ||||
| -rw-r--r-- | gdb/symfile.h | 2 | ||||
| -rw-r--r-- | gdb/symtab.h | 4 | ||||
| -rw-r--r-- | gdb/tracepoint.c | 16 |
12 files changed, 524 insertions, 490 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 5323c27..2121e3e 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,121 @@ +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. + 2017-11-22 Joel Brobecker <brobecker@adacore.com> * ravenscar-thread.c (ravenscar_inferior_created): Remove diff --git a/gdb/break-catch-throw.c b/gdb/break-catch-throw.c index fd8a113..b1f9c32 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 + || pc_probe.prob->get_provider () != "libstdcxx" + || (pc_probe.prob->get_name () != "catch" + && pc_probe.prob->get_name () != "throw" + && pc_probe.prob->get_name () != "rethrow")) 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 d8d0ed0..b48c405 100644 --- a/gdb/breakpoint.c +++ b/gdb/breakpoint.c @@ -3310,7 +3310,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. */ @@ -3330,7 +3330,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"); @@ -3463,7 +3463,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. */ @@ -3483,7 +3483,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"); @@ -8692,7 +8692,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; @@ -12877,10 +12877,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; @@ -12891,10 +12888,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 cdef5a8..f248302 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 49f2fc5..d7df3c7 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -7565,7 +7565,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 c78778e..5ed3623 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 829f6d1..1be8faa 100644 --- a/gdb/probe.c +++ b/gdb/probe.c @@ -38,11 +38,35 @@ #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. */ + std::vector<struct info_probe_column> gen_info_probes_table_header + () 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 +91,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 != NULL && p->get_provider () != provider) continue; - if (strcmp (p->name, name) != 0) + if (p->get_name () != name) 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 +122,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 +182,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 +190,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 +229,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 (p->get_provider () != provider) continue; - if (strcmp (p->name, name) != 0) + if (p->get_name () != name) continue; result.push_back (p); @@ -227,7 +250,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 +262,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 +276,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 +314,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 ().c_str (), 0, NULL, 0) != 0) continue; if (probe_pat - && probe_pat->exec (p->name, 0, NULL, 0) != 0) + && probe_pat->exec (p->get_name ().c_str (), 0, NULL, 0) != 0) continue; result.emplace_back (p, objfile); @@ -315,16 +339,16 @@ compare_probes (const bound_probe &a, const bound_probe &b) { int v; - v = strcmp (a.probe->provider, b.probe->provider); + v = a.prob->get_provider ().compare (b.prob->get_provider ()); if (v != 0) return v < 0; - v = strcmp (a.probe->name, b.probe->name); + v = a.prob->get_name ().compare (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 +358,33 @@ 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; + gdb_assert (spops != NULL); - gdb_assert (p != NULL); + std::vector<struct info_probe_column> headings + = spops->gen_info_probes_table_header (); - if (p->gen_info_probes_table_header == NULL - && p->gen_info_probes_table_values == NULL) - 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); - - for (ix = 0; - VEC_iterate (info_probe_column_s, headings, ix, column); - ++ix) + for (const 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; - 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); + std::vector<const char *> probe_fields + = probe.prob->gen_info_probes_table_values (); - 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 +394,75 @@ 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; - - if (pops->gen_info_probes_table_header == NULL) - 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")); + std::vector<struct info_probe_column> headings + = spops->gen_info_probes_table_header (); - do_cleanups (c); + for (const 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; - 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; - - gdb_assert (probe->pops->gen_info_probes_table_header != NULL - && probe->pops->gen_info_probes_table_values != NULL); - - c = make_cleanup (VEC_cleanup (info_probe_column_s), &headings); - make_cleanup (VEC_cleanup (const_char_ptr), &values); + std::vector<struct info_probe_column> headings + = probe->get_static_ops ()->gen_info_probes_table_header (); + std::vector<const char *> values + = probe->gen_info_probes_table_values (); - probe->pops->gen_info_probes_table_header (&headings); - probe->pops->gen_info_probes_table_values (probe, &values); + gdb_assert (headings.size () == values.size ()); - 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; - - if (pops->gen_info_probes_table_header == NULL) - 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); - - do_cleanups (c); - - return n; + return spops->gen_info_probes_table_header ().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 +486,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 +502,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 +539,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 (probe.prob->get_name ().size (), size_name); + size_provider = std::max (probe.prob->get_provider ().size (), + size_provider); size_objname = std::max (strlen (objfile_name (probe.objfile)), size_objname); } @@ -604,44 +555,47 @@ 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 ().c_str ()); + current_uiout->field_string ("name", probe.prob->get_name ().c_str ()); + 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 +614,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 +627,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 +638,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->get_static_ops ()->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 ().c_str (), + probe.prob->get_name ().c_str ()); } else current_uiout->message (_("Probe %s:%s cannot be enabled.\n"), - probe.probe->provider, probe.probe->name); + probe.prob->get_provider ().c_str (), + probe.prob->get_name ().c_str ()); } } @@ -708,7 +662,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 +673,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->get_static_ops ()->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 ().c_str (), + probe.prob->get_name ().c_str ()); } else current_uiout->message (_("Probe %s:%s cannot be disabled.\n"), - probe.probe->provider, probe.probe->name); + probe.prob->get_provider ().c_str (), + probe.prob->get_name ().c_str ()); } } /* 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 +696,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 +741,40 @@ 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 'gen_info_probes_table_header' method. */ + +std::vector<struct info_probe_column> +any_static_probe_ops::gen_info_probes_table_header () const +{ + return std::vector<struct info_probe_column> (); +} /* See comments in probe.h. */ @@ -883,17 +813,16 @@ compute_probe_arg (struct gdbarch *arch, struct internalvar *ivar, CORE_ADDR pc = get_frame_pc (frame); int sel = (int) (uintptr_t) data; struct bound_probe pc_probe; - const struct sym_probe_fns *pc_probe_fns; unsigned n_args; /* SEL == -1 means "_probe_argc". */ 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 +830,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 @@ -914,7 +843,6 @@ compile_probe_arg (struct internalvar *ivar, struct agent_expr *expr, CORE_ADDR pc = expr->scope; int sel = (int) (uintptr_t) data; struct bound_probe pc_probe; - const struct sym_probe_fns *pc_probe_fns; int n_args; struct frame_info *frame = get_selected_frame (NULL); @@ -922,10 +850,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 +868,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 +879,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 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, diff --git a/gdb/solib-svr4.c b/gdb/solib-svr4.c index 5ec606d..6e834fb 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 e742984..fa38abf 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 2d826aa..e5aae2a 100644 --- a/gdb/symtab.h +++ b/gdb/symtab.h @@ -42,10 +42,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. */ @@ -1727,7 +1727,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 59a7b64..76d05df 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); } } |