This is the mail archive of the gdb-prs@sourceware.org mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[Bug breakpoints/7143] Watchpoint does not trigger when first set


https://sourceware.org/bugzilla/show_bug.cgi?id=7143

--- Comment #11 from cvs-commit at gcc dot gnu.org <cvs-commit at gcc dot gnu.org> ---
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "gdb and binutils".

The branch, master has been updated
       via  802e8e6d8465a0d05803a987ba1bb3237fb2fb70 (commit)
       via  932539e3ab93db990ef61c80bbf78a4f2fdcc60b (commit)
       via  4ff0d3d82d37a57507c147886ce9f9bfb7495b99 (commit)
      from  786dc51990a8d593a8d727735910ccf97752d928 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=802e8e6d8465a0d05803a987ba1bb3237fb2fb70

commit 802e8e6d8465a0d05803a987ba1bb3237fb2fb70
Author: Pedro Alves <palves@redhat.com>
Date:   Tue May 20 18:24:28 2014 +0100

    [GDBserver] Make Zx/zx packet handling idempotent.

    This patch fixes hardware breakpoint regressions exposed by my fix for
    "PR breakpoints/7143 - Watchpoint does not trigger when first set", at
    https://sourceware.org/ml/gdb-patches/2014-03/msg00167.html

    The testsuite caught them on Linux/x86_64, at least.  gdb.sum:

    gdb.sum:

     FAIL: gdb.base/hbreak2.exp: next over recursive call
     FAIL: gdb.base/hbreak2.exp: backtrace from factorial(5.1)
     FAIL: gdb.base/hbreak2.exp: continue until exit at recursive next test

    gdb.log:

     (gdb) next

     Program received signal SIGTRAP, Trace/breakpoint trap.
     factorial (value=4) at ../../../src/gdb/testsuite/gdb.base/break.c:113
     113       if (value > 1) {  /* set breakpoint 7 here */
     (gdb) FAIL: gdb.base/hbreak2.exp: next over recursive call

    Actually, that patch just exposed a latent issue to "breakpoints
    always-inserted off" mode, not really caused it.  After that patch,
    GDB no longer removes breakpoints at each internal event, thus making
    some scenarios behave like breakpoint always-inserted on.  The bug is
    easy to trigger with always-inserted on.

    The issue is that since the target-side breakpoint conditions support,
    if the stub/server supports evaluating breakpoint conditions on the
    target side, then GDB is sending duplicate Zx packets to the target
    without removing them before, and GDBserver is not really expecting
    that for Z packets other than Z0/z0.  E.g., with "set breakpoint
    always-inserted on" and "set debug remote 1":

     (gdb) b main
     Sending packet: $m410943,1#ff...Packet received: 48
     Breakpoint 4 at 0x410943: file ../../../src/gdb/gdbserver/server.c, line
3028.
     Sending packet: $Z0,410943,1#48...Packet received: OK
                     ^^^^^^^^^^^^
     (gdb) b main
     Note: breakpoint 4 also set at pc 0x410943.
     Sending packet: $m410943,1#ff...Packet received: 48
     Breakpoint 5 at 0x410943: file ../../../src/gdb/gdbserver/server.c, line
3028.
     Sending packet: $Z0,410943,1#48...Packet received: OK
                     ^^^^^^^^^^^^
     (gdb) b main
     Note: breakpoints 4 and 5 also set at pc 0x410943.
     Sending packet: $m410943,1#ff...Packet received: 48
     Breakpoint 6 at 0x410943: file ../../../src/gdb/gdbserver/server.c, line
3028.
     Sending packet: $Z0,410943,1#48...Packet received: OK
                     ^^^^^^^^^^^^
     (gdb) del
     Delete all breakpoints? (y or n) y
     Sending packet: $Z0,410943,1#48...Packet received: OK
     Sending packet: $Z0,410943,1#48...Packet received: OK
     Sending packet: $z0,410943,1#68...Packet received: OK

    And for Z1, similarly:

     (gdb) hbreak main
     Sending packet: $m410943,1#ff...Packet received: 48
     Hardware assisted breakpoint 4 at 0x410943: file
../../../src/gdb/gdbserver/server.c, line 3028.
     Sending packet: $Z1,410943,1#49...Packet received: OK
                     ^^^^^^^^^^^^
     Packet Z1 (hardware-breakpoint) is supported
     (gdb) hbreak main
     Note: breakpoint 4 also set at pc 0x410943.
     Sending packet: $m410943,1#ff...Packet received: 48
     Hardware assisted breakpoint 5 at 0x410943: file
../../../src/gdb/gdbserver/server.c, line 3028.
     Sending packet: $Z1,410943,1#49...Packet received: OK
                     ^^^^^^^^^^^^
     (gdb) hbreak main
     Note: breakpoints 4 and 5 also set at pc 0x410943.
     Sending packet: $m410943,1#ff...Packet received: 48
     Hardware assisted breakpoint 6 at 0x410943: file
../../../src/gdb/gdbserver/server.c, line 3028.
     Sending packet: $Z1,410943,1#49...Packet received: OK
                     ^^^^^^^^^^^^
     (gdb) del
     Delete all breakpoints? (y or n) y
     Sending packet: $Z1,410943,1#49...Packet received: OK
                     ^^^^^^^^^^^^
     Sending packet: $Z1,410943,1#49...Packet received: OK
                     ^^^^^^^^^^^^
     Sending packet: $z1,410943,1#69...Packet received: OK
                     ^^^^^^^^^^^^

    So GDB sent a bunch of Z1 packets, and then when finally removing the
    breakpoint, only one z1 packet was sent.  On the GDBserver side (with
    monitor set debug-hw-points 1), in the Z1 case, we see:

     $ ./gdbserver :9999 ./gdbserver
     Process ./gdbserver created; pid = 8629
     Listening on port 9999
     Remote debugging from host 127.0.0.1
     insert_watchpoint (addr=410943, len=1, type=instruction-execute):
         CONTROL (DR7): 00000101          STATUS (DR6): 00000000
         DR0: addr=0x410943, ref.count=1  DR1: addr=0x0, ref.count=0
         DR2: addr=0x0, ref.count=0  DR3: addr=0x0, ref.count=0
     insert_watchpoint (addr=410943, len=1, type=instruction-execute):
         CONTROL (DR7): 00000101          STATUS (DR6): 00000000
         DR0: addr=0x410943, ref.count=2  DR1: addr=0x0, ref.count=0
         DR2: addr=0x0, ref.count=0  DR3: addr=0x0, ref.count=0
     insert_watchpoint (addr=410943, len=1, type=instruction-execute):
         CONTROL (DR7): 00000101          STATUS (DR6): 00000000
         DR0: addr=0x410943, ref.count=3  DR1: addr=0x0, ref.count=0
         DR2: addr=0x0, ref.count=0  DR3: addr=0x0, ref.count=0
     insert_watchpoint (addr=410943, len=1, type=instruction-execute):
         CONTROL (DR7): 00000101          STATUS (DR6): 00000000
         DR0: addr=0x410943, ref.count=4  DR1: addr=0x0, ref.count=0
         DR2: addr=0x0, ref.count=0  DR3: addr=0x0, ref.count=0
     insert_watchpoint (addr=410943, len=1, type=instruction-execute):
         CONTROL (DR7): 00000101          STATUS (DR6): 00000000
         DR0: addr=0x410943, ref.count=5  DR1: addr=0x0, ref.count=0
         DR2: addr=0x0, ref.count=0  DR3: addr=0x0, ref.count=0
     remove_watchpoint (addr=410943, len=1, type=instruction-execute):
         CONTROL (DR7): 00000101          STATUS (DR6): 00000000
         DR0: addr=0x410943, ref.count=4  DR1: addr=0x0, ref.count=0
         DR2: addr=0x0, ref.count=0  DR3: addr=0x0, ref.count=0

    That's one insert_watchpoint call for each Z1 packet, and then one
    remove_watchpoint call for the z1 packet.  Notice how ref.count
    increased for each insert_watchpoint call, and then in the end, after
    GDB told GDBserver to forget about the hardware breakpoint, GDBserver
    ends with the the first debug register still with ref.count=4!  IOW,
    the hardware breakpoint is left armed on the target, while on the GDB
    end it's gone.  If the program happens to execute 0x410943 afterwards,
    then the CPU traps, GDBserver reports the trap to GDB, and GDB not
    having a breakpoint set at that address anymore, reports to the user a
    spurious SIGTRAP.

    This is exactly what is happening in the hbreak2.exp test, though in
    that case, it's a shared library event that triggers a
    breakpoint_re_set, when breakpoints are still inserted (because
    nowadays GDB doesn't remove breakpoints while handling internal
    events), and that recreates breakpoint locations, which likewise
    forces breakpoint reinsertion and Zx packet resends...

    That is a lot of bogus Zx duplication that should possibly be
    addressed on the GDB side.  GDB resends Zx packets because the way to
    change the target-side condition, is to resend the breakpoint to the
    server with the new condition.  (That's an option in the packet: e.g.,
    "Z1,410943,1;X3,220027" for "hbreak main if 0".  The packets in the
    examples above are shorter because the breakpoints don't have
    conditions attached).  GDB doesn't remove the breakpoint first before
    reinserting it because that'd be bad for non-stop, as it'd open a
    window where the inferior could miss the breakpoint.  The conditions
    actually haven't changed between the resends, but GDB isn't smart
    enough to realize that.

    (TBC, if the target doesn't support target-side conditions, then GDB
    doesn't trigger these resends (init_bp_location calls
    mark_breakpoint_location_modified, and that does nothing if condition
    evaluation is on the host side.  The resends are caused by the
    'loc->condition_changed = condition_modified.'  line.)

    But, even if GDB was made smarter, GDBserver should really still
    handle the resends anyway.  So target-side conditions also aren't
    really to blame.  The documentation of the Z/z packets says:

     "To avoid potential problems with duplicate packets, the operations
     should be implemented in an idempotent way."

    As such, we may want to fix GDB, but we should definitely fix
    GDBserver.  The fix is a prerequisite for target-side conditions on
    hardware breakpoints anyway (and while at it, on watchpoints too).

    GDBserver indeed already treats duplicate Z0 packets in an idempotent
    way.  mem-break.c has the concept of high-level and low-level
    breakpoints, somewhat similar to GDB's split of breakpoints vs
    breakpoint locations, and keeps track of multiple breakpoints
    referencing the same address/location, for the case of an internal
    GDBserver breakpoint or a tracepoint being set at the same address as
    a GDB breakpoint.  But, it only allows GDB to ever contribute one
    reference to a software breakpoint location.  IOW, if gdbserver sees a
    Z0 packet for the same address where it already had a GDB breakpoint
    set, then GDBserver won't create another high-level GDB breakpoint.

    However, mem-break.c only tracks GDB Z0 breakpoints.  The same logic
    should apply to all kinds of Zx packets.  Currently, gdbserver passes
    down each duplicate Zx (other than Z0) request directly to the
    target->insert_point routine.  The x86 watchpoint support itself
    refcounts watchpoint / hw breakpoint requests, to handle overlapping
    watchpoints, and save debug registers.  But that code doesn't (and
    really shouldn't) handle the duplicate requests, assuming that for
    each insert there will be a corresponding remove.

    So the fix is to generalize mem-break.c to track all kinds of Zx
    breakpoints, and filter out duplicates.  As mentioned, this ends up
    adding support for target-side conditions on hardware breakpoints and
    watchpoints too (though GDB itself doesn't support the latter yet).

    Probably the least obvious change in the patch is that it kind of
    turns the breakpoint insert/remove APIs inside out.  Before, the
    target methods were only called for GDB breakpoints.  The internal
    breakpoint set/delete methods inserted memory breakpoints directly
    bypassing the insert/remove target methods.  That's not good when the
    target should use a debug API to set software breakpoints, instead of
    relying on GDBserver patching memory with breakpoint instructions, as
    is the case of NTO.

    Now removal/insertion of all kinds of breakpoints/watchpoints, either
    internal, or from GDB, always go through the target methods.  The
    insert_point/remove_point methods no longer get passed a Z packet
    type, but an internal/raw breakpoint type.  They're also passed a
    pointer to the raw breakpoint itself (note that's still opaque outside
    mem-break.c), so that insert_memory_breakpoint /
    remove_memory_breakpoint have access to the breakpoint's shadow
    buffer.  I first tried passing down a new structure based on GDB's
    "struct bp_target_info" (actually with that name exactly), but then
    decided against it as unnecessary complication.

    As software/memory breakpoints work by poking at memory, when setting
    a GDB Z0 breakpoint (but not internal breakpoints, as those can assume
    the conditions are already right), we need to tell the target to
    prepare to access memory (which on Linux means stop threads).  If that
    operation fails, we need to return error to GDB.  Seeing an error, if
    this is the first breakpoint of that type that GDB tries to insert,
    GDB would then assume the breakpoint type is supported, but it may
    actually not be.  So we need to check whether the type is supported at
    all before preparing to access memory.  And to solve that, the patch
    adds a new target->supports_z_point_type method that is called before
    actually trying to insert the breakpoint.

    Other than that, hopefully the change is more or less obvious.

    New test added that exercises the hbreak2.exp regression in a more
    direct way, without relying on a breakpoint re-set happening before
    main is reached.

    Tested by building GDBserver for:

     aarch64-linux-gnu
     arm-linux-gnueabihf
     i686-pc-linux-gnu
     i686-w64-mingw32
     m68k-linux-gnu
     mips-linux-gnu
     mips-uclinux
     nios2-linux-gnu
     powerpc-linux-gnu
     sh-linux-gnu
     tilegx-unknown-linux-gnu
     x86_64-redhat-linux
     x86_64-w64-mingw32

    And also regression tested on x86_64 Fedora 20.

    gdb/gdbserver/
    2014-05-20  Pedro Alves  <palves@redhat.com>

        * linux-aarch64-low.c (aarch64_insert_point)
        (aarch64_remove_point): No longer check whether the type is
        supported here.  Adjust to new interface.
        (the_low_target): Install aarch64_supports_z_point_type as
        supports_z_point_type method.
        * linux-arm-low.c (raw_bkpt_type_to_arm_hwbp_type): New function.
        (arm_linux_hw_point_initialize): Take an enum raw_bkpt_type
        instead of a Z packet char.  Adjust.
        (arm_supports_z_point_type): New function.
        (arm_insert_point, arm_remove_point): Adjust to new interface.
        (the_low_target): Install arm_supports_z_point_type.
        * linux-crisv32-low.c (cris_supports_z_point_type): New function.
        (cris_insert_point, cris_remove_point): Adjust to new interface.
        Don't check whether the type is supported here.
        (the_low_target): Install cris_supports_z_point_type.
        * linux-low.c (linux_supports_z_point_type): New function.
        (linux_insert_point, linux_remove_point): Adjust to new interface.
        * linux-low.h (struct linux_target_ops) <insert_point,
        remove_point>: Take an enum raw_bkpt_type instead of a char.  Add
        raw_breakpoint pointer parameter.
        <supports_z_point_type>: New method.
        * linux-mips-low.c (mips_supports_z_point_type): New function.
        (mips_insert_point, mips_remove_point): Adjust to new interface.
        Use mips_supports_z_point_type.
        (the_low_target): Install mips_supports_z_point_type.
        * linux-ppc-low.c (the_low_target): Install NULL as
        supports_z_point_type method.
        * linux-s390-low.c (the_low_target): Install NULL as
        supports_z_point_type method.
        * linux-sparc-low.c (the_low_target): Install NULL as
        supports_z_point_type method.
        * linux-x86-low.c (x86_supports_z_point_type): New function.
        (x86_insert_point): Adjust to new insert_point interface.  Use
        insert_memory_breakpoint.  Adjust to new
        i386_low_insert_watchpoint interface.
        (x86_remove_point): Adjust to remove_point interface.  Use
        remove_memory_breakpoint.  Adjust to new
        i386_low_remove_watchpoint interface.
        (the_low_target): Install x86_supports_z_point_type.
        * lynx-low.c (lynx_target_ops): Install NULL as
        supports_z_point_type callback.
        * nto-low.c (nto_supports_z_point_type): New.
        (nto_insert_point, nto_remove_point): Adjust to new interface.
        (nto_target_ops): Install nto_supports_z_point_type.
        * mem-break.c: Adjust intro comment.
        (struct raw_breakpoint) <raw_type, size>: New fields.
        <inserted>: Update comment.
        <shlib_disabled>: Delete field.
        (enum bkpt_type) <gdb_breakpoint>: Delete value.
        <gdb_breakpoint_Z0, gdb_breakpoint_Z1, gdb_breakpoint_Z2,
        gdb_breakpoint_Z3, gdb_breakpoint_Z4>: New values.
        (raw_bkpt_type_to_target_hw_bp_type): New function.
        (find_enabled_raw_code_breakpoint_at): New function.
        (find_raw_breakpoint_at): New type and size parameters.  Use them.
        (insert_memory_breakpoint): New function, based off
        set_raw_breakpoint_at.
        (remove_memory_breakpoint): New function.
        (set_raw_breakpoint_at): Reimplement.
        (set_breakpoint): New, based on set_breakpoint_at.
        (set_breakpoint_at): Reimplement.
        (delete_raw_breakpoint): Go through the_target->remove_point
        instead of assuming memory breakpoints.
        (find_gdb_breakpoint_at): Delete.
        (Z_packet_to_bkpt_type, Z_packet_to_raw_bkpt_type): New functions.
        (find_gdb_breakpoint): New function.
        (set_gdb_breakpoint_at): Delete.
        (z_type_supported): New function.
        (set_gdb_breakpoint_1): New function, loosely based off
        set_gdb_breakpoint_at.
        (check_gdb_bp_preconditions, set_gdb_breakpoint): New functions.
        (delete_gdb_breakpoint_at): Delete.
        (delete_gdb_breakpoint_1): New function, loosely based off
        delete_gdb_breakpoint_at.
        (delete_gdb_breakpoint): New function.
        (clear_gdb_breakpoint_conditions): Rename to ...
        (clear_breakpoint_conditions): ... this.  Don't handle a NULL
        breakpoint.
        (add_condition_to_breakpoint): Make static.
        (add_breakpoint_condition): Take a struct breakpoint pointer
        instead of an address.  Adjust.
        (gdb_condition_true_at_breakpoint): Rename to ...
        (gdb_condition_true_at_breakpoint_z_type): ... this, and add
        z_type parameter.
        (gdb_condition_true_at_breakpoint): Reimplement.
        (add_breakpoint_commands): Take a struct breakpoint pointer
        instead of an address.  Adjust.
        (gdb_no_commands_at_breakpoint): Rename to ...
        (gdb_no_commands_at_breakpoint_z_type): ... this.  Add z_type
        parameter.  Return true if no breakpoint was found.  Change debug
        output.
        (gdb_no_commands_at_breakpoint): Reimplement.
        (run_breakpoint_commands): Rename to ...
        (run_breakpoint_commands_z_type): ... this.  Add z_type parameter,
        and change return type to boolean.
        (run_breakpoint_commands): New function.
        (gdb_breakpoint_here): Also check for Z1 breakpoints.
        (uninsert_raw_breakpoint): Don't try to reinsert a disabled
        breakpoint.  Go through the_target->remove_point instead of
        assuming memory breakpoint.
        (uninsert_breakpoints_at, uninsert_all_breakpoints): Uninsert
        software and hardware breakpoints.
        (reinsert_raw_breakpoint): Go through the_target->insert_point
        instead of assuming memory breakpoint.
        (reinsert_breakpoints_at, reinsert_all_breakpoints): Reinsert
        software and hardware breakpoints.
        (check_breakpoints, breakpoint_here, breakpoint_inserted_here):
        Check both software and hardware breakpoints.
        (validate_inserted_breakpoint): Assert the breakpoint is a
        software breakpoint.  Set the inserted flag to -1 instead of
        setting shlib_disabled.
        (delete_disabled_breakpoints): Adjust.
        (validate_breakpoints): Only validate software breakpoints.
        Adjust to inserted flag change.
        (check_mem_read, check_mem_write): Skip breakpoint types other
        than software breakpoints.  Adjust to inserted flag change.
        * mem-break.h (enum raw_bkpt_type): New enum.
        (raw_breakpoint, struct process_info): Forward declare.
        (Z_packet_to_target_hw_bp_type): Delete declaration.
        (raw_bkpt_type_to_target_hw_bp_type, Z_packet_to_raw_bkpt_type)
        (set_gdb_breakpoint, delete_gdb_breakpoint)
        (clear_breakpoint_conditions): New declarations.
        (set_gdb_breakpoint_at, clear_gdb_breakpoint_conditions): Delete.
        (breakpoint_inserted_here): Update comment.
        (add_breakpoint_condition, add_breakpoint_commands): Replace
        address parameter with a breakpoint pointer parameter.
        (gdb_breakpoint_here): Update comment.
        (delete_gdb_breakpoint_at): Delete.
        (insert_memory_breakpoint, remove_memory_breakpoint): Declare.
        * server.c (process_point_options): Take a struct breakpoint
        pointer instead of an address.  Adjust.
        (process_serial_event) <Z/z packets>: Use set_gdb_breakpoint and
        delete_gdb_breakpoint.
        * spu-low.c (spu_target_ops): Install NULL as
        supports_z_point_type method.
        * target.h: Include mem-break.h.
        (struct target_ops) <prepare_to_access_memory>: Update comment.
        <supports_z_point_type>: New field.
        <insert_point, remove_point>: Take an enum raw_bkpt_type argument
        instead of a char.  Also take a raw breakpoint pointer.
        * win32-arm-low.c (the_low_target): Install NULL as
        supports_z_point_type.
        * win32-i386-low.c (i386_supports_z_point_type): New function.
        (i386_insert_point, i386_remove_point): Adjust to new interface.
        (the_low_target): Install i386_supports_z_point_type.
        * win32-low.c (win32_supports_z_point_type): New function.
        (win32_insert_point, win32_remove_point): Adjust to new interface.
        (win32_target_ops): Install win32_supports_z_point_type.
        * win32-low.h (struct win32_target_ops):
        <supports_z_point_type>: New method.
        <insert_point, remove_point>: Take an enum raw_bkpt_type argument
        instead of a char.  Also take a raw breakpoint pointer.

    gdb/testsuite/
    2014-05-20  Pedro Alves  <palves@redhat.com>

        * gdb.base/break-idempotent.c: New file.
        * gdb.base/break-idempotent.exp: New file.

https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=932539e3ab93db990ef61c80bbf78a4f2fdcc60b

commit 932539e3ab93db990ef61c80bbf78a4f2fdcc60b
Author: Pedro Alves <palves@redhat.com>
Date:   Tue May 20 18:24:27 2014 +0100

    [GDBserver] Move Z packet defines and type convertion routines to shared
code.

    The Aarch64, MIPS and x86 Linux backends all have Z packet number
    defines and corresponding protocol number to internal type convertion
    routines.  Factor them all out to gdbserver's core code, so we only
    have one shared copy.

    Tested on x86_64 Fedora 20, and also cross built for aarch64-linux-gnu
    and mips-linux-gnu.

    gdb/gdbserver/
    2014-05-20  Pedro Alves  <palves@redhat.com>

        * mem-break.h: Include break-common.h.
        (Z_PACKET_SW_BP, Z_PACKET_HW_BP, Z_PACKET_WRITE_WP)
        (Z_PACKET_READ_WP, Z_PACKET_ACCESS_WP): New defines.
        (Z_packet_to_target_hw_bp_type): New declaration.
        * mem-break.c (Z_packet_to_target_hw_bp_type): New function.
        * i386-low.c (Z_PACKET_HW_BP, Z_PACKET_WRITE_WP, Z_PACKET_READ_WP)
        (Z_PACKET_ACCESS_WP): Delete macros.
        (Z_packet_to_hw_type): Delete function.
        * i386-low.h: Don't include break-common.h here.
        (Z_packet_to_hw_type): Delete declaration.
        * linux-x86-low.c (x86_insert_point, x86_insert_point): Call
        Z_packet_to_target_hw_bp_type instead of Z_packet_to_hw_type.
        * win32-i386-low.c (i386_insert_point, i386_remove_point): Call
        Z_packet_to_target_hw_bp_type instead of Z_packet_to_hw_type.
        * linux-aarch64-low.c: Don't include break-common.h here.
        (Z_PACKET_SW_BP, Z_PACKET_HW_BP, Z_PACKET_WRITE_WP)
        (Z_PACKET_READ_WP, Z_PACKET_ACCESS_WP): Delete macros.
        (Z_packet_to_target_hw_bp_type): Delete function.
        * linux-mips-low.c (rsp_bp_type_to_target_hw_bp_type): Delete
        function.
        (mips_insert_point, mips_remove_point): Use
        Z_packet_to_target_hw_bp_type.

https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=4ff0d3d82d37a57507c147886ce9f9bfb7495b99

commit 4ff0d3d82d37a57507c147886ce9f9bfb7495b99
Author: Pedro Alves <palves@redhat.com>
Date:   Tue May 20 18:24:27 2014 +0100

    [GDBserver][AArch64] Make watchpoint support use target_hw_bp_type.

    This makes linux-aarch64-low.c use target_hw_bp_type, like gdb's
    aarch64-linux-nat.c.  The original motivation is decoupling
    insert_point/remove_point from Z packet numbers, but I think making
    the files a little bit more similar is a good thing on its own right.
    Ideally we'd merge these files even...  The
    aarch64_point_encode_ctrl_reg change is taken straight from GDB's
    copy.

    I confirmed with a cross compiler that this builds, but it's otherwise
    untested.

    gdb/gdbserver/
    2014-05-20  Pedro Alves  <palves@redhat.com>

        * linux-aarch64-low.c: Include break-common.h.
        (enum target_point_type): Delete.
        (Z_packet_to_point_type): Rename to ...
        (Z_packet_to_target_hw_bp_type): ... this, and return a
        target_hw_bp_type instead.
        (aarch64_show_debug_reg_state): Take an enum target_hw_bp_type
        instead of an enum target_point_type.
        (aarch64_point_encode_ctrl_reg): Likewise.  Compute type mask from
        breakpoint type.
        (aarch64_dr_state_insert_one_point)
        (aarch64_dr_state_remove_one_point, aarch64_handle_breakpoint)
        (aarch64_handle_aligned_watchpoint)
        (aarch64_handle_unaligned_watchpoint, aarch64_handle_watchpoint):
        Take an enum target_hw_bp_type instead of an enum
        target_point_type.
        (aarch64_supports_z_point_type): New function.
        (aarch64_insert_point, aarch64_remove_point): Use it.  Adjust to
        use Z_packet_to_target_hw_bp_type.

-----------------------------------------------------------------------

Summary of changes:
 gdb/gdbserver/ChangeLog                     |  200 ++++++++
 gdb/gdbserver/i386-low.c                    |   23 -
 gdb/gdbserver/i386-low.h                    |    6 -
 gdb/gdbserver/linux-aarch64-low.c           |  121 ++---
 gdb/gdbserver/linux-arm-low.c               |   73 ++-
 gdb/gdbserver/linux-crisv32-low.c           |   63 +--
 gdb/gdbserver/linux-low.c                   |   18 +-
 gdb/gdbserver/linux-low.h                   |    8 +-
 gdb/gdbserver/linux-mips-low.c              |   59 +--
 gdb/gdbserver/linux-ppc-low.c               |    1 +
 gdb/gdbserver/linux-s390-low.c              |    1 +
 gdb/gdbserver/linux-sparc-low.c             |    1 +
 gdb/gdbserver/linux-x86-low.c               |   76 ++--
 gdb/gdbserver/lynx-low.c                    |    1 +
 gdb/gdbserver/mem-break.c                   |  732 +++++++++++++++++++++------
 gdb/gdbserver/mem-break.h                   |   86 +++-
 gdb/gdbserver/nto-low.c                     |   49 ++-
 gdb/gdbserver/server.c                      |   57 +--
 gdb/gdbserver/spu-low.c                     |    1 +
 gdb/gdbserver/target.h                      |   23 +-
 gdb/gdbserver/win32-arm-low.c               |    1 +
 gdb/gdbserver/win32-i386-low.c              |   42 +-
 gdb/gdbserver/win32-low.c                   |   18 +-
 gdb/gdbserver/win32-low.h                   |    7 +-
 gdb/testsuite/ChangeLog                     |    5 +
 gdb/testsuite/gdb.base/break-idempotent.c   |   52 ++
 gdb/testsuite/gdb.base/break-idempotent.exp |  181 +++++++
 27 files changed, 1409 insertions(+), 496 deletions(-)
 create mode 100644 gdb/testsuite/gdb.base/break-idempotent.c
 create mode 100644 gdb/testsuite/gdb.base/break-idempotent.exp

-- 
You are receiving this mail because:
You are on the CC list for the bug.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]