[binutils-gdb] gdb: protect some 'regcache_read_pc' calls

[binutils-gdb] gdb: protect some 'regcache_read_pc' calls

[Tankut Baris Aktemur]

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

commit fc75c28ba1ea7353fb6e1e5904c5703a48504b67
Author: Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Date:   Thu May 14 13:59:53 2020 +0200

    gdb: protect some 'regcache_read_pc' calls
    
    It possible that a thread whose PC we attempt to read is already dead.
    In this case, 'regcache_read_pc' errors out.  This impacts the
    "proceed" execution flow, where GDB quits early before having a chance
    to check if there exists a pending event.  To remedy, keep going with
    a 0 value for the PC if 'regcache_read_pc' fails.  Because the value
    of PC before resuming a thread is mostly used for storing and checking
    the next time the thread stops, this tolerance is expected to be
    harmless for a dead thread/process.
    
    gdb/ChangeLog:
    2020-05-14  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>
    
            * regcache.c (regcache_read_pc_protected): New function
            implementation that returns 0 if the PC cannot read via
            'regcache_read_pc'.
            * infrun.c (proceed): Call 'regcache_read_pc_protected'
            instead of 'regcache_read_pc'.
            (keep_going_pass_signal): Ditto.
    
    gdbsupport/ChangeLog:
    2020-05-14  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>
    
            * common-regcache.h (regcache_read_pc_protected): New function
            declaration.

Diff:
---
 gdb/ChangeLog                |  9 +++++++++
 gdb/infrun.c                 |  7 ++++---
 gdb/regcache.c               | 18 ++++++++++++++++++
 gdbsupport/ChangeLog         |  5 +++++
 gdbsupport/common-regcache.h |  5 +++++
 5 files changed, 41 insertions(+), 3 deletions(-)

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 4f948d57a04..462884ce41e 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,12 @@
+2020-05-14  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>
+
+	* regcache.c (regcache_read_pc_protected): New function
+	implementation that returns 0 if the PC cannot read via
+	'regcache_read_pc'.
+	* infrun.c (proceed): Call 'regcache_read_pc_protected'
+	instead of 'regcache_read_pc'.
+	(keep_going_pass_signal): Ditto.
+
 2020-05-13  Tom Tromey  <tromey@adacore.com>
 
 	* ada-lang.c (align_value): Remove.
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 3c6b201a9fc..5e01336ab09 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -2995,7 +2995,8 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
   gdbarch = regcache->arch ();
   const address_space *aspace = regcache->aspace ();
 
-  pc = regcache_read_pc (regcache);
+  pc = regcache_read_pc_protected (regcache);
+
   thread_info *cur_thr = inferior_thread ();
 
   /* Fill in with reasonable starting values.  */
@@ -3122,7 +3123,7 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
      advanced.  Must do this before resuming any thread, as in
      all-stop/remote, once we resume we can't send any other packet
      until the target stops again.  */
-  cur_thr->prev_pc = regcache_read_pc (regcache);
+  cur_thr->prev_pc = regcache_read_pc_protected (regcache);
 
   {
     scoped_restore save_defer_tc = make_scoped_defer_target_commit_resume ();
@@ -7929,7 +7930,7 @@ keep_going_pass_signal (struct execution_control_state *ecs)
 
   /* Save the pc before execution, to compare with pc after stop.  */
   ecs->event_thread->prev_pc
-    = regcache_read_pc (get_thread_regcache (ecs->event_thread));
+    = regcache_read_pc_protected (get_thread_regcache (ecs->event_thread));
 
   if (ecs->event_thread->control.trap_expected)
     {
diff --git a/gdb/regcache.c b/gdb/regcache.c
index 4f079c91a7f..1be794520ec 100644
--- a/gdb/regcache.c
+++ b/gdb/regcache.c
@@ -1220,6 +1220,24 @@ regcache_read_pc (struct regcache *regcache)
   return pc_val;
 }
 
+/* See gdbsupport/common-regcache.h.  */
+
+CORE_ADDR
+regcache_read_pc_protected (regcache *regcache)
+{
+  CORE_ADDR pc;
+  try
+    {
+      pc = regcache_read_pc (regcache);
+    }
+  catch (const gdb_exception_error &ex)
+    {
+      pc = 0;
+    }
+
+  return pc;
+}
+
 void
 regcache_write_pc (struct regcache *regcache, CORE_ADDR pc)
 {
diff --git a/gdbsupport/ChangeLog b/gdbsupport/ChangeLog
index 194811e65cb..636a3d34e14 100644
--- a/gdbsupport/ChangeLog
+++ b/gdbsupport/ChangeLog
@@ -1,3 +1,8 @@
+2020-05-14  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>
+
+	* common-regcache.h (regcache_read_pc_protected): New function
+	declaration.
+
 2020-04-28  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>
 
 	* gdb-sigmask.h: Fix typo (pthead_sigmask -> pthread_sigmask).
diff --git a/gdbsupport/common-regcache.h b/gdbsupport/common-regcache.h
index 18446ff8416..650536e8a88 100644
--- a/gdbsupport/common-regcache.h
+++ b/gdbsupport/common-regcache.h
@@ -56,6 +56,11 @@ extern int regcache_register_size (const struct regcache *regcache, int n);
 
 extern CORE_ADDR regcache_read_pc (struct regcache *regcache);
 
+/* Read the PC register.  If PC cannot be read, return 0.
+   This is a wrapper around 'regcache_read_pc'.  */
+
+extern CORE_ADDR regcache_read_pc_protected (regcache *regcache);
+
 /* Read a raw register into a unsigned integer.  */
 extern enum register_status regcache_raw_read_unsigned
   (struct regcache *regcache, int regnum, ULONGEST *val);