'thread' or 'task' keywords are parsed at the time the breakpoint is
created, rather than at the time the breakpoint becomes non-pending.
+* Thread-specific breakpoints are only inserted into the program space
+ in which the thread of interest is running. In most cases program
+ spaces are unique for each inferior, so this means that
+ thread-specific breakpoints will usually only be inserted for the
+ inferior containing the thread of interest. The breakpoint will
+ be hit no less than before.
+
* Python API
** Added gdb.record.clear. Clears the trace data of the current recording.
enable_state = enabled ? bp_enabled : bp_disabled;
language = language_ada;
- re_set ();
+ re_set (pspace);
}
struct bp_location *allocate_location () override;
- void re_set () override;
+ void re_set (program_space *pspace) override;
void check_status (struct bpstat *bs) override;
enum print_stop_action print_it (const bpstat *bs) const override;
bool print_one (const bp_location **) const override;
catchpoint kinds. */
void
-ada_catchpoint::re_set ()
+ada_catchpoint::re_set (program_space *pspace)
{
std::vector<symtab_and_line> sals;
try
_("invalid type-matching regexp")))
{
pspace = current_program_space;
- re_set ();
+ re_set (pspace);
}
- void re_set () override;
+ void re_set (program_space *pspace) override;
enum print_stop_action print_it (const bpstat *bs) const override;
bool print_one (const bp_location **) const override;
void print_mention () const override;
/* Implement the 're_set' method. */
void
-exception_catchpoint::re_set ()
+exception_catchpoint::re_set (program_space *pspace)
{
std::vector<symtab_and_line> sals;
struct program_space *filter_pspace = current_program_space;
static void map_breakpoint_numbers (const char *,
gdb::function_view<void (breakpoint *)>);
-static void
- create_sals_from_location_spec_default (location_spec *locspec,
- linespec_result *canonical);
+static void parse_breakpoint_sals (location_spec *locspec,
+ linespec_result *canonical,
+ program_space *search_pspace);
+
+static void breakpoint_re_set_one (breakpoint *b,
+ program_space *filter_pspace);
static void create_breakpoints_sal (struct gdbarch *,
struct linespec_result *,
static void bkpt_probe_create_sals_from_location_spec
(location_spec *locspec,
- struct linespec_result *canonical);
+ struct linespec_result *canonical,
+ struct program_space *search_pspace);
const struct breakpoint_ops code_breakpoint_ops =
{
- create_sals_from_location_spec_default,
+ parse_breakpoint_sals,
create_breakpoints_sal,
};
disposition = disp_donttouch;
}
- void re_set () override;
+ void re_set (program_space *pspace) override;
void check_status (struct bpstat *bs) override;
enum print_stop_action print_it (const bpstat *bs) const override;
void print_mention () const override;
gdb_assert (inferior == -1);
}
- void re_set () override;
+ void re_set (program_space *pspace) override;
void check_status (struct bpstat *bs) override;
enum print_stop_action print_it (const bpstat *bs) const override;
void print_mention () const override;
{
using ordinary_breakpoint::ordinary_breakpoint;
- void re_set () override;
+ void re_set (program_space *pspace) override;
int breakpoint_hit (const struct bp_location *bl,
const address_space *aspace,
CORE_ADDR bp_addr,
int old_thread = b->thread;
b->thread = thread;
if (old_thread != thread)
- notify_breakpoint_modified (b);
+ {
+ /* If THREAD is in a different program_space than OLD_THREAD, or the
+ breakpoint has switched to or from being thread-specific, then we
+ need to re-set the locations of this breakpoint. First, figure
+ out the program_space for the old and new threads, use a value of
+ nullptr to indicate the breakpoint is in all program spaces. */
+ program_space *old_pspace = nullptr;
+ if (old_thread != -1)
+ {
+ struct thread_info *thr = find_thread_global_id (old_thread);
+ gdb_assert (thr != nullptr);
+ old_pspace = thr->inf->pspace;
+ }
+
+ program_space *new_pspace = nullptr;
+ if (thread != -1)
+ {
+ struct thread_info *thr = find_thread_global_id (thread);
+ gdb_assert (thr != nullptr);
+ new_pspace = thr->inf->pspace;
+ }
+
+ /* If the program space has changed for this breakpoint, then
+ re-evaluate it's locations. */
+ if (old_pspace != new_pspace)
+ breakpoint_re_set_one (b, new_pspace);
+
+ /* Let others know the breakpoint has changed. */
+ notify_breakpoint_modified (b);
+ }
}
/* See breakpoint.h. */
int old_inferior = b->inferior;
b->inferior = inferior;
if (old_inferior != inferior)
- notify_breakpoint_modified (b);
+ {
+ /* If INFERIOR is in a different program_space than OLD_INFERIOR, or
+ the breakpoint has switch to or from inferior-specific, then we
+ need to re-set the locations of this breakpoint. First, figure
+ out the program_space for the old and new inferiors, use a value
+ of nullptr to indicate the breakpoint is in all program
+ spaces. */
+ program_space *old_pspace = nullptr;
+ if (old_inferior != -1)
+ {
+ struct inferior *inf = find_inferior_id (old_inferior);
+ gdb_assert (inf != nullptr);
+ old_pspace = inf->pspace;
+ }
+
+ program_space *new_pspace = nullptr;
+ if (inferior != -1)
+ {
+ struct inferior *inf = find_inferior_id (inferior);
+ gdb_assert (inf != nullptr);
+ new_pspace = inf->pspace;
+ }
+
+ if (old_pspace != new_pspace)
+ breakpoint_re_set_one (b, new_pspace);
+
+ notify_breakpoint_modified (b);
+ }
}
/* See breakpoint.h. */
/* See breakpoint.h. */
void
-catchpoint::re_set ()
+catchpoint::re_set (program_space *filter_pspace)
{
/* All catchpoints are associated with a specific program_space. */
gdb_assert (pspace != nullptr);
+ /* If only a single program space changed, and it's not the program space
+ for which this catchpoint applies, then there's nothing to do. */
+ if (filter_pspace != nullptr && filter_pspace != pspace)
+ return;
+
/* Catchpoints have a single dummy location. */
gdb_assert (locations ().size () == 1);
bp_location &bl = m_locations.front ();
static void
parse_breakpoint_sals (location_spec *locspec,
- struct linespec_result *canonical)
+ struct linespec_result *canonical,
+ struct program_space *search_pspace)
{
if (locspec->type () == LINESPEC_LOCATION_SPEC)
{
&& strchr ("+-", spec[0]) != NULL
&& spec[1] != '['))
{
- decode_line_full (locspec, DECODE_LINE_FUNFIRSTLINE, NULL,
+ decode_line_full (locspec, DECODE_LINE_FUNFIRSTLINE, search_pspace,
get_last_displayed_symtab (),
get_last_displayed_line (),
canonical, NULL, NULL);
}
}
- decode_line_full (locspec, DECODE_LINE_FUNFIRSTLINE, NULL,
+ decode_line_full (locspec, DECODE_LINE_FUNFIRSTLINE, search_pspace,
cursal.symtab, cursal.line, canonical, NULL, NULL);
}
}
}
+/* Return the program space to use as a filter when searching for locations
+ of a breakpoint specific to THREAD or INFERIOR. If THREAD and INFERIOR
+ are both -1, meaning all threads/inferiors, then this function returns
+ nullptr, indicating no program space filtering should be performed.
+ Otherwise, this function returns the program space for the inferior that
+ contains THREAD (when THREAD is not -1), or the program space for
+ INFERIOR (when INFERIOR is not -1). */
+
+static struct program_space *
+find_program_space_for_breakpoint (int thread, int inferior)
+{
+ if (thread != -1)
+ {
+ gdb_assert (inferior == -1);
+
+ struct thread_info *thr = find_thread_global_id (thread);
+ gdb_assert (thr != nullptr);
+ gdb_assert (thr->inf != nullptr);
+ return thr->inf->pspace;
+ }
+ else if (inferior != -1)
+ {
+ gdb_assert (thread == -1);
+
+ struct inferior *inf = find_inferior_id (inferior);
+ gdb_assert (inf != nullptr);
+
+ return inf->pspace;
+ }
+
+ return nullptr;
+}
+
/* See breakpoint.h. */
const struct breakpoint_ops *
try
{
- ops->create_sals_from_location_spec (locspec, &canonical);
+ struct program_space *search_pspace
+ = find_program_space_for_breakpoint (thread, inferior);
+ ops->create_sals_from_location_spec (locspec, &canonical,
+ search_pspace);
}
catch (const gdb_exception_error &e)
{
arg_start = arg;
location_spec_up start_locspec
= string_to_location_spec (&arg, current_language);
- parse_breakpoint_sals (start_locspec.get (), &canonical_start);
+ parse_breakpoint_sals (start_locspec.get (), &canonical_start, nullptr);
if (arg[0] != ',')
error (_("Too few arguments."));
/* Implement the "re_set" method for watchpoints. */
void
-watchpoint::re_set ()
+watchpoint::re_set (struct program_space *pspace)
{
/* Watchpoint can be either on expression using entirely global
variables, or it can be on local variables.
/* Default breakpoint_ops methods. */
void
-code_breakpoint::re_set ()
+code_breakpoint::re_set (struct program_space *pspace)
{
/* FIXME: is this still reachable? */
if (breakpoint_location_spec_empty_p (this))
return;
}
- re_set_default ();
+ re_set_default (pspace);
}
int
/* Virtual table for internal breakpoints. */
void
-internal_breakpoint::re_set ()
+internal_breakpoint::re_set (struct program_space *pspace)
{
switch (type)
{
/* Virtual table for momentary breakpoints */
void
-momentary_breakpoint::re_set ()
+momentary_breakpoint::re_set (struct program_space *pspace)
{
/* Keep temporary breakpoints, which can be encountered when we step
over a dlopen call and solib_add is resetting the breakpoints.
static void
bkpt_probe_create_sals_from_location_spec (location_spec *locspec,
- struct linespec_result *canonical)
+ struct linespec_result *canonical,
+ struct program_space *search_pspace)
{
struct linespec_sals lsal;
- lsal.sals = parse_probes (locspec, NULL, canonical);
+ lsal.sals = parse_probes (locspec, search_pspace, canonical);
lsal.canonical = xstrdup (canonical->locspec->to_string ());
canonical->lsals.push_back (std::move (lsal));
}
}
void
-dprintf_breakpoint::re_set ()
+dprintf_breakpoint::re_set (struct program_space *pspace)
{
- re_set_default ();
+ re_set_default (pspace);
/* 1 - connect to target 1, that can run breakpoint commands.
2 - create a dprintf, which resolves fine.
markers (`-m'). */
static void
-strace_marker_create_sals_from_location_spec (location_spec *locspec,
- struct linespec_result *canonical)
+strace_marker_create_sals_from_location_spec
+ (location_spec *locspec,
+ struct linespec_result *canonical,
+ struct program_space *search_pspace)
{
struct linespec_sals lsal;
const char *arg_start, *arg;
all locations are in the same shared library, that was unloaded.
We'd like to retain the location, so that when the library is
loaded again, we don't loose the enabled/disabled status of the
- individual locations. */
+ individual locations.
+
+ Thread specific breakpoints will also trigger this case if the thread
+ is changed to a different program space, and all of the old locations
+ go out of scope. In this case we do (currently) discard the old
+ locations -- we assume the change in thread is permanent and the old
+ locations will never come back into scope. */
if (all_locations_are_pending (b, filter_pspace) && sals.empty ())
- return;
+ {
+ if (b->thread != -1)
+ b->clear_locations ();
+ return;
+ }
bp_location_list existing_locations = b->steal_locations (filter_pspace);
+ /* If this is a thread-specific breakpoint then any locations left on the
+ breakpoint are for a program space in which the thread of interest
+ does not operate. This can happen when the user changes the thread of
+ a thread-specific breakpoint.
+
+ We assume that the change in thread is permanent, and that the old
+ locations will never be used again, so discard them now. */
+ if (b->thread != -1)
+ b->clear_locations ();
+
for (const auto &sal : sals)
{
struct bp_location *new_loc;
locations. */
void
-code_breakpoint::re_set_default ()
+code_breakpoint::re_set_default (struct program_space *filter_pspace)
{
- struct program_space *filter_pspace = current_program_space;
std::vector<symtab_and_line> expanded, expanded_end;
- int found;
- std::vector<symtab_and_line> sals = location_spec_to_sals (locspec.get (),
- filter_pspace,
- &found);
- if (found)
- expanded = std::move (sals);
-
- if (locspec_range_end != nullptr)
- {
- std::vector<symtab_and_line> sals_end
- = location_spec_to_sals (locspec_range_end.get (),
- filter_pspace, &found);
+ /* If this breakpoint is thread-specific then find the program space in
+ which the specific thread exists. Otherwise, for breakpoints that are
+ not thread-specific THREAD_PSPACE will be nullptr. */
+ program_space *bp_pspace
+ = find_program_space_for_breakpoint (this->thread, this->inferior);
+
+ /* If this is not a thread or inferior specific breakpoint, or it is a
+ thread or inferior specific breakpoint but we are looking for new
+ locations in the program space that the specific thread or inferior is
+ running, then look for new locations for this breakpoint. */
+ if (bp_pspace == nullptr || filter_pspace == bp_pspace)
+ {
+ int found;
+ std::vector<symtab_and_line> sals
+ = location_spec_to_sals (locspec.get (), filter_pspace, &found);
if (found)
- expanded_end = std::move (sals_end);
+ expanded = std::move (sals);
+
+ if (locspec_range_end != nullptr)
+ {
+ std::vector<symtab_and_line> sals_end
+ = location_spec_to_sals (locspec_range_end.get (),
+ filter_pspace, &found);
+ if (found)
+ expanded_end = std::move (sals_end);
+ }
}
+ /* Update the locations for this breakpoint. For thread-specific
+ breakpoints this will remove any old locations that are for the wrong
+ program space -- this can happen if the user changes the thread of a
+ thread-specific breakpoint. */
update_breakpoint_locations (this, filter_pspace, expanded, expanded_end);
}
-/* Default method for creating SALs from an address string. It basically
- calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
-
-static void
-create_sals_from_location_spec_default (location_spec *locspec,
- struct linespec_result *canonical)
-{
- parse_breakpoint_sals (locspec, canonical);
-}
-
/* Re-set breakpoint locations for the current program space.
Locations bound to other program spaces are left untouched. */
{
input_radix = b.input_radix;
set_language (b.language);
- b.re_set ();
+ b.re_set (current_program_space);
}
catch (const gdb_exception &ex)
{
/* Now we can insert. */
update_global_location_list (UGLL_MAY_INSERT);
}
+
+/* Re-set locations for breakpoint B in FILTER_PSPACE. If FILTER_PSPACE is
+ nullptr then re-set locations for B in all program spaces. Locations
+ bound to program spaces other than FILTER_PSPACE are left untouched. */
+
+static void
+breakpoint_re_set_one (breakpoint *b, program_space *filter_pspace)
+{
+ {
+ scoped_restore_current_language save_language;
+ scoped_restore save_input_radix = make_scoped_restore (&input_radix);
+ scoped_restore_current_pspace_and_thread restore_pspace_thread;
+
+ /* To ::re_set each breakpoint we set the current_language to the
+ language of the breakpoint before re-evaluating the breakpoint's
+ location. This change can unfortunately get undone by accident if
+ the language_mode is set to auto, and we either switch frames, or
+ more likely in this context, we select the current frame.
+
+ We prevent this by temporarily turning the language_mode to
+ language_mode_manual. We restore it once all breakpoints
+ have been reset. */
+ scoped_restore save_language_mode = make_scoped_restore (&language_mode);
+ language_mode = language_mode_manual;
+
+ /* Note: we must not try to insert locations until after all
+ breakpoints have been re-set. Otherwise, e.g., when re-setting
+ breakpoint 1, we'd insert the locations of breakpoint 2, which
+ hadn't been re-set yet, and thus may have stale locations. */
+
+ try
+ {
+ input_radix = b->input_radix;
+ set_language (b->language);
+ b->re_set (filter_pspace);
+ }
+ catch (const gdb_exception &ex)
+ {
+ exception_fprintf (gdb_stderr, ex,
+ "Error in re-setting breakpoint %d: ",
+ b->number);
+ }
+ }
+
+ /* Now we can insert. */
+ update_global_location_list (UGLL_MAY_INSERT);
+}
\f
/* Reset the thread number of this breakpoint:
struct breakpoint_ops
{
- /* Create SALs from location spec, storing the result in
- linespec_result.
-
- For an explanation about the arguments, see the function
- `create_sals_from_location_spec_default'.
+ /* Create SALs from LOCSPEC, storing the result in linespec_result
+ CANONICAL. If SEARCH_PSPACE is not nullptr then only results in the
+ corresponding program space are returned. If SEARCH_PSPACE is nullptr
+ then results for all program spaces are returned.
This function is called inside `create_breakpoint'. */
void (*create_sals_from_location_spec) (location_spec *locspec,
- struct linespec_result *canonical);
+ linespec_result *canonical,
+ program_space *search_pspace);
/* This method will be responsible for creating a breakpoint given its SALs.
Usually, it just calls `create_breakpoints_sal' (for ordinary
/* Reevaluate a breakpoint. This is necessary after symbols change
(e.g., an executable or DSO was loaded, or the inferior just
- started). This is pure virtual as, at a minimum, each sub-class must
- recompute any cached condition expressions based off of the
- cond_string member variable. */
- virtual void re_set () = 0;
+ started).
+
+ If not nullptr, then FILTER_PSPACE is the program space in which
+ symbols may have changed, we only need to add new locations in
+ FILTER_PSPACE.
+
+ If FILTER_PSPACE is nullptr then all program spaces may have changed,
+ new locations need to be searched for in every program space.
+
+ This is pure virtual as, at a minimum, each sub-class must recompute
+ any cached condition expressions based off of the cond_string member
+ variable. */
+ virtual void re_set (program_space *filter_pspace) = 0;
/* Insert the breakpoint or watchpoint or activate the catchpoint.
Return 0 for success, 1 if the breakpoint, watchpoint or
/* Add a location for SAL to this breakpoint. */
bp_location *add_location (const symtab_and_line &sal);
- void re_set () override;
+ void re_set (program_space *pspace) override;
int insert_location (struct bp_location *) override;
int remove_location (struct bp_location *,
enum remove_bp_reason reason) override;
struct program_space *search_pspace);
/* Helper method that does the basic work of re_set. */
- void re_set_default ();
+ void re_set_default (program_space *pspace);
/* Find the SaL locations corresponding to the given LOCATION.
On return, FOUND will be 1 if any SaL was found, zero otherwise. */
{
using breakpoint::breakpoint;
- void re_set () override;
+ void re_set (program_space *pspace) override;
int insert_location (struct bp_location *) override;
int remove_location (struct bp_location *,
enum remove_bp_reason reason) override;
/* If the catchpoint has a condition set then recompute the cached
expression within the single dummy location. */
- void re_set () override;
+ void re_set (program_space *filter_pspace) override;
};
\f
set loc2 [make_bp_loc "$::decimal\\.2"]
# Create the inferior-specific breakpoint.
- mi_create_breakpoint_multi "-g i2 foo" "create breakpoint in inferior 2" \
- -inferior "2" -locations "\\\[$loc1,$loc2\\\]"
+ mi_create_breakpoint "-g i2 foo" "create breakpoint in inferior 2" \
+ -number "$decimal" \
+ -type "breakpoint" \
+ -enabled "y" \
+ -func "foo" \
+ -inferior "2"
set bpnum [mi_get_valueof "/d" "\$bpnum" "INVALID"]
if {$mode eq "separate"} {
# Consume MI output.
with_spawn_id $mi_spawn_id {
- if { $inf == 1} {
- mi_expect_stop "breakpoint-hit" "child_sub_function" \
- "" "$srcfile" "$decimal" {"" "disp=\"del\""} \
- "thread $inf.2 stops MI"
- } else {
- mi_expect_stop "breakpoint-hit" "child_sub_function" \
- "" "$srcfile" "$decimal" {"" "disp=\"del\"" "locno=\"[0-9]+\""} \
- "thread $inf.2 stops MI"
- }
+ mi_expect_stop "breakpoint-hit" "child_sub_function" \
+ "" "$srcfile" "$decimal" {"" "disp=\"del\""} \
+ "thread $inf.2 stops MI"
}
}
}
with_spawn_id $mi_spawn_id {
mi_expect_stop "breakpoint-hit" "main" "" "$srcfile" "$decimal" \
- {"" "disp=\"del\"" "locno=\"[0-9]+\""} "main stop"
+ {"" "disp=\"del\""} "main stop"
}
# Consume CLI output.
# locations ('foo' in both inferiors) even though only one of those
# locations will ever trigger ('foo' in inferior 2).
gdb_test "break foo thread 2.1" \
- "Breakpoint $decimal at $hex: foo\\. \\(2 locations\\)"
+ "Breakpoint $decimal at $hex: file \[^\r\n\]+$srcfile, line $decimal\\."
set bpnum [get_integer_valueof "\$bpnum" "INVALID"]
# earlier breakpoint. Check that the thread-id used when describing
# the earlier breakpoints is correct.
gdb_test "break foo thread 1.1" \
- [multi_line \
- "Note: breakpoint $bpnum \\(thread 2.1\\) also set at pc $hex\\." \
- "Note: breakpoint $bpnum \\(thread 2.1\\) also set at pc $hex\\." \
- "Breakpoint $decimal at $hex: foo\\. \\(2 locations\\)"]
+ "Breakpoint $decimal at $hex: file \[^\r\n\]+$srcfile, line $decimal\\."
# Save the breakpoints into a file.
if {[is_remote host]} {
# Create an inferior-specific breakpoint. Use gdb_test instead of
# gdb_breakpoint here as we want to check the breakpoint was placed in
# multiple locations.
-#
-# Currently GDB still places inferior specific breakpoints into every
-# inferior, just like it does with thread specific breakpoints.
-# Hopefully this will change in the future, at which point, this test
-# will need updating.
-#
-# Two of these locations are in inferior 1, while the third is in
-# inferior 2.
gdb_test "break foo inferior 1" \
- "Breakpoint $decimal at $hex: foo\\. \\(3 locations\\)"
+ "Breakpoint $decimal at $hex: foo\\. \\(2 locations\\)"
set bp_number [get_integer_valueof "\$bpnum" "INVALID" \
"get b/p number for inferior specific breakpoint"]
set saw_inf_cond false
check_info_breakpoints "first check for inferior specific breakpoint" \
- $bp_number 3
+ $bp_number 2
# Create a multi-inferior breakpoint to stop at.
gdb_breakpoint "stop_breakpt" message
proc set_break {inf} {
gdb_test "break function${inf} thread ${inf}.1" \
- "Breakpoint .* function${inf}\\..*"
+ "Breakpoint ${::decimal} at ${::hex}: file .*, line ${::decimal}\\."
}
# Select inferior INF, and then run to a breakpoint on inferior
gdb_test "thread 1.1" "Switching to thread 1.1 .*"
gdb_test "break $srcfile:$line1 thread 1.1" \
- "Breakpoint .*$srcfile:$line1\\..*"
+ "Breakpoint .*$srcfile, line $line1\\."
gdb_test "continue" "hit Breakpoint .*"
gdb_test "break $srcfile:$line2 thread 2.1" \
- "Breakpoint .*$srcfile:$line2\\..*"
+ "Breakpoint .*$srcfile, line $line2\\."
# Now block inferior 1 and issue "next". We should stop at the
# breakpoint for inferior 2, given schedlock off.
} else {
set bp_pattern_before \
[multi_line \
- "$bp_number\\s+breakpoint\\s+keep\\s+y\\s+<MULTIPLE>\\s*" \
- "\\s+stop only in [string_to_regexp $bp_restriction]" \
- "$bp_number\\.1\\s+y\\s+$::hex in $bp_func at \[^\r\n\]+ inf 1" \
- "$bp_number\\.2\\s+y\\s+$::hex in $bp_func at \[^\r\n\]+ inf 2"]
+ "$bp_number\\s+breakpoint\\s+keep\\s+y\\s+$::hex in $bp_func at \[^\r\n\]+ inf 1" \
+ "\\s+stop only in [string_to_regexp $bp_restriction]"]
set bp_pattern_after \
[multi_line \
return true
}
+# Create a breakpoint on the function 'foo' in THREAD. It is expected
+# that the breakpoint created will be pending, this is checked by
+# running the 'info breakpoints' command.
+#
+# Returns the number for the newly created breakpoint.
+proc do_create_pending_foo_breakpoint { {thread "1.1"} } {
+ gdb_test "break foo thread $thread" \
+ [multi_line \
+ "Function \"foo\" not defined\\." \
+ "Breakpoint $::decimal \\(foo\\) pending\."] \
+ "set pending thread-specific breakpoint"
+ set bpnum [get_integer_valueof "\$bpnum" "*INVALID*" \
+ "get number for thread-specific breakpoint on foo"]
+ gdb_test "info breakpoints $bpnum" \
+ [multi_line \
+ "$bpnum\\s+breakpoint\\s+keep\\s+y\\s+<PENDING>\\s+foo" \
+ "\\s+stop only in thread [string_to_regexp $thread]"] \
+ "check thread-specific breakpoint is initially pending"
+
+ return $bpnum
+}
+
+# Create a breakpoint on the function 'foo' in THREAD. It is expected
+# that the breakpoint created will not be pending, this is checked by
+# running the 'info breakpoints' command.
+#
+# Returns the number for the newly created breakpoint.
+proc do_create_foo_breakpoint { {thread "1.1"} } {
+ gdb_test "break foo thread $thread" \
+ "Breakpoint $::decimal at $::hex" \
+ "set thread-specific breakpoint"
+ set bpnum [get_integer_valueof "\$bpnum" "*INVALID*" \
+ "get number for thread-specific breakpoint on foo"]
+ gdb_test "info breakpoints $bpnum" \
+ [multi_line \
+ "$bpnum\\s+breakpoint\\s+keep\\s+y\\s+$::hex\\s+<foo\[^>\]*> inf $::decimal" \
+ "\\s+stop only in thread [string_to_regexp $thread]"] \
+ "check thread-specific breakpoint is initially pending"
+
+ return $bpnum
+}
+
# Check that when a breakpoint is in the pending state, but that breakpoint
# does have some locations (those locations themselves are pending), GDB
# doesn't display the inferior list in the 'info breakpoints' output.
"check info breakpoints while breakpoint is pending"
}
+# Setup two inferiors. In #1 the symbol 'foo' has not yet been
+# loaded, while in #2 the symbol 'foo' has been loaded.
+#
+# Create a thread-specific breakpoint on 'foo' tied to a thread in
+# inferior #1, the breakpoint should be pending -- 'foo' is not yet
+# loaded in #1.
+#
+# Now move inferior #1 forward until 'foo' is loaded, check the
+# breakpoint is no longer pending.
+#
+# Move inferior #1 forward more until 'foo' is unloaded, check that
+# the breakpoint returns to the pending state.
+proc_with_prefix test_pending_toggle { } {
+
+ do_test_setup "Break before open" "Break before close"
+
+ set bpnum [do_create_pending_foo_breakpoint]
+
+ # Now return to inferior 1 and continue until the shared library is
+ # loaded, the breakpoint should become non-pending.
+ gdb_test "inferior 1" "Switching to inferior 1 .*" \
+ "switch back to inferior 1"
+ gdb_continue_to_breakpoint "stop in foo in inferior 1" "foo \\(\\) .*"
+
+ gdb_test "info breakpoint $bpnum" \
+ [multi_line \
+ "$bpnum\\s+breakpoint\\s+keep\\s+y\\s+$::hex <foo\[^>\]*> inf 1" \
+ "\\s+stop only in thread 1\\.1" \
+ "\\s+breakpoint already hit 1 time"] \
+ "check thread-specific breakpoint is no longer pending"
+
+ gdb_breakpoint [gdb_get_line_number "Break after close"] temporary
+ gdb_continue_to_breakpoint "close library"
+ gdb_test "info breakpoints $bpnum" \
+ [multi_line \
+ "$bpnum\\s+breakpoint\\s+keep\\s+y\\s+<PENDING>\\s+foo" \
+ "\\s+stop only in thread 1\\.1" \
+ "\\s+breakpoint already hit 1 time"] \
+ "check thread-specific breakpoint is pending again"
+}
+
+# Create a Python variable VAR and set it to the gdb.Breakpoint object
+# corresponding to the breakpoint numbered BPNUM. If THREAD is not
+# the empty string then THREAD should be an integer, check that
+# gdb.Breakpoint.thread is set to the value of THREAD. Otherwise, if
+# THREAD is the empty string, check that gdb.Breakpoint.thread is set
+# to None.
+proc py_find_breakpoint { var bpnum {thread ""} } {
+ gdb_test_no_output \
+ "python ${var}=\[b for b in gdb.breakpoints() if b.number == $bpnum\]\[0\]" \
+ "find Python gdb.Breakpoint object"
+ if { $thread ne "" } {
+ gdb_test_no_output "python assert(${var}.thread == ${thread})" \
+ "check thread attribute is currently correct"
+ } else {
+ gdb_test_no_output "python assert(${var}.thread is None)" \
+ "check thread attribute is currently correct"
+ }
+}
+
+# Setup two inferiors. In #1 the symbol 'foo' has not yet been
+# loaded, while in #2 the symbol 'foo' has been loaded.
+#
+# Create a thread-specific breakpoint on 'foo' tied to a thread in
+# inferior #1, the breakpoint should be pending -- 'foo' is not yet
+# loaded in #1.
+#
+# Use Python to change the thread of the thread-specific breakpoint to
+# a thread in inferior #2, at this point the thread should gain a
+# location and become non-pending.
+#
+# Set the thread back to a thread in inferior #1, the breakpoint
+# should return to the pending state.
+proc_with_prefix py_test_toggle_thread {} {
+ do_test_setup "Break before open" "Break after open"
+
+ set bpnum [do_create_pending_foo_breakpoint]
+
+ py_find_breakpoint "bp" $bpnum 1
+
+ gdb_test_no_output "python bp.thread = 2" \
+ "change thread on thread-specific breakpoint"
+ gdb_test "info breakpoint $bpnum" \
+ [multi_line \
+ "$bpnum\\s+breakpoint\\s+keep\\s+y\\s+$::hex <foo\[^>\]*> inf 2" \
+ "\\s+stop only in thread 2\\.1"] \
+ "check thread-specific breakpoint now has a location"
+
+ gdb_test_no_output "set call_count = 2" "set call_count in inferior 2"
+ gdb_continue_to_breakpoint "stop at foo in inferior 2" "foo \\(\\) .*"
+
+ gdb_test_no_output "python bp.thread = 1" \
+ "restore thread on thread-specific breakpoint"
+ gdb_test "info breakpoints $bpnum" \
+ [multi_line \
+ "$bpnum\\s+breakpoint\\s+keep\\s+y\\s+<PENDING>\\s+foo" \
+ "\\s+stop only in thread 1\\.1" \
+ "\\s+breakpoint already hit 1 time"] \
+ "check thread-specific breakpoint has returned to pending"
+
+ gdb_breakpoint [gdb_get_line_number "Break after close"] temporary
+ gdb_continue_to_breakpoint "stop after close in inferior 2" \
+ ".* Break after close\\. .*"
+
+ gdb_test "inferior 1" "Switching to inferior 1 .*" \
+ "switch to inferior 1"
+ gdb_continue_to_breakpoint "stop at foo in inferior 1" "foo \\(\\) .*"
+}
+
+# Setup two inferiors. Both inferiors have the symbol 'foo'
+# available.
+#
+# Create a thread-specific breakpoint on 'foo' tied to a thread in
+# inferior #1, the breakpoint should not be pending, but will only
+# have a single location, the location in inferior #1.
+#
+# Use Python to change the thread of the thread-specific breakpoint to
+# None. At this point the breakpoint should gain a second location, a
+# location in inferior #2.
+proc_with_prefix py_test_clear_thread {} {
+ do_test_setup "Break after open" "Break after open"
+
+ set bpnum [do_create_foo_breakpoint]
+
+ py_find_breakpoint "bp" $bpnum 1
+
+ gdb_test_no_output "python bp.thread = None" \
+ "clear thread on thread-specific breakpoint"
+ gdb_test "info breakpoints $bpnum" \
+ [multi_line \
+ "${bpnum}\\s+breakpoint\\s+keep y\\s+<MULTIPLE>\\s*" \
+ "${bpnum}\\.1\\s+y\\s+${::hex}\\s+<foo\[^>\]*> inf $::decimal" \
+ "${bpnum}\\.2\\s+y\\s+${::hex}\\s+<foo\[^>\]*> inf $::decimal"] \
+ "check for a location in both inferiors"
+
+ gdb_continue_to_breakpoint "stop at foo in inferior 2" "foo \\(\\) .*"
+ gdb_test_no_output "set call_count = 2" "set call_count in inferior 2"
+
+ gdb_test "inferior 1" "Switching to inferior 1 .*" \
+ "switch to inferior 1"
+ gdb_continue_to_breakpoint "stop at foo in inferior 1" "foo \\(\\) .*"
+ gdb_test_no_output "set call_count = 2" "set call_count in inferior 1"
+
+ gdb_test_no_output "python bp.thread = 2"
+ gdb_test "info breakpoints $bpnum" \
+ [multi_line \
+ "${bpnum}\\s+breakpoint\\s+keep y\\s+${::hex}\\s+<foo\[^>\]*> inf 2" \
+ "\\s+stop only in thread 2\\.1" \
+ "\\s+breakpoint already hit 2 times"] \
+ "check for a location only in inferior 2"
+
+ gdb_breakpoint [gdb_get_line_number "Break after close"] temporary
+ gdb_continue_to_breakpoint "stop after close in inferior 1" \
+ ".* Break after close\\. .*"
+
+ gdb_test "inferior 2" "Switching to inferior 2 .*" \
+ "switch back to inferior 2"
+ gdb_continue_to_breakpoint "stop at foo again in inferior 2" \
+ "foo \\(\\) .*"
+}
+
# Run all the tests.
test_no_inf_display
+test_pending_toggle
+py_test_toggle_thread
+py_test_clear_thread
gdb_py_test_silent_cmd "python bp = gdb.breakpoints()\[0\]" \
"get python breakpoint" 0
- gdb_test "python bp.thread = 6" "thread = 6" \
+ gdb_test_no_output "python bp.thread = 6" \
"make breakpoint thread-specific with python"
# Check that the inferior-qualified ID is correct.
gdb_test "info breakpoint" \
- "stop only in thread 1.3\r\n.*" \
+ [multi_line \
+ "$decimal\\s+\[^\r\n\]+ in thread_function1 at \[^\r\n\]+" \
+ "\\s+stop only in thread 1\\.3"] \
"thread specific breakpoint right thread"
}
}
projects / thirdparty / binutils-gdb.git / commitdiff
