[binutils-gdb] Remove REPARSE condition to force hardware resource checking when updating watchpoints

[binutils-gdb] Remove REPARSE condition to force hardware resource checking when updating watchpoints

[Carl Love]

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

commit bc45f5366eaf4e93cfd675a07a8cc5bb5522b184
Author: Carl Love <cel@us.ibm.com>
Date:   Mon Oct 31 14:44:17 2022 -0400

    Remove REPARSE condition to force hardware resource checking when updating watchpoints
    
    Currently the resource checking is done if REPARSE is true.  The hardware
    watchpoint resource checking in update_watchpoint needs to be redone on
    each call to function update_watchpoints as the value chain may have
    changed.  The number of hardware registers needed for a watchpoint can
    change if the variable being watched changes.  This situation occurs in
    this test when watching variable **global_ptr_ptr.  Initially when the
    watch command is issued, only two addresses need to be watched as
    **global_ptr_ptr has not yet been initialized.  Once the value of
    **global_ptr_ptr is initialized the locations to be tracked increase to
    three addresses.  However, update_watchpoints is not called again with
    REPARSE set to 1 to force the resource checking to be redone.  When the
    test is run on Power 10, an internal gdb error occurs when the PowerPC
    routine tries to setup the three hardware watchpoint address since the hw
    only has two hardware watchpoint registers.  The error occurs because the
    resource checking was not redone in update_watchpoints after
    **global_ptr_ptr changed.
    
    The following descibes the situation in detail that occurs on Power 10 with
    gdb running on the binary for gdb.base/watchpoint.c.
    
    1 break func4
    2 run
    3 watch *global_ptr
    4 next      execute source code:   buf[0] = 3;
    5 next      execute source code:   global_ptr = buf;
    6 next      execute source code:   buf[0] = 7;
    7 delete 2  (delete watch *global_ptr)
    8 watch **global_ptr_ptr
    9 next       execute source code:   buf[1] = 5;
    10 next      global_ptr_ptr = &global_ptr;
    11 next      buf[0] = 9;
    
    In step 8, the the watch **global_ptr_prt command calls update_watchpoint
    in breakpoint.c with REPARSE set to 1.  The function update_watchpoint
    calls can_use_hardware_watchpoint to see if there are enough
    resources available to add the watchpoint since REPARSE is set to 1.  At
    this point, **global_ptr_ptr has not been initialized so only two addresses
    are watched.  The val_chain contains the address for **global_ptr_ptr and 0
    since **global_ptr_ptr has not been initialized.  The update_watchpoint
    updates the breakpoint list as follows:
    
      breakpoint 0
       loc 0: b->address = 0x100009c0
      breakpoint 1
       loc 1: b->address = 0x7ffff7f838a0
      breakpoint 2
       loc 2: b->address = 0x7ffff7b7fc54
      breakpoint 3
       loc 3: b->address = 0x7ffff7a5788c
      breakpoint 4
       loc 4: b->address = 0x0         <-- location pointed to by global_ptr_ptr
       loc 5: b->address = 0x100200b8  <-- global_ptr_ptr watchpoint
      breakpoint 5
       loc 6: b->address = 0x7ffff7b7fc54
    
    In step 10, the next command executes the source code
    global_ptr_ptr = &global_ptr.  This changes the set of locations to be
    watched for the watchpoint **global_ptr_prt.  The list of addresses for the
    breakpoint consist of the address for global_ptr_prt, global_ptr and buf.
    The breakpoint list gets updated by update_watchpoint as follows:
    
      breakpoint 0
       loc 0: b->address = 0x100009c0
      breakpoint 1
       loc 1: b->address = 0x7ffff7f838a0
      breakpoint 2
       loc 2: b->address = 0x7ffff7b7fc54
      breakpoint 3
       loc 3: b->address = 0x7ffff7a5788c
      breakpoint 4
       loc 4: b->address = 0x10020050           buf
       loc 5: b->address = 0x100200b0           watch *global_ptr
       loc 6: b->address = 0x100200b8           watch **global_ptr_ptr
      breakpoint 5
       loc 7: b->address = 0x7ffff7b7fc54
      breakpoint 6
    
    However, the hardware resource checking was not redone because
    update_breakpoint was called with REPARSE equal to  0.
    
    Step 11, execute the third next command.  The function
    ppc_linux_nat_target::low_prepare_to_resume() attempts a ptrace
    call to setup each of the three address for breakpoint 4.  The slot
    value returned for the third ptrace call is -1 indicating an error
    because there are only two hardware watchpoint registers available on
    Power 10.
    
    This patch removes just the statement "if (reparse)" in function
    update_watchpoint to force the resources to be rechecked on every call to
    the function.  This ensures that any changes to the val_chain resulting
    in needing more resources then available will be caught.
    
    The patch has been tested on Power 8, Power 10 and X86-64.  Note the patch
    has no effect on Power 9 since hardware watchpoint support is disabled on
    that processor.

Diff:
---
 gdb/breakpoint.c | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 30826032360..490708938ec 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -2123,10 +2123,9 @@ update_watchpoint (struct watchpoint *b, bool reparse)
 	}
 
       /* Change the type of breakpoint between hardware assisted or
-	 an ordinary watchpoint depending on the hardware support
-	 and free hardware slots.  REPARSE is set when the inferior
-	 is started.  */
-      if (reparse)
+	 an ordinary watchpoint depending on the hardware support and
+	 free hardware slots.  Recheck the number of free hardware slots
+	 as the value chain may have changed.  */
 	{
 	  int reg_cnt;
 	  enum bp_loc_type loc_type;