public inbox for gdb-testers@sourceware.org
help / color / mirror / Atom feed
* [binutils-gdb/gdb-7.10-branch] [amd64] Invalid return address after displaced stepping
@ 2015-08-13 19:13 sergiodj+buildbot
  2015-08-13 19:13 ` Failures on Fedora-i686, branch gdb-7.10-branch sergiodj+buildbot
                   ` (20 more replies)
  0 siblings, 21 replies; 44+ messages in thread
From: sergiodj+buildbot @ 2015-08-13 19:13 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT 475f4248decaaa6fcd6fbed0b47dd541db640c3f ***

Author: Joel Brobecker <brobecker@adacore.com>
Branch: gdb-7.10-branch
Commit: 475f4248decaaa6fcd6fbed0b47dd541db640c3f

[amd64] Invalid return address after displaced stepping

Making all-stop run on top of non-stop caused a small regression
in behavior. This was observed on x86_64-linux. The attached testcase
is in C whereas the investigation was done with an Ada program,
but it's the same scenario, and using a C testcase allows wider testing.
Basically: I am debugging a single-threaded program, and currently
stopped inside a function provided by a shared-library, at a line
calling a subprogram provided by a second shared library, and trying
to "next" over that function call.

Before we changed the default all-stop behavior, we had:

    7             Impl_Initialize;  -- Stop here and try "next" over this line
    (gdb) n
    8             return 5;  <<-- OK

But now, "next" just stops much earlier:

    (gdb) n
    0x00007ffff7bd8560 in impl.initialize@plt () from /[...]/lib/libpck.so

What happens is that next stops at a call instruction, which calls
the function's PLT, and GDB fails to notice that the inferior stepped
into a subroutine, and so decides that we're done. We can see another
symptom of the same issue by looking at the backtrace at the point
GDB stopped:

    (gdb) bt
    #0  0x00007ffff7bd8560 in impl.initialize@plt ()
       from /[...]/lib/libpck.so
    #1  0x00000000f7bd86f9 in ?? ()
    #2  0x00007fffffffdf50 in ?? ()
    #3  0x0000000000401893 in a () at /[...]/a.adb:7
    Backtrace stopped: frame did not save the PC

With a functioning GDB, the backtrace looks like the following instead:

    #0  0x00007ffff7bd8560 in impl.initialize@plt ()
       from /[...]/lib/libpck.so
    #1  0x00007ffff7bd86f9 in sub () at /[...]/pck.adb:7
    #2  0x0000000000401893 in a () at /[...]/a.adb:7

Note how, for frame #1, the address looks quite similar, except
for the high-order bits not being set:

    #1  0x00007ffff7bd86f9 in sub () at /[...]/pck.adb:7   <<<--  OK
    #1  0x00000000f7bd86f9 in ?? ()                        <<<--  WRONG
              ^^^^
              ||||
              Wrong

Investigating this further led me to displaced stepping.
As we are "next"-ing from a location where a breakpoint is inserted,
we need to step out of it, and since we're on non-stop mode, we need
to do it using displaced stepping. And looking at
amd64-tdep.c:amd64_displaced_step_fixup, I found the code that handles
the return address:

    regcache_cooked_read_unsigned (regs, AMD64_RSP_REGNUM, &rsp);
    retaddr = read_memory_unsigned_integer (rsp, retaddr_len, byte_order);
    retaddr = (retaddr - insn_offset) & 0xffffffffUL;

The mask used to compute retaddr looks wrong to me, keeping only
4 bytes instead of 8, and explains why the high order bits of
the backtrace are unset. What happens is that, after the displaced
stepping has completed, GDB restores that return address at the location
where the program expects it.  But because the top half bits of
the address have been masked out, the return address is now invalid.
The incorrect behavior of the "next" command and the backtrace at
that location are the first symptoms of that.  Another symptom is
that this actually alters the behavior of the program, where a "cont"
from there soon leads to a SEGV when the inferior tries to jump back
to that incorrect return address:

    (gdb) c
    Continuing.

    Program received signal SIGSEGV, Segmentation fault.
    0x00000000f7bd86f9 in ?? ()
    ^^^^^^^^^^^^^^^^^^

This patch fixes the issue by using a mask that seems more appropriate
for this architecture.

gdb/ChangeLog:

        * amd64-tdep.c (amd64_displaced_step_fixup): Fix the mask used to
        compute RETADDR.

gdb/testsuite/ChangeLog:

        * gdb.base/dso2dso-dso2.c, gdb.base/dso2dso-dso2.h,
        gdb.base/dso2dso-dso1.c, gdb.base/dso2dso-dso1.h, gdb.base/dso2dso.c,
        gdb.base/dso2dso.exp: New files.

Tested on x86_64-linux, no regression.


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] Fix '-data-read-memory-bytes' typo/assertion
@ 2016-02-11 15:36 sergiodj+buildbot
  2016-02-11 15:40 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2016-02-11 15:36 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT 718b36fead887693158396b948d7f409b987c053 ***

Author: Don Breazeal <donb@codesourcery.com>
Branch: gdb-7.10-branch
Commit: 718b36fead887693158396b948d7f409b987c053

Fix '-data-read-memory-bytes' typo/assertion

Backported to the 7.10 branch per this thread:
https://www.sourceware.org/ml/gdb-patches/2016-02/msg00134.html

This patch fixes a typo in target.c:read_memory_robust, where
it calls read_whatever_is_readable with the function arguments
in the wrong order.  Depending on the address being read, it
can cause an xmalloc with a huge size, resulting in an assertion
failure, or just read something other than what was requested.

The problem only arises when GDB is handling an MI
"-data-read-memory-bytes" request and the initial target_read returns
an error status.  Note that read_memory_robust is only called from
the MI code.

gdb/ChangeLog:

	* gdb/target.c (read_memory_robust): Call
	read_whatever_is_readable with arguments in the correct order.


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] Adjust GDB to demangler API change
@ 2015-11-28 21:16 sergiodj+buildbot
  2015-12-01 10:11 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2015-11-28 21:16 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT 9a2752c7f09d24865b33fedd9ac2585f3cbba3c3 ***

Author: Pedro Alves <palves@redhat.com>
Branch: gdb-7.10-branch
Commit: 9a2752c7f09d24865b33fedd9ac2585f3cbba3c3

Adjust GDB to demangler API change

Before commit 3a8724032abf, DEMANGLE_COMPONENT_CAST was used for both
casts and conversion operators.  We now have
DEMANGLE_COMPONENT_CONVERSION for the latter.

gdb/ChangeLog:
2014-11-28  Pedro Alves  <palves@redhat.com>

	* cp-name-parser.y (conversion_op): Use
	DEMANGLE_COMPONENT_CONVERSION instead of DEMANGLE_COMPONENT_CAST.


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] PR other/61321 - demangler crash on casts in template parameters
@ 2015-11-28 20:37 sergiodj+buildbot
  2015-12-01  9:45 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2015-11-28 20:37 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT 49037e4a1249890812a8d4995c7592774e99c399 ***

Author: Pedro Alves <palves@redhat.com>
Branch: gdb-7.10-branch
Commit: 49037e4a1249890812a8d4995c7592774e99c399

PR other/61321 - demangler crash on casts in template parameters

The fix for bug 59195:

 [C++ demangler handles conversion operator incorrectly]
 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59195

unfortunately makes the demangler crash due to infinite recursion, in
case of casts in template parameters.

For example, with:

 template<int> struct A {};
 template <typename Y> void function_temp(A<sizeof ((Y)(999))>) {}
 template void function_temp<int>(A<sizeof (int)>);

The 'function_temp<int>' instantiation above mangles to:

  _Z13function_tempIiEv1AIXszcvT_Li999EEE

The demangler parses this as:

typed name
  template
    name 'function_temp'
    template argument list
      builtin type int
  function type
    builtin type void
    argument list
      template                          (*)
        name 'A'
        template argument list
          unary operator
            operator sizeof
            unary operator
              cast
                template parameter 0    (**)
              literal
                builtin type int
                name '999'

And after the fix for 59195, due to:

 static void
 d_print_cast (struct d_print_info *dpi, int options,
	       const struct demangle_component *dc)
 {
 ...
   /* For a cast operator, we need the template parameters from
      the enclosing template in scope for processing the type.  */
   if (dpi->current_template != NULL)
     {
       dpt.next = dpi->templates;
       dpi->templates = &dpt;
       dpt.template_decl = dpi->current_template;
     }

when printing the template argument list of A (what should be "<sizeof
(int)>"), the template parameter 0 (that is, "T_", the '**' above) now
refers to the first parameter of the the template argument list of the
'A' template (the '*' above), exactly what we were already trying to
print.  This leads to infinite recursion, and stack exaustion.  The
template parameter 0 should actually refer to the first parameter of
the 'function_temp' template.

Where it reads "for the cast operator" in the comment in d_print_cast
(above), it's really talking about a conversion operator, like:

  struct A { template <typename U> explicit operator U(); };

We don't want to inject the template parameters from the enclosing
template in scope when processing a cast _expression_, only when
handling a conversion operator.

The problem is that DEMANGLE_COMPONENT_CAST is currently ambiguous,
and means _both_ 'conversion operator' and 'cast expression'.

Fix this by adding a new DEMANGLE_COMPONENT_CONVERSION component type,
which does what DEMANGLE_COMPONENT_CAST does today, and making
DEMANGLE_COMPONENT_CAST just simply print its component subtree.

I think we could instead reuse DEMANGLE_COMPONENT_CAST and in
d_print_comp_inner still do:

 @@ -5001,9 +5013,9 @@ d_print_comp_inner (struct d_print_info *dpi, int options,
        d_print_comp (dpi, options, dc->u.s_extended_operator.name);
        return;

     case DEMANGLE_COMPONENT_CAST:
       d_append_string (dpi, "operator ");
 -     d_print_cast (dpi, options, dc);
 +     d_print_conversion (dpi, options, dc);
       return;

leaving the unary cast case below calling d_print_cast, but seems to
me that spliting the component types makes it easier to reason about
the code.

g++'s testsuite actually generates three symbols that crash the
demangler in the same way.  I've added those as tests in the demangler
testsuite as well.

And then this fixes PR other/61233 too, which happens to be a
demangler crash originally reported to GDB, at:
https://sourceware.org/bugzilla/show_bug.cgi?id=16957

Bootstrapped and regtested on x86_64 Fedora 20.

Also ran this through GDB's testsuite.  GDB will require a small
update to use DEMANGLE_COMPONENT_CONVERSION in one place it's using
DEMANGLE_COMPONENT_CAST in its sources.

libiberty/
2015-11-27  Pedro Alves  <palves@redhat.com>

        PR other/61321
        PR other/61233
        * demangle.h (enum demangle_component_type)
        <DEMANGLE_COMPONENT_CONVERSION>: New value.
        * cp-demangle.c (d_demangle_callback, d_make_comp): Handle
        DEMANGLE_COMPONENT_CONVERSION.
        (is_ctor_dtor_or_conversion): Handle DEMANGLE_COMPONENT_CONVERSION
        instead of DEMANGLE_COMPONENT_CAST.
        (d_operator_name): Return a DEMANGLE_COMPONENT_CONVERSION
        component if handling a conversion.
        (d_count_templates_scopes, d_print_comp_inner): Handle
        DEMANGLE_COMPONENT_CONVERSION.
        (d_print_comp_inner): Handle DEMANGLE_COMPONENT_CONVERSION instead
        of DEMANGLE_COMPONENT_CAST.
        (d_print_cast): Rename as ...
        (d_print_conversion): ... this.  Adjust comments.
        (d_print_cast): Rewrite - simply print the left subcomponent.
        * cp-demint.c (cplus_demangle_fill_component): Handle
        DEMANGLE_COMPONENT_CONVERSION.

        * testsuite/demangle-expected: Add tests.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@231020 138bc75d-0d04-0410-961f-82ee72b054a4


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] Implement N4514, C++ Extensions for Transactional Memory.
@ 2015-11-28 20:05 sergiodj+buildbot
  2015-12-01  9:24 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2015-11-28 20:05 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT d65faac094af199ce4f9c8c0bbd062f668979431 ***

Author: Jason Merrill <jason@redhat.com>
Branch: gdb-7.10-branch
Commit: d65faac094af199ce4f9c8c0bbd062f668979431

Implement N4514, C++ Extensions for Transactional Memory.

gcc/
	* builtins.def (BUILT_IN_ABORT): Add transaction_pure attribute.
gcc/c-family/
	* c-common.c (c_common_reswords): Add C++ TM TS keywords.
	(c_common_attribute_table): Add transaction_safe_dynamic.
	transaction_safe now affects type identity.
	(handle_tm_attribute): Handle transaction_safe_dynamic.
	* c-common.h (enum rid): Add RID_ATOMIC_NOEXCEPT,
	RID_ATOMIC_CANCEL, RID_SYNCHRONIZED.
	(OBJC_IS_CXX_KEYWORD): Add RID_SYNCHRONIZED.
	(D_TRANSMEM): New.
	* c-cppbuiltin.c (c_cpp_builtins): Define __cpp_transactional_memory.
	* c-pretty-print.c (pp_c_attributes_display): Don't print
	transaction_safe in C++.
gcc/c/
	* c-parser.c (c_lex_one_token): Handle @synchronized.
	* c-decl.c (match_builtin_function_types): A declaration of a built-in
	can change whether the function is transaction_safe.
gcc/cp/
	* cp-tree.h (struct cp_declarator): Add tx_qualifier field.
	(BCS_NORMAL, BCS_TRANSACTION): New enumerators.
	* lex.c (init_reswords): Limit TM kewords to -fgnu-tm.
	* parser.c (cp_lexer_get_preprocessor_token): Fix @synchronized.
	(make_call_declarator): Take tx_qualifier.
	(cp_parser_tx_qualifier_opt): New.
	(cp_parser_lambda_declarator_opt): Use it.
	(cp_parser_direct_declarator): Likewise.
	(cp_parser_statement): Handle atomic_noexcept, atomic_cancel.
	(cp_parser_compound_statement): Change in_try parameter to bcs_flags.
	(cp_parser_std_attribute): Map optimize_for_synchronized to
	transaction_callable.
	(cp_parser_transaction): Take the token.  Handle atomic_noexcept.
	* lambda.c (maybe_add_lambda_conv_op): Handle transaction-safety.
	* call.c (enum conversion_kind): Add ck_tsafe.
	(standard_conversion): Handle transaction-safety conversion.
	(convert_like_real, resolve_address_of_overloaded_function): Likewise.
	(check_methods): Diagnose transaction_safe_dynamic on non-virtual
	function.
	(look_for_tm_attr_overrides): Don't inherit transaction_safe_dynamic.
	* cvt.c (tx_safe_fn_type_p, tx_unsafe_fn_variant)
	(can_convert_tx_safety): New.
	* typeck.c (composite_pointer_type): Handle transaction-safety.
	* name-lookup.h (enum scope_kind): Add sk_transaction.
	* name-lookup.c (begin_scope): Handle it.
	* semantics.c (begin_compound_stmt): Pass it.
	* decl.c (check_previous_goto_1): Check it.
	(struct named_label_entry): Add in_transaction_scope.
	(poplevel_named_label_1): Set it.
	(check_goto): Check it.
	(duplicate_decls): A specialization can be transaction_safe
	independently of its template.
	(grokdeclarator): Handle tx-qualifier.
	* rtti.c (ptr_initializer): Handle transaction-safe.
	* search.c (check_final_overrider): Check transaction_safe_dynamic.
	Don't check transaction_safe.
	* mangle.c (write_function_type): Mangle transaction_safe here.
	(write_CV_qualifiers_for_type): Not here.
	(write_type): Preserve transaction_safe when stripping attributes.
	* error.c (dump_type_suffix): Print transaction_safe.
libiberty/
	* cp-demangle.c (d_cv_qualifiers): Dx means transaction_safe.
	(cplus_demangle_type): Let d_cv_qualifiers handle it.
	(d_dump, d_make_comp, has_return_type, d_encoding)
	(d_count_templates_scopes, d_print_comp_inner)
	(d_print_mod_list, d_print_mod, d_print_function_type)
	(is_ctor_or_dtor): Handle DEMANGLE_COMPONENT_TRANSACTION_SAFE.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@228462 138bc75d-0d04-0410-961f-82ee72b054a4


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] btrace: diagnose "record btrace pt" without libipt
@ 2015-11-26 12:29 sergiodj+buildbot
  2015-11-26 12:32 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2015-11-26 12:29 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT bab694b7f968cc5703a69df694b5968384d6c0b4 ***

Author: Markus Metzger <markus.t.metzger@intel.com>
Branch: gdb-7.10-branch
Commit: bab694b7f968cc5703a69df694b5968384d6c0b4

btrace: diagnose "record btrace pt" without libipt

If GDB has been configured without libipt support, i.e. HAVE_LIBIPT is
undefined, and is running on a system that supports Intel(R) Processor Trace,
GDB will run into an internal error when trying to decode the trace.

    (gdb) record btrace
    (gdb) s
    usage (name=0x7fffffffe954 "fib-64")
        at src/fib.c:12
    12          fprintf(stderr, "usage: %s <num>\n", name);
    (gdb) info record
    Active record target: record-btrace
    Recording format: Intel(R) Processor Trace.
    Buffer size: 16kB.
    gdb/btrace.c:971: internal-error: Unexpected branch trace format.
    A problem internal to GDB has been detected,
    further debugging may prove unreliable.
    Quit this debugging session? (y or n)

This requires a system with Linux kernel 4.1 or later running on a 5th
Generation Intel Core processor or later.

The issue is documented as PR 19297.

When trying to enable branch tracing, in addition to checking the target
support for the requested branch tracing format, also check whether GDB
supports. it.

gdb/
	* btrace.c (btrace_enable): Check whether HAVE_LIBIPT is defined.


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] Bump GDB version number to 7.10.0.DATE-cvs.
@ 2015-08-28 22:28 sergiodj+buildbot
  2015-08-28 22:33 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2015-08-28 22:28 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT 731da5a0b366c9442eb268bade3e80ed0e7c8cfb ***

Author: Joel Brobecker <brobecker@adacore.com>
Branch: gdb-7.10-branch
Commit: 731da5a0b366c9442eb268bade3e80ed0e7c8cfb

Bump GDB version number to 7.10.0.DATE-cvs.

gdb/ChangeLog:

	* version.in: Set GDB version number to 7.10.0.DATE-cvs.


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] signal_command: Leftover cleanup chain regression
@ 2015-08-25 17:11 sergiodj+buildbot
  2015-08-25 20:22 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2015-08-25 17:11 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT 3ba0344e56ef739808615be5ca319f82c2a83855 ***

Author: Jan Kratochvil <jan.kratochvil@redhat.com>
Branch: gdb-7.10-branch
Commit: 3ba0344e56ef739808615be5ca319f82c2a83855

signal_command: Leftover cleanup chain regression

gdb/ChangeLog
2015-08-04  Jan Kratochvil  <jan.kratochvil@redhat.com>

	* infcmd.c (signal_command): Call do_cleanups for args_chain.


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] Make remote file transfers interruptible
@ 2015-08-21 18:24 sergiodj+buildbot
  2015-08-21 18:26 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2015-08-21 18:24 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT ecc06bd425d6fcbb994b7b4d1d6f3c6f705e0784 ***

Author: Gary Benson <gbenson@redhat.com>
Branch: gdb-7.10-branch
Commit: ecc06bd425d6fcbb994b7b4d1d6f3c6f705e0784

Make remote file transfers interruptible

This commit makes it possible to interrupt remote file transfers.

gdb/ChangeLog:

	* gdb_bfd.c (gdb_bfd_iovec_fileio_pread): Add QUIT call.


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] Warn when accessing binaries from remote targets
@ 2015-08-21 17:54 sergiodj+buildbot
  2015-08-21 17:58 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2015-08-21 17:54 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT 290f582b49a81b7fa01fc430bad1a7f9af21c922 ***

Author: Gary Benson <gbenson@redhat.com>
Branch: gdb-7.10-branch
Commit: 290f582b49a81b7fa01fc430bad1a7f9af21c922

Warn when accessing binaries from remote targets

GDB provides no indicator of progress during file operations, and can
appear to have locked up during slow remote transfers.  This commit
updates GDB to print a warning each time a file is accessed over RSP.
An additional message detailing how to avoid remote transfers is
printed for the first transfer only.

gdb/ChangeLog:

	* target.h (struct target_ops) <to_fileio_open>: New argument
	warn_if_slow.  Update comment.  All implementations updated.
	(target_fileio_open_warn_if_slow): New declaration.
	* target.c (target_fileio_open): Renamed as...
	(target_fileio_open_1): ...this.  New argument warn_if_slow.
	Pass warn_if_slow to implementation.  Update debug printing.
	(target_fileio_open): New function.
	(target_fileio_open_warn_if_slow): Likewise.
	* gdb_bfd.c (gdb_bfd_iovec_fileio_open): Use new function
	target_fileio_open_warn_if_slow.

gdb/testsuite/ChangeLog:

	* gdb.trace/pending.exp: Cope with remote transfer warnings.


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] Fix mis-parsing of hex register numbers in 'T' stop replies
@ 2015-08-18 18:12 sergiodj+buildbot
  2015-08-18 18:12 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2015-08-18 18:12 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT e13cbb569965ee3baca2ad4801eeb910c2b2f03f ***

Author: Sandra Loosemore <sandra@codesourcery.com>
Branch: gdb-7.10-branch
Commit: e13cbb569965ee3baca2ad4801eeb910c2b2f03f

Fix mis-parsing of hex register numbers in 'T' stop replies

2015-08-18  Sandra Loosemore  <sandra@codesourcery.com>

	gdb/
	* remote.c (strprefix): New.
	(remote_parse_stop_reply): Use strprefix instead of strncmp
	to ensure exact match of keyword.


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] gdb.base/dso2dso.exp: Improve testcase documentation.
@ 2015-08-13 20:06 sergiodj+buildbot
  2015-08-13 20:12 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2015-08-13 20:06 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT 3d1e2b37751fed4e014d52ce858bcb6b147c475a ***

Author: Joel Brobecker <brobecker@adacore.com>
Branch: gdb-7.10-branch
Commit: 3d1e2b37751fed4e014d52ce858bcb6b147c475a

gdb.base/dso2dso.exp: Improve testcase documentation.

gdb/testsuite/ChangeLog:

        * gdb.base/dso2dso.exp: Improve the testcase's documentation.


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] [regression] Do not read from catchpoint/watchpoint locations' addresses when checking for a permanent breakpoint
@ 2015-08-12  9:20 sergiodj+buildbot
  2015-08-12  9:20 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2015-08-12  9:20 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT 835001623351330d49678d215d1338c0ce35c1f9 ***

Author: Luis Machado <lgustavo@codesourcery.com>
Branch: gdb-7.10-branch
Commit: 835001623351330d49678d215d1338c0ce35c1f9

[regression] Do not read from catchpoint/watchpoint locations' addresses when checking for a permanent breakpoint

While running bare-metal tests with GDB i noticed some failures in
gdb.base/break.exp, related to the use of the catch commands.

It turns out GDB tries to access memory address 0x0 whenever one tries
to insert a catchpoint, which should obviously not happen.

This was introduced with the changes for permanent breakpoints. In special,
bp_loc_is_permanent tries to check if there is a breakpoint inserted at
the same address as the current breakpoint's location's address. In the
case of catchpoints, this is 0x0.

(top-gdb) catch fork
Sending packet: $m0,1#fa...Packet received: E01
Catchpoint 4 (fork)

(top-gdb) catch vfork
Sending packet: $m0,1#fa...Packet received: E01
Catchpoint 5 (vfork)

It is not obvious to detect because this fails silently for Linux. For our
bare-metal testing, though, this fails with a clear error message from the
target about not being able to read such address.

The attached patch addresses this by bailing out of bp_loc_is_permanent (...)
if the location address is not meaningful. I also took the opportunity to
update the comment for breakpoint_address_is_meaningful, which mentioned
breakpoint addresses as opposed to their locations' addresses.

gdb/ChangeLog:

2015-08-11  Luis Machado  <lgustavo@codesourcery.com>

	* breakpoint.c (bp_loc_is_permanent): Return 0 when breakpoint
	location address is not meaningful.
	(breakpoint_address_is_meaningful): Update comment.


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] PR python/17136
@ 2015-08-06 17:47 sergiodj+buildbot
  2015-08-06 18:36 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2015-08-06 17:47 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT 17d1595ac5371d06537bc57df86a9f7359e62127 ***

Author: Clem Dickey <clemd@acm.org>
Branch: gdb-7.10-branch
Commit: 17d1595ac5371d06537bc57df86a9f7359e62127

PR python/17136
gdb/ChangeLog:

	* python/lib/gdb/command/type_printers.py (InfoTypePrinter): Fix typo.


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] gdbserver: move_out_of_jump_pad_callback misses switching current thread
@ 2015-08-06 16:01 sergiodj+buildbot
  2015-08-06 16:40 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2015-08-06 16:01 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT a01c46276aa3a16c2ac1dae249df14e39d1c281f ***

Author: Pedro Alves <palves@redhat.com>
Branch: gdb-7.10-branch
Commit: a01c46276aa3a16c2ac1dae249df14e39d1c281f

gdbserver: move_out_of_jump_pad_callback misses switching current thread
While hacking on the fix for PR threads/18600 (Threads left stopped
after fork+thread spawn), I once saw its test (fork-plus-threads.exp)
FAIL against gdbserver because move_out_of_jump_pad_callback has a
gdb_breakpoint_here call, and the caller isn't making sure the current
thread points to the right thread.  In the case I saw, the current
thread pointed to the wrong process, so gdb_breakpoint_here returned
the wrong answer.  Unfortunately I didn't save logs.  Still, seems
obvious enough and it should fix a potential occasional racy FAIL.

Tested on x86_64 Fedora 20.

gdb/gdbserver/ChangeLog:
2015-08-06  Pedro Alves  <palves@redhat.com>

	* linux-low.c (move_out_of_jump_pad_callback): Temporarily switch
	the current thread.


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] Fix gdbserver --debug issues caught by Valgrind
@ 2015-08-06 14:49 sergiodj+buildbot
  2015-08-06 15:23 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2015-08-06 14:49 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT 4ede28ca86b7206859a965cfaf2b13236f2de752 ***

Author: Pedro Alves <palves@redhat.com>
Branch: gdb-7.10-branch
Commit: 4ede28ca86b7206859a965cfaf2b13236f2de752

Fix gdbserver --debug issues caught by Valgrind
Running gdbserver --debug under Valgrind shows:

 ==4803== Invalid read of size 4
 ==4803==    at 0x432B62: linux_write_memory (linux-low.c:5320)
 ==4803==    by 0x4143F7: write_inferior_memory (target.c:83)
 ==4803==    by 0x415895: remove_memory_breakpoint (mem-break.c:362)
 ==4803==    by 0x432EF5: linux_remove_point (linux-low.c:5460)
 ==4803==    by 0x416319: delete_raw_breakpoint (mem-break.c:802)
 ==4803==    by 0x4163F3: release_breakpoint (mem-break.c:842)
 ==4803==    by 0x416477: delete_breakpoint_1 (mem-break.c:869)
 ==4803==    by 0x4164EF: delete_breakpoint (mem-break.c:891)
 ==4803==    by 0x416843: delete_gdb_breakpoint_1 (mem-break.c:1069)
 ==4803==    by 0x4168D8: delete_gdb_breakpoint (mem-break.c:1098)
 ==4803==    by 0x4134E3: process_serial_event (server.c:4051)
 ==4803==    by 0x4138E4: handle_serial_event (server.c:4196)
 ==4803==  Address 0x4c6b930 is 0 bytes inside a block of size 1 alloc'd
 ==4803==    at 0x4A0645D: malloc (in /usr/lib64/valgrind/vgpreload_memcheck-amd64-linux.so)
 ==4803==    by 0x4240C6: xmalloc (common-utils.c:43)
 ==4803==    by 0x41439C: write_inferior_memory (target.c:80)
 ==4803==    by 0x415895: remove_memory_breakpoint (mem-break.c:362)
 ==4803==    by 0x432EF5: linux_remove_point (linux-low.c:5460)
 ==4803==    by 0x416319: delete_raw_breakpoint (mem-break.c:802)
 ==4803==    by 0x4163F3: release_breakpoint (mem-break.c:842)
 ==4803==    by 0x416477: delete_breakpoint_1 (mem-break.c:869)
 ==4803==    by 0x4164EF: delete_breakpoint (mem-break.c:891)
 ==4803==    by 0x416843: delete_gdb_breakpoint_1 (mem-break.c:1069)
 ==4803==    by 0x4168D8: delete_gdb_breakpoint (mem-break.c:1098)
 ==4803==    by 0x4134E3: process_serial_event (server.c:4051)
 ==4803==

And:

 ==7272== Conditional jump or move depends on uninitialised value(s)
 ==7272==    at 0x3615E48361: vfprintf (vfprintf.c:1634)
 ==7272==    by 0x414E89: debug_vprintf (debug.c:60)
 ==7272==    by 0x42800A: debug_printf (common-debug.c:35)
 ==7272==    by 0x43937B: my_waitpid (linux-waitpid.c:149)
 ==7272==    by 0x42D740: linux_wait_for_event_filtered (linux-low.c:2441)
 ==7272==    by 0x42DADA: linux_wait_for_event (linux-low.c:2552)
 ==7272==    by 0x42E165: linux_wait_1 (linux-low.c:2860)
 ==7272==    by 0x42F5D8: linux_wait (linux-low.c:3453)
 ==7272==    by 0x4144A4: mywait (target.c:107)
 ==7272==    by 0x413969: handle_target_event (server.c:4214)
 ==7272==    by 0x41A1A6: handle_file_event (event-loop.c:429)
 ==7272==    by 0x41996D: process_event (event-loop.c:184)

gdb/ChangeLog:
2015-08-06  Pedro Alves  <palves@redhat.com>

	* nat/linux-waitpid.c (my_waitpid): Only print *status if waitpid
	returned > 0.

gdb/gdbserver/ChangeLog:
2015-08-06  Pedro Alves  <palves@redhat.com>

	* linux-low.c (linux_write_memory): Rewrite debug output to avoid
	reading beyond the passed in buffer length.


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] gdbserver: Fix non-stop / fork / step-over issues
@ 2015-08-06 12:22 sergiodj+buildbot
  2015-08-06 12:24 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2015-08-06 12:22 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT 3a3f16c0cf0fa5a555a688e119bb8b363a2e7d59 ***

Author: Pedro Alves <palves@redhat.com>
Branch: gdb-7.10-branch
Commit: 3a3f16c0cf0fa5a555a688e119bb8b363a2e7d59

gdbserver: Fix non-stop / fork / step-over issues
Ref: https://sourceware.org/ml/gdb-patches/2015-07/msg00868.html

This adds a test that has a multithreaded program have several threads
continuously fork, while another thread continuously steps over a
breakpoint.

This exposes several intertwined issues, which this patch addresses:

 - When we're stopping and suspending threads, some thread may fork,
   and we missed setting its suspend count to 1, like we do when a new
   clone/thread is detected.  When we next unsuspend threads, the fork
   child's suspend count goes below 0, which is bogus and fails an
   assertion.

 - If a step-over is cancelled because a signal arrives, but then gdb
   is not interested in the signal, we pass the signal straight back
   to the inferior.  However, we miss that we need to re-increment the
   suspend counts of all other threads that had been paused for the
   step-over.  As a result, other threads indefinitely end up stuck
   stopped.

 - If a detach request comes in just while gdbserver is handling a
   step-over (in the test at hand, this is GDB detaching the fork
   child), gdbserver internal errors in stabilize_thread's helpers,
   which assert that all thread's suspend counts are 0 (otherwise we
   wouldn't be able to move threads out of the jump pads).  The
   suspend counts aren't 0 while a step-over is in progress, because
   all threads but the one stepping past the breakpoint must remain
   paused until the step-over finishes and the breakpoint can be
   reinserted.

 - Occasionally, we see "BAD - reinserting but not stepping." being
   output (from within linux_resume_one_lwp_throw).  That was because
   GDB pokes memory while gdbserver is busy with a step-over, and that
   suspends threads, and then re-resumes them with proceed_one_lwp,
   which missed another reason to tell linux_resume_one_lwp that the
   thread should be set back to stepping.

 - In a couple places, we were resuming threads that are meant to be
   suspended.  E.g., when a vCont;c/s request for thread B comes in
   just while gdbserver is stepping thread A past a breakpoint.  The
   resume for thread B must be deferred until the step-over finishes.

 - The test runs with both "set detach-on-fork" on and off.  When off,
   it exercises the case of GDB detaching the fork child explicitly.
   When on, it exercises the case of gdb resuming the child
   explicitly.  In the "off" case, gdb seems to exponentially become
   slower as new inferiors are created.  This is _very_ noticeable as
   with only 100 inferiors gdb is crawling already, which makes the
   test take quite a bit to run.  For that reason, I've disabled the
   "off" variant for now.

gdb/ChangeLog:
2015-08-06  Pedro Alves  <palves@redhat.com>

	* target/waitstatus.h (enum target_stop_reason)
	<TARGET_STOPPED_BY_SINGLE_STEP>: New value.

gdb/gdbserver/ChangeLog:
2015-08-06  Pedro Alves  <palves@redhat.com>

	* linux-low.c (handle_extended_wait): Set the fork child's suspend
	count if stopping and suspending threads.
	(check_stopped_by_breakpoint): If stopped by trace, set the LWP's
	stop reason to TARGET_STOPPED_BY_SINGLE_STEP.
	(linux_detach): Complete an ongoing step-over.
	(lwp_suspended_inc, lwp_suspended_decr): New functions.  Use
	throughout.
	(resume_stopped_resumed_lwps): Don't resume a suspended thread.
	(linux_wait_1): If passing a signal to the inferior after
	finishing a step-over, unsuspend and re-resume all lwps.  If we
	see a single-step event but the thread should be continuing, don't
	pass the trap to gdb.
	(stuck_in_jump_pad_callback, move_out_of_jump_pad_callback): Use
	internal_error instead of gdb_assert.
	(enqueue_pending_signal): New function.
	(check_ptrace_stopped_lwp_gone): Add debug output.
	(start_step_over): Use internal_error instead of gdb_assert.
	(complete_ongoing_step_over): New function.
	(linux_resume_one_thread): Don't resume a suspended thread.
	(proceed_one_lwp): If the LWP is stepping over a breakpoint, reset
	it stepping.

gdb/testsuite/ChangeLog:
2015-08-06  Pedro Alves  <palves@redhat.com>

	* gdb.threads/forking-threads-plus-breakpoint.exp: New file.
	* gdb.threads/forking-threads-plus-breakpoint.c: New file.


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] Linux gdbserver confused when event randomization picks process exit event
@ 2015-08-06 11:58 sergiodj+buildbot
  2015-08-06 11:58 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2015-08-06 11:58 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT 91da80b56eb52209fb8b366aca9519eb6e488397 ***

Author: Pedro Alves <palves@redhat.com>
Branch: gdb-7.10-branch
Commit: 91da80b56eb52209fb8b366aca9519eb6e488397

Linux gdbserver confused when event randomization picks process exit event
The tail end of linux_wait_1 isn't expecting that the select_event_lwp
machinery can pick a whole-process exit event to report to GDB.  When
that happens, both gdb and gdbserver end up quite confused:

 ...
 (gdb)
 [Thread 24971.24971] #1 stopped.
 0x0000003615a011f0 in ?? ()
 c&
 Continuing.
 (gdb) [New Thread 24971.24981]
 [New Thread 24983.24983]
 [New Thread 24971.24982]

 [Thread 24983.24983] #3 stopped.
 0x0000003615ebc7cc in __libc_fork () at ../nptl/sysdeps/unix/sysv/linux/fork.c:130
 130       pid = ARCH_FORK ();
 [New Thread 24984.24984]
 Error in re-setting breakpoint -16: PC register is not available
 Error in re-setting breakpoint -17: PC register is not available
 Error in re-setting breakpoint -18: PC register is not available
 Error in re-setting breakpoint -19: PC register is not available
 Error in re-setting breakpoint -24: PC register is not available
 Error in re-setting breakpoint -25: PC register is not available
 Error in re-setting breakpoint -26: PC register is not available
 Error in re-setting breakpoint -27: PC register is not available
 Error in re-setting breakpoint -28: PC register is not available
 Error in re-setting breakpoint -29: PC register is not available
 Error in re-setting breakpoint -30: PC register is not available
 PC register is not available
 (gdb)

gdb/gdbserver/ChangeLog:
2015-08-06  Pedro Alves  <palves@redhat.com>

	* linux-low.c (add_lwp): Set waitstatus to TARGET_WAITKIND_IGNORE.
	(linux_thread_alive): Use lwp_is_marked_dead.
	(extended_event_reported): Delete.
	(linux_wait_1): Check if waitstatus is TARGET_WAITKIND_IGNORE
	instead of extended_event_reported.
	(mark_lwp_dead): Don't set the 'dead' flag.  Store the waitstatus
	as well.
	(lwp_is_marked_dead): New function.
	(lwp_running): Use lwp_is_marked_dead.
	* linux-low.h: Delete 'dead' field, and update 'waitstatus's
	comment.


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] remote follow fork and spurious child stops in non-stop mode
@ 2015-07-30 20:35 sergiodj+buildbot
  2015-07-30 21:01 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2015-07-30 20:35 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT 4ccc18f16da05e93aff0c7ac570017d5ef79ef6c ***

Author: Pedro Alves <palves@redhat.com>
Branch: gdb-7.10-branch
Commit: 4ccc18f16da05e93aff0c7ac570017d5ef79ef6c

remote follow fork and spurious child stops in non-stop mode
Running gdb.threads/fork-plus-threads.exp against gdbserver in
extended-remote mode, even though the test passes, we still see broken
behavior:

 (gdb) PASS: gdb.threads/fork-plus-threads.exp: set detach-on-fork off
 continue &
 Continuing.
 (gdb) PASS: gdb.threads/fork-plus-threads.exp: continue &
 [New Thread 28092.28092]

 [Thread 28092.28092] #2 stopped.
 [New Thread 28094.28094]
 [Inferior 2 (process 28092) exited normally]
 [New Thread 28094.28105]
 [New Thread 28094.28109]

...

[Thread 28174.28174] #18 stopped.
 [New Thread 28185.28185]
 [Inferior 10 (process 28174) exited normally]
 [New Thread 28185.28196]

 [Thread 28185.28185] #20 stopped.
 Cannot remove breakpoints because program is no longer writable.
 Further execution is probably impossible.
 [Inferior 11 (process 28185) exited normally]
 [Inferior 1 (process 28091) exited normally]
 PASS: gdb.threads/fork-plus-threads.exp: reached breakpoint
 info threads
 No threads.
 (gdb) PASS: gdb.threads/fork-plus-threads.exp: no threads left
 info inferiors
   Num  Description       Executable
 * 1    <null>            /home/pedro/gdb/mygit/build/gdb/testsuite/gdb.threads/fork-plus-threads
 (gdb) PASS: gdb.threads/fork-plus-threads.exp: only inferior 1 left

All the "[Thread FOO] #NN stopped." above are bogus, as well as the
"Cannot remove breakpoints because program is no longer writable.",
which is a consequence.

The problem is that when we intercept a fork event, we should report
the event for the parent, only, and leave the child stopped, but not
report its stop event.  GDB later decides whether to follow the parent
or the child.  But because handle_extended_wait does not set the
child's last_status.kind to TARGET_WAITKIND_STOPPED, a
stop_all_threads/unstop_all_lwps sequence (e.g., from trying to access
memory) by mistake ends up queueing a SIGSTOP on the child, resuming
it, and then when that SIGSTOP is intercepted, because the LWP has
last_resume_kind set to resume_stop, gdbserver reports the stop to
GDB, as GDB_SIGNAL_0:

...
 >>>> entering unstop_all_lwps
 unstopping all lwps
 proceed_one_lwp: lwp 1600
    client wants LWP to remain 1600 stopped
 proceed_one_lwp: lwp 1828
 Client wants LWP 1828 to stop. Making sure it has a SIGSTOP pending
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 Sending sigstop to lwp 1828
 pc is 0x3615ebc7cc
 Resuming lwp 1828 (continue, signal 0, stop expected)
   continue from pc 0x3615ebc7cc
 unstop_all_lwps done
 sigchld_handler
 <<<< exiting unstop_all_lwps
 handling possible target event
 >>>> entering linux_wait_1
 linux_wait_1: [<all threads>]
 my_waitpid (-1, 0x40000001)
 my_waitpid (-1, 0x1): status(137f), 1828
 LWFE: waitpid(-1, ...) returned 1828, ERRNO-OK
 LLW: waitpid 1828 received Stopped (signal) (stopped)
 pc is 0x3615ebc7cc
 Expected stop.
 LLW: resume_stop SIGSTOP caught for LWP 1828.1828.
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
...
 linux_wait_1 ret = LWP 1828.1828, 1, 0
 <<<< exiting linux_wait_1
 Writing resume reply for LWP 1828.1828:1
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Tested on x86_64 Fedora 20, extended-remote.

gdb/gdbserver/ChangeLog:
2015-07-30  Pedro Alves  <palves@redhat.com>

	* linux-low.c (handle_extended_wait): Set the child's last
	reported status to TARGET_WAITKIND_STOPPED.


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] PR threads/18600: Threads left stopped after fork+thread spawn
@ 2015-07-30 19:38 sergiodj+buildbot
  2015-07-30 19:49 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2015-07-30 19:38 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT b31f5e79aac67f61a684c3af281caebd2ac1eece ***

Author: Pedro Alves <palves@redhat.com>
Branch: gdb-7.10-branch
Commit: b31f5e79aac67f61a684c3af281caebd2ac1eece

PR threads/18600: Threads left stopped after fork+thread spawn
When a program forks and another process start threads while gdb is
handling the fork event, newly created threads are left stuck stopped
by gdb, even though gdb presents them as "running", to the user.

This can be seen with the test added by this patch.  The test has the
inferior fork a certain number of times and waits for all children to
exit.  Each fork child spawns a number of threads that do nothing and
joins them immediately.  Normally, the program should run unimpeded
(from the point of view of the user) and exit very quickly.  Without
this fix, it doesn't because of some threads left stopped by gdb, so
inferior 1 never exits.

The program triggers when a new clone thread is found while inside the
linux_stop_and_wait_all_lwps call in linux-thread-db.c:

      linux_stop_and_wait_all_lwps ();

      ALL_LWPS (lp)
	if (ptid_get_pid (lp->ptid) == pid)
	  thread_from_lwp (lp->ptid);

      linux_unstop_all_lwps ();

Within linux_stop_and_wait_all_lwps, we reach
linux_handle_extended_wait with the "stopping" parameter set to 1, and
because of that we don't mark the new lwp as resumed.  As consequence,
the subsequent resume_stopped_resumed_lwps, called from
linux_unstop_all_lwps, never resumes the new LWP.

There's lots of cruft in linux_handle_extended_wait that no longer
makes sense.  On systems with CLONE events support, we don't rely on
libthread_db for thread listing anymore, so the code that preserves
stop_requested and the handling of last_resume_kind is all dead.

So the fix is to remove all that, and simply always mark the new LWP
as resumed, so that resume_stopped_resumed_lwps re-resumes it.

gdb/ChangeLog:
2015-07-30  Pedro Alves  <palves@redhat.com>
	    Simon Marchi  <simon.marchi@ericsson.com>

	PR threads/18600
	* linux-nat.c (linux_handle_extended_wait): On CLONE event, always
	mark the new thread as resumed.  Remove STOPPING parameter.
	(wait_lwp): Adjust call to linux_handle_extended_wait.
	(linux_nat_filter_event): Adjust call to
	linux_handle_extended_wait.
	(resume_stopped_resumed_lwps): Add debug output.

gdb/testsuite/ChangeLog:
2015-07-30  Simon Marchi  <simon.marchi@ericsson.com>
	    Pedro Alves  <palves@redhat.com>

	PR threads/18600
	* gdb.threads/fork-plus-threads.c: New file.
	* gdb.threads/fork-plus-threads.exp: New file.


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] record: set stop_pc in "record goto" command
@ 2015-07-14  7:24 sergiodj+buildbot
  2015-07-14  7:30 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2015-07-14  7:24 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT 0900c4cec7f75a00cccb3537d754c20f99096686 ***

Author: Markus Metzger <markus.t.metzger@intel.com>
Branch: gdb-7.10-branch
Commit: 0900c4cec7f75a00cccb3537d754c20f99096686

record: set stop_pc in "record goto" command
When navigating in the recorded execution trace via "record goto", we do not
set stop_pc.  This may trigger an internal error in infrun.c when stepping
from that location.  Set it.

(gdb) rec full
(gdb) c
Continuing.

Breakpoint 1, foo (void) at foo.c:42
42             x = y
(gdb) rn
foo (void)
    at foo.c:41
41             y = x
(gdb) rec go end
Go forward to insn number 98724
    at foo.c:42
42             x = y
(gdb) n
infrun.c:2382: internal-error: resume: Assertion `sig != GDB_SIGNAL_0' failed.
A problem internal to GDB has been detected,
further debugging may prove unreliable.
Quit this debugging session? (y or n)

This happens because there's a breakpoint at PC when the "next"
is issued, so that breapoint should be immediately stepped over.
That should have been detected/done by proceed, here:

  if (addr == (CORE_ADDR) -1)
    {
      if (pc == stop_pc
	  && breakpoint_here_p (aspace, pc) == ordinary_breakpoint_here
	  && execution_direction != EXEC_REVERSE)
	/* There is a breakpoint at the address we will resume at,
	   step one instruction before inserting breakpoints so that
	   we do not stop right away (and report a second hit at this
	   breakpoint).

	   Note, we don't do this in reverse, because we won't
	   actually be executing the breakpoint insn anyway.
	   We'll be (un-)executing the previous instruction.  */
	tp->stepping_over_breakpoint = 1;

But since stop_pc was stale, the pc == stop_pc check failed, and left the
breakpont at PC inserted.

gdb/
	* record-btrace.c (record_btrace_goto_begin, record_btrace_goto_end)
	record_btrace_goto): Move call to print_stack_frame ...
	(record_btrace_set_replay): ... here.  Set stop_pc.
	* record-full.c (record_full_goto_entry): Set stop_pc.

testsuite/
	* gdb.btrace/record_goto-step.exp: New.


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] btrace: fix build fail with 32-bit BFD
@ 2015-07-14  6:52 sergiodj+buildbot
  2015-07-14  6:54 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2015-07-14  6:52 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT 77116e10e2eb48425af3fe860b5dc8faa71de16a ***

Author: Markus Metzger <markus.t.metzger@intel.com>
Branch: gdb-7.10-branch
Commit: 77116e10e2eb48425af3fe860b5dc8faa71de16a

btrace: fix build fail with 32-bit BFD
When compiling GDB with 32-bit BFD, the build fails with:

In file included from btrace.h:33:0,
                 from btrace.c:23:
/usr/include/intel-pt.h:1643:51: note: expected 'int (*)(uint8_t *, size_t,
 const struct pt_asid *, uint64_t, void *)' but argument is of type 'int
 (*)(gdb_byte *, size_t, const struct pt_asid *, CORE_ADDR, void *)' extern
 pt_export int pt_image_set_callback(struct pt_image *image, ^

gdb/
	* btrace.c (btrace_pt_readmem_callback): Change type of PC argument.


^ permalink raw reply	[flat|nested] 44+ messages in thread
* [binutils-gdb/gdb-7.10-branch] Fix testsuite regression by: Do not skip prologue for asm (.S) files
@ 2015-07-10 13:58 sergiodj+buildbot
  2015-07-10 14:31 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
  0 siblings, 1 reply; 44+ messages in thread
From: sergiodj+buildbot @ 2015-07-10 13:58 UTC (permalink / raw)
  To: gdb-testers

*** TEST RESULTS FOR COMMIT 8746ea769d67bf186d582d892cf37da42bc95ea9 ***

Author: Jan Kratochvil <jan.kratochvil@redhat.com>
Branch: gdb-7.10-branch
Commit: 8746ea769d67bf186d582d892cf37da42bc95ea9

Fix testsuite regression by: Do not skip prologue for asm (.S) files
I have somehow missed gdb.asm/asm-source.exp PASS->FAIL even on x86_64.

It has no longer valid assumption that "break" breaks after the prologue even
in assembler.  So I have changed this assumption of the testfile.

gdb/testsuite/ChangeLog
2015-07-10  Jan Kratochvil  <jan.kratochvil@redhat.com>

	* gdb.asm/asm-source.exp (f at main): Stop at gdbasm_enter.
	(n at main): New.
	* gdb.asm/asmsrc1.s: Add comment "mark: main enter".


^ permalink raw reply	[flat|nested] 44+ messages in thread
end of thread, other threads:[~2016-02-11 15:40 UTC | newest]

Thread overview: 44+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2015-08-13 19:13 [binutils-gdb/gdb-7.10-branch] [amd64] Invalid return address after displaced stepping sergiodj+buildbot
2015-08-13 19:13 ` Failures on Fedora-i686, branch gdb-7.10-branch sergiodj+buildbot
2015-08-13 19:13 ` Failures on Fedora-x86_64-m32, " sergiodj+buildbot
2015-08-13 19:22 ` Failures on Fedora-x86_64-cc-with-index, " sergiodj+buildbot
2015-08-13 19:23 ` Failures on Fedora-x86_64-native-extended-gdbserver-m32, " sergiodj+buildbot
2015-08-13 19:26 ` Failures on AIX-POWER7-plain, " sergiodj+buildbot
2015-08-13 19:27 ` Failures on Fedora-x86_64-native-gdbserver-m64, " sergiodj+buildbot
2015-08-13 19:42 ` Failures on Fedora-x86_64-native-gdbserver-m32, " sergiodj+buildbot
2015-08-13 19:54 ` Failures on Debian-s390x-native-extended-gdbserver-m64, " sergiodj+buildbot
2015-08-13 20:09 ` Failures on Fedora-s390x-m64, " sergiodj+buildbot
2015-08-14  3:22 ` Failures on Fedora-ppc64be-cc-with-index, " sergiodj+buildbot
2015-08-14  3:48 ` Failures on Fedora-ppc64be-m64, " sergiodj+buildbot
2015-08-14  4:04 ` Failures on Fedora-ppc64be-native-gdbserver-m64, " sergiodj+buildbot
2015-08-14  4:25 ` Failures on Fedora-ppc64be-native-extended-gdbserver-m64, " sergiodj+buildbot
2015-08-14 10:57 ` Failures on Debian-x86_64-m64, " sergiodj+buildbot
2015-08-14 17:46 ` Failures on Fedora-ppc64le-native-extended-gdbserver-m64, " sergiodj+buildbot
2015-08-14 18:21 ` Failures on Fedora-ppc64le-native-gdbserver-m64, " sergiodj+buildbot
2015-08-14 18:42 ` Failures on Fedora-ppc64le-m64, " sergiodj+buildbot
2015-08-15 11:26 ` Failures on Debian-i686, " sergiodj+buildbot
2015-08-15 12:16 ` Failures on Debian-i686-native-gdbserver, " sergiodj+buildbot
2015-08-15 13:30 ` Failures on Debian-i686-native-extended-gdbserver, " sergiodj+buildbot
2015-08-23  1:14 ` Failures on Debian-MIPS-m64, " sergiodj+buildbot
  -- strict thread matches above, loose matches on Subject: below --
2016-02-11 15:36 [binutils-gdb/gdb-7.10-branch] Fix '-data-read-memory-bytes' typo/assertion sergiodj+buildbot
2016-02-11 15:40 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
2015-11-28 21:16 [binutils-gdb/gdb-7.10-branch] Adjust GDB to demangler API change sergiodj+buildbot
2015-12-01 10:11 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
2015-11-28 20:37 [binutils-gdb/gdb-7.10-branch] PR other/61321 - demangler crash on casts in template parameters sergiodj+buildbot
2015-12-01  9:45 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
2015-11-28 20:05 [binutils-gdb/gdb-7.10-branch] Implement N4514, C++ Extensions for Transactional Memory sergiodj+buildbot
2015-12-01  9:24 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
2015-11-26 12:29 [binutils-gdb/gdb-7.10-branch] btrace: diagnose "record btrace pt" without libipt sergiodj+buildbot
2015-11-26 12:32 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
2015-08-28 22:28 [binutils-gdb/gdb-7.10-branch] Bump GDB version number to 7.10.0.DATE-cvs sergiodj+buildbot
2015-08-28 22:33 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
2015-08-25 17:11 [binutils-gdb/gdb-7.10-branch] signal_command: Leftover cleanup chain regression sergiodj+buildbot
2015-08-25 20:22 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
2015-08-21 18:24 [binutils-gdb/gdb-7.10-branch] Make remote file transfers interruptible sergiodj+buildbot
2015-08-21 18:26 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
2015-08-21 17:54 [binutils-gdb/gdb-7.10-branch] Warn when accessing binaries from remote targets sergiodj+buildbot
2015-08-21 17:58 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
2015-08-18 18:12 [binutils-gdb/gdb-7.10-branch] Fix mis-parsing of hex register numbers in 'T' stop replies sergiodj+buildbot
2015-08-18 18:12 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
2015-08-13 20:06 [binutils-gdb/gdb-7.10-branch] gdb.base/dso2dso.exp: Improve testcase documentation sergiodj+buildbot
2015-08-13 20:12 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
2015-08-12  9:20 [binutils-gdb/gdb-7.10-branch] [regression] Do not read from catchpoint/watchpoint locations' addresses when checking for a permanent breakpoint sergiodj+buildbot
2015-08-12  9:20 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
2015-08-06 17:47 [binutils-gdb/gdb-7.10-branch] PR python/17136 sergiodj+buildbot
2015-08-06 18:36 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
2015-08-06 16:01 [binutils-gdb/gdb-7.10-branch] gdbserver: move_out_of_jump_pad_callback misses switching current thread sergiodj+buildbot
2015-08-06 16:40 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
2015-08-06 14:49 [binutils-gdb/gdb-7.10-branch] Fix gdbserver --debug issues caught by Valgrind sergiodj+buildbot
2015-08-06 15:23 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
2015-08-06 12:22 [binutils-gdb/gdb-7.10-branch] gdbserver: Fix non-stop / fork / step-over issues sergiodj+buildbot
2015-08-06 12:24 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
2015-08-06 11:58 [binutils-gdb/gdb-7.10-branch] Linux gdbserver confused when event randomization picks process exit event sergiodj+buildbot
2015-08-06 11:58 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
2015-07-30 20:35 [binutils-gdb/gdb-7.10-branch] remote follow fork and spurious child stops in non-stop mode sergiodj+buildbot
2015-07-30 21:01 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
2015-07-30 19:38 [binutils-gdb/gdb-7.10-branch] PR threads/18600: Threads left stopped after fork+thread spawn sergiodj+buildbot
2015-07-30 19:49 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
2015-07-14  7:24 [binutils-gdb/gdb-7.10-branch] record: set stop_pc in "record goto" command sergiodj+buildbot
2015-07-14  7:30 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
2015-07-14  6:52 [binutils-gdb/gdb-7.10-branch] btrace: fix build fail with 32-bit BFD sergiodj+buildbot
2015-07-14  6:54 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot
2015-07-10 13:58 [binutils-gdb/gdb-7.10-branch] Fix testsuite regression by: Do not skip prologue for asm (.S) files sergiodj+buildbot
2015-07-10 14:31 ` Failures on Fedora-x86_64-m32, branch gdb-7.10-branch sergiodj+buildbot

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).