[PATCH v2 6/7] [gdb/tui] Handle section holes when forward disassembling

[Tom de Vries <tdevries@suse.de>]

Consider a hello world:
...
$ gcc hello.c -g
...
and gdb setup like this:
...
$ gdb -q a.out -ex "layout asm" -ex "disassemble _init"
...
which gives us the following asm window:
...
┌─────────────────────────────────────────────────────────────────────┐
│   0x401000 <_init>        endbr64                                   │
│   0x401004 <_init+4>      sub    $0x8,%rsp                          │
│   0x401008 <_init+8>      mov    0x2fd1(%rip),%rax        # 0x403fe0│
│   0x40100f <_init+15>     test   %rax,%rax                          │
│   0x401012 <_init+18>     je     0x401016 <_init+22>                │
│   0x401014 <_init+20>     call   *%rax                              │
│   0x401016 <_init+22>     add    $0x8,%rsp                          │
│   0x40101a <_init+26>     ret                                       │
│                                                                     │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘
...

We cannot scroll from the init section to the plt section, because there's a
section hole in between:
...
Disassembly of section .init:

0000000000401000 <_init>:
  ...
  40101a:       c3                      ret

Disassembly of section .plt:

0000000000401020 <puts@plt-0x10>:

  401020:       ff 35 ca 2f 00 00       push   0x2fca(%rip)
...
and the section hole is causing MEMORY_ERRORs in tui_disassemble.

However, that all changes if instead we do:
...
$ gdb -q a.out -ex start -ex "layout asm" -ex "disassemble _init"
...
and get:
...
┌─────────────────────────────────────────────────────────────────────┐
│   0x401000 <_init>        endbr64                                   │
│   0x401004 <_init+4>      sub    $0x8,%rsp                          │
│   0x401008 <_init+8>      mov    0x2fd1(%rip),%rax        # 0x403fe0│
│   0x40100f <_init+15>     test   %rax,%rax                          │
│   0x401012 <_init+18>     je     0x401016 <_init+22>                │
│   0x401014 <_init+20>     call   *%rax                              │
│   0x401016 <_init+22>     add    $0x8,%rsp                          │
│   0x40101a <_init+26>     ret                                       │
│   0x40101b                add    %al,(%rax)                         │
│   0x40101d                add    %al,(%rax)                         │
└─────────────────────────────────────────────────────────────────────┘
...

The section hole is no longer causing MEMORY_ERRORs, and we can scroll past it
into the plt section.

Achieve something similar in the initial setup (without start) by skipping
over the section hole, getting us:
...
┌─────────────────────────────────────────────────────────────────────┐
│   0x401000 <_init>        endbr64                                   │
│   0x401004 <_init+4>      sub    $0x8,%rsp                          │
│   0x401008 <_init+8>      mov    0x2fd1(%rip),%rax        # 0x403fe0│
│   0x40100f <_init+15>     test   %rax,%rax                          │
│   0x401012 <_init+18>     je     0x401016 <_init+22>                │
│   0x401014 <_init+20>     call   *%rax                              │
│   0x401016 <_init+22>     add    $0x8,%rsp                          │
│   0x40101a <_init+26>     ret                                       │
│   0x401020                push   0x2fca(%rip)        # 0x403ff0     │
│   0x401026                jmp    *0x2fcc(%rip)        # 0x403ff8    │
└─────────────────────────────────────────────────────────────────────┘
...
allowing to scroll (further) into the plt section.
---
 gdb/tui/tui-disasm.c | 51 +++++++++++++++++++++++++++++++-------------
 1 file changed, 36 insertions(+), 15 deletions(-)

diff --git a/gdb/tui/tui-disasm.c b/gdb/tui/tui-disasm.c
index 3e525000efd..d96048dc1de 100644
--- a/gdb/tui/tui-disasm.c
+++ b/gdb/tui/tui-disasm.c
@@ -112,22 +112,43 @@ tui_disassemble (struct gdbarch *gdbarch,
     {
       tui_asm_line tal;
 
-      /* Save the instruction address.  */
-      tal.addr = pc;
-
-      try
-	{
-	  pc += gdb_print_insn (gdbarch, pc, stream, NULL);
-	}
-      catch (const gdb_exception_error &except)
+      bool retry;
+      do
 	{
-	  /* If PC points to an invalid address then we'll catch a
-	     MEMORY_ERROR here, this should stop the disassembly, but
-	     otherwise is fine.  */
-	  if (except.error != MEMORY_ERROR)
-	    throw;
-	  return pc;
+	  retry = false;
+
+	  /* Save the instruction address.  */
+	  tal.addr = pc;
+
+	  try
+	    {
+	      pc += gdb_print_insn (gdbarch, pc, stream, NULL);
+	    }
+	  catch (const gdb_exception_error &except)
+	    {
+	      /* If PC points to an invalid address then we'll catch a
+		 MEMORY_ERROR here, this should stop the disassembly, but
+		 otherwise is fine.  */
+	      if (except.error != MEMORY_ERROR)
+		throw;
+
+	      struct obj_section *next;
+	      struct obj_section *section
+		= find_pc_section (pc, nullptr, &next);
+	      if (section == nullptr
+		  && next != nullptr
+		  && ((bfd_section_flags (next->the_bfd_section) & SEC_ALLOC)
+		      != 0))
+		{
+		  /* Skip over section hole.  */
+		  pc = next->addr ();
+		  retry = true;
+		}
+	      else
+		return pc;
+	    }
 	}
+      while (retry);
 
       /* If that's all we need, continue.  */
       if (addr_size == nullptr)
@@ -563,7 +584,7 @@ run_tests ()
 
       /* Check that tui_find_disassembly_address robustly handles the case of
 	 being passed a PC for which gdb_print_insn throws a MEMORY_ERROR.  */
-      SELF_CHECK (tui_find_disassembly_address (gdbarch, 0, 1) == 0);
+      tui_find_disassembly_address (gdbarch, 0, 1);
       SELF_CHECK (tui_find_disassembly_address (gdbarch, 0, -1) == 0);
     }
 }
-- 
2.51.0