[PATCHv2 2/3] gdb: introduce program_space::get_entry_point_info function

[Andrew Burgess <aburgess@redhat.com>]

I noticed that when debugging a dynamically linked executable, if I
started the inferior with 'starti' then used 'bt' I would see some
bogus frames:

  (gdb) starti
  Starting program: /tmp/hello

  Program stopped.
  0x00007ffff7fd3110 in _start () from /lib64/ld-linux-x86-64.so.2
  (gdb) bt
  #0  0x00007ffff7fd3110 in _start () from /lib64/ld-linux-x86-64.so.2
  #1  0x0000000000000001 in ?? ()
  #2  0x00007fffffffac13 in ?? ()
  #3  0x0000000000000000 in ?? ()
  (gdb)

This surprised me as 'backtrace past-entry' was off:

  (gdb) show backtrace past-entry
  Whether backtraces should continue past the entry point of a program is off.

I was expecting GDB to stop the backtrace at the inferior's entry
address.

Frame unwinding starts in get_prev_frame, and in here we find this
block:

  if (this_frame->level >= 0
      && get_frame_type (this_frame) == NORMAL_FRAME
      && !user_set_backtrace_options.backtrace_past_entry
      && frame_pc.has_value ()
      && inside_entry_func (this_frame))
    {
      frame_debug_got_null_frame (this_frame, "inside entry func");
      return NULL;
    }

Which uses inside_entry_func to terminate the backtrace when we reach
the entry frame.  The inside_entry_func function calls
current_program_space->exec_entry_point_address_if_available and uses
the result to figure out if we are in the entry frame.

And here the problem becomes obvious, we are only checking if we are
in the "entry frame" for the main executable, not for the inferior as
a whole.  And indeed, if I compile the same test program as a static
binary, where there will be no run-time linker, and the entry point of
the executable is the entry point for the inferior, then the 'bt'
problem I saw above goes away.

This suggests, I think, that we need to track two different entry
addresses, the entry address for the executable file, and the entry
address for the entire inferior.  Then, for dynamically linked
executables, these two addresses can be different, the former will
still be the same address within the main executable file, while the
latter will be the address of the entry point within the run-time
linker.

If we had this information then we could extend inside_entry_func to
check both addresses, and the 'bt' problem seen above will be
resolved.

To make this information available I added a new solib_ops method,
solib_ops::inferior_entry_point_address, for svr4 targets this figures
out if the main executable is dynamically linked, and if it is, finds
the run-time linker and uses that to compute the entry address.

I then added program_space::get_entry_point_info, which returns a
struct containing the two entry point addresses, one comes from the
new solib_ops method, and one comes from the existing method
program_space::exec_entry_point_address_if_available.

With the infrastructure in place I can then update inside_entry_func
to check against both entry addresses.

To aid in debugging GDB, I added a new maintenance command:

  maintenance info entry-address

which just calls program_space::get_entry_point_info and then prints
the two addresses.  I left this as a maintenance command as I don't
see much user utility in this right now, but it made it easier for me
to see what GDB was doing, so I left the command in this commit.
---
 gdb/NEWS                                   |   7 +
 gdb/doc/gdb.texinfo                        |  14 ++
 gdb/frame.c                                |  10 +-
 gdb/progspace.c                            |  60 ++++++++
 gdb/progspace.h                            |  48 +++++++
 gdb/solib-svr4.c                           | 102 ++++++++++++++
 gdb/solib-svr4.h                           |   1 +
 gdb/solib.h                                |  14 ++
 gdb/testsuite/gdb.base/bt-after-starti.exp | 153 +++++++++++++++++++++
 9 files changed, 404 insertions(+), 5 deletions(-)
 create mode 100644 gdb/testsuite/gdb.base/bt-after-starti.exp

diff --git a/gdb/NEWS b/gdb/NEWS
index d5214a98a57..99c9fb6999c 100644
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -146,6 +146,13 @@ disable skip
   These are new aliases for 'skip delete', 'skip enable', and 'skip
   disable' respectively.
 
+maint info entry-address
+  Display the inferior and main executable entry addresses for the
+  current inferior.  The inferior entry address is the address of the
+  first instruction in the inferior that was executed.  The main
+  executable entry address is the address of the first instruction in
+  the main executable that was executed.
+
 * MI changes
 
 ** The "-trace-save" command no longer supports the "-ctf" flag.
diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo
index a698b2b8451..dd6cfd04011 100644
--- a/gdb/doc/gdb.texinfo
+++ b/gdb/doc/gdb.texinfo
@@ -43212,6 +43212,20 @@ Maintenance Commands
 Ignoring SystemTap probe libc longjmp in /lib64/libc.so.6.^M
 Ignoring SystemTap probe libc longjmp in /lib64/libc.so.6.^M
 @end smallexample
+
+@kindex maint info entry-address
+@item maint info entry-address
+Display the entry addresses for the currently selected inferior.  Two
+addresses are displayed, the first is the address of the first
+instruction in the inferior, and the second is for the first
+instruction in the main executable, see @kbd{file} in @ref{Files,
+,Commands to Specify Files}.
+
+For statically linked inferiors, these addresses will usually be the
+same, but for dynamically linked executables these addresses can be
+different, with the inferior's entry address being an address within
+the run-time linker, while the main executable's entry address will
+always be an address within the executable file.
 @end table
 
 The following command is useful for non-interactive invocations of
diff --git a/gdb/frame.c b/gdb/frame.c
index f5a6a8919df..3920d8d03f7 100644
--- a/gdb/frame.c
+++ b/gdb/frame.c
@@ -2699,12 +2699,12 @@ inside_main_func (const frame_info_ptr &this_frame)
 static bool
 inside_entry_func (const frame_info_ptr &this_frame)
 {
-  std::optional<CORE_ADDR> entry_point
-    = current_program_space->exec_entry_point_address_if_available ();
-  if (!entry_point.has_value ())
-    return false;
+  const program_space::entry_point_info &ep_info
+    = current_program_space->get_entry_point_info ();
 
-  return get_frame_func (this_frame) == *entry_point;
+  CORE_ADDR frame_func_addr = get_frame_func (this_frame);
+  return (ep_info.exec_entry_address () == frame_func_addr
+	  || ep_info.inferior_entry_address () == frame_func_addr);
 }
 
 /* Return a structure containing various interesting information about
diff --git a/gdb/progspace.c b/gdb/progspace.c
index 0e8516f4640..8a20e8d770a 100644
--- a/gdb/progspace.c
+++ b/gdb/progspace.c
@@ -26,6 +26,7 @@
 #include <algorithm>
 #include "cli/cli-style.h"
 #include "observable.h"
+#include "arch-utils.h"
 
 /* The last program space number assigned.  */
 static int last_program_space_num = 0;
@@ -288,6 +289,55 @@ program_space::exec_entry_point_address () const
 
 /* See progspace.h.  */
 
+program_space::entry_point_info
+program_space::get_entry_point_info () const
+{
+  std::optional<CORE_ADDR> exec_entry_address
+    = this->exec_entry_point_address_if_available ();
+
+  std::optional<CORE_ADDR> inferior_entry_address;
+  if (m_solib_ops != nullptr)
+    inferior_entry_address = m_solib_ops->inferior_entry_point_address ();
+
+  return entry_point_info (std::move (inferior_entry_address),
+			   std::move (exec_entry_address));
+}
+
+/* Implement the 'maint info entry-address' command.  */
+
+static void
+maintenance_info_entry_address (const char *args, int from_tty)
+{
+  if (args != nullptr && *args != '\0')
+    error (_("unknown argument: %s"), args);
+
+  struct gdbarch *gdbarch = get_current_arch ();
+
+  program_space::entry_point_info ep_info
+    = current_program_space->get_entry_point_info ();
+
+  /* Display a single entry address ADDR with TITLE as a description.  */
+  auto display_entry_address
+    = [&gdbarch] (const char *title,
+		  const std::optional<CORE_ADDR> &addr) -> void
+  {
+    gdb_puts (title);
+    if (addr.has_value ())
+      fputs_styled (paddress (gdbarch, addr.value ()),
+		    address_style.style (), gdb_stdout);
+    else
+      fputs_styled ("<unknown>", metadata_style.style (), gdb_stdout);
+    gdb_puts ("\n");
+  };
+
+  display_entry_address (_("Inferior entry address: "),
+			 ep_info.inferior_entry_address ());
+  display_entry_address (_("Executable entry address: "),
+			 ep_info.exec_entry_address ());
+}
+
+/* See progspace.h.  */
+
 bool
 program_space::has_partial_symbols ()
 {
@@ -498,6 +548,16 @@ initialize_progspace ()
 	   _("Info about currently known program spaces."),
 	   &maintenanceinfolist);
 
+  add_cmd ("entry-address", class_maintenance,
+	   maintenance_info_entry_address,
+	   _("Information about the current inferior's entry addresses.\n\
+Display the address of the first instruction executed within the\n\
+inferior, and the first instruction executed within the main executable.\n\
+The entry address of the whole inferior will be <unknown> prior to the\n\
+inferior starting, and either or both addresses can be <unknown> if\n\
+GDB is unable to find the required information."),
+	   &maintenanceinfolist);
+
   /* There's always one program space.  Note that this function isn't
      an automatic _initialize_foo function, since other
      _initialize_foo routines may need to install their per-pspace
diff --git a/gdb/progspace.h b/gdb/progspace.h
index 1ae1e42f3bb..d75379fe621 100644
--- a/gdb/progspace.h
+++ b/gdb/progspace.h
@@ -323,6 +323,54 @@ struct program_space
     return m_target_sections;
   }
 
+  /* Class for tracking two possible entry points that an inferior might
+     have, the entry point for the entire inferior, and the entry point
+     within the main executable.  */
+  struct entry_point_info
+  {
+    explicit entry_point_info (std::optional<CORE_ADDR> inferior_entry_address,
+			       std::optional<CORE_ADDR> exec_entry_address)
+      : m_inferior_entry_address (std::move (inferior_entry_address)),
+	m_exec_entry_address (std::move (exec_entry_address))
+    { /* Nothing.  */ }
+
+    DISABLE_COPY_AND_ASSIGN (entry_point_info);
+
+    /* The entry address within the inferior as a whole.  See the member
+       variable definition below for more details.  */
+    const std::optional<CORE_ADDR> &inferior_entry_address () const
+    {
+      return m_inferior_entry_address;
+    }
+
+    /* The entry address within the main executable.  See the member
+       variable definition below for more details.  */
+    const std::optional<CORE_ADDR> &exec_entry_address () const
+    {
+      return m_exec_entry_address;
+    }
+
+  private:
+    /* The entry address within the inferior.  This can be outside of the
+       main executable, e.g. for dynamically linked executables this could
+       be the entry address for the run-time linker.  For statically linked
+       executables this will be the entry address of the main executable.
+       This can be empty if GDB doesn't know how to figure out the correct
+       entry address for any reason.  */
+    std::optional<CORE_ADDR> m_inferior_entry_address;
+
+    /* The entry address within the main executable.  This can be empty if
+       the main executable is not set yet, or GDB doesn't have an objfile
+       associated with the main executable, e.g. in some attach, or remote
+       debug cases.  */
+    std::optional<CORE_ADDR> m_exec_entry_address;
+  };
+
+  /* Return information about the entry point in the main executable, and
+     the entry point for the inferior, which might be different from the
+     main executable.  */
+  entry_point_info get_entry_point_info () const;
+
   /* If there is a valid and known entry point in the main executable of
      this program space, return it.  Otherwise return an empty optional.  */
   std::optional<CORE_ADDR> exec_entry_point_address_if_available () const;
diff --git a/gdb/solib-svr4.c b/gdb/solib-svr4.c
index 8e3de4d3ea1..fa49670ece9 100644
--- a/gdb/solib-svr4.c
+++ b/gdb/solib-svr4.c
@@ -3777,6 +3777,108 @@ svr4_solib_ops::get_solibs_in_ns (int nsid) const
   return ns_solibs;
 }
 
+/* See solib.h.  */
+
+std::optional<CORE_ADDR>
+svr4_solib_ops::inferior_entry_point_address () const
+{
+  std::optional<gdb::byte_vector> interp_name_holder
+    = svr4_find_program_interpreter ();
+
+  /* No interpreter means this is a static executable.  Ask the
+     program_space for the entry address within the main executable.  */
+  if (!interp_name_holder.has_value ())
+    return m_pspace->exec_entry_point_address_if_available ();
+
+  /* If we can find a solib that matches the interpreter name then we can
+     use that to find the actual entry address of the inferior.  */
+  const solib *interp_solib = nullptr;
+  const char *interp_name = (const char *) interp_name_holder->data ();
+  for (const solib &so : m_pspace->solibs ())
+    {
+      if (svr4_same_name (interp_name, so.original_name.c_str ()))
+	{
+	  interp_solib = &so;
+
+	  const objfile *objfile = so.objfile;
+	  if (objfile != nullptr && objfile->per_bfd->ei.entry_point_p)
+	    {
+	      const entry_info &ei = objfile->per_bfd->ei;
+	      return (ei.entry_point
+		      + objfile->section_offsets[ei.the_bfd_section_index]);
+	    }
+	}
+    }
+
+  gdb_bfd_ref_ptr tmp_bfd;
+  target_ops_up tmp_bfd_target;
+  try
+    {
+      tmp_bfd = solib_bfd_open (interp_name);
+
+      /* Failed to open the interpreter BFD.  */
+      if (tmp_bfd == nullptr)
+	return {};
+
+      tmp_bfd_target = target_bfd_reopen (tmp_bfd);
+    }
+  catch (const gdb_exception &ex)
+    {
+      return {};
+    }
+
+  CORE_ADDR entry_addr
+    = exec_entry_point (tmp_bfd.get (), tmp_bfd_target.get ());
+
+  /* We found the solib for the interpreter, but we don't have a
+     corresponding objfile, or the objfile doesn't have entry point
+     information.  Maybe symbols haven't been loaded yet?  */
+  if (interp_solib != nullptr)
+    {
+      gdb_assert (interp_solib->objfile == nullptr
+		  || !interp_solib->objfile->per_bfd->ei.entry_point_p);
+
+      CORE_ADDR load_addr
+	= this->lm_addr_check (*interp_solib, tmp_bfd.get ());
+
+      return load_addr + entry_addr;
+    }
+
+  /* We could not find a solib corresponding to the interpreter, this might
+     mean that the name didn't match for some reason, or maybe GDB has
+     failed to create a solib due to some other issue reading the solib
+     list from the inferior.
+
+     If we got here we have managed to open the expected interpreter on
+     disk though, so we can try using the AT_BASE value.  */
+  CORE_ADDR load_addr;
+  if (target_auxv_search (AT_BASE, &load_addr) > 0)
+    {
+      int addr_bit = gdbarch_addr_bit (current_inferior ()->arch ());
+
+      /* Ensure LOAD_ADDR has proper sign in its possible upper bits so
+	 that `+ load_addr' will overflow CORE_ADDR width not creating
+	 invalid addresses like 0x101234567 for 32bit inferiors on 64bit
+	 GDB.  */
+      if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
+	{
+	  CORE_ADDR space_size = (CORE_ADDR) 1 << addr_bit;
+
+	  gdb_assert (load_addr < space_size);
+
+	  /* ENTRY_ADDR exceeding SPACE_SIZE would be for prelinked
+	     64bit ld.so with 32bit executable, it should not happen.  */
+	  if (entry_addr < space_size
+	      && entry_addr + load_addr >= space_size)
+	    load_addr -= space_size;
+	}
+
+      return load_addr + entry_addr;
+    }
+
+  return {};
+}
+
 INIT_GDB_FILE (svr4_solib)
 {
   gdb::observers::free_objfile.attach (svr4_free_objfile_observer,
diff --git a/gdb/solib-svr4.h b/gdb/solib-svr4.h
index 3078a092778..f76f350d951 100644
--- a/gdb/solib-svr4.h
+++ b/gdb/solib-svr4.h
@@ -115,6 +115,7 @@ struct svr4_solib_ops : public solib_ops
   void iterate_over_objfiles_in_search_order
     (iterate_over_objfiles_in_search_order_cb_ftype cb,
      objfile *current_objfile) const override;
+  std::optional<CORE_ADDR> inferior_entry_point_address () const override;
 
   /* Return the appropriate link map offsets table for the architecture.  */
   virtual link_map_offsets *fetch_link_map_offsets () const = 0;
diff --git a/gdb/solib.h b/gdb/solib.h
index 9e6c3f7346e..7ed00c63471 100644
--- a/gdb/solib.h
+++ b/gdb/solib.h
@@ -288,6 +288,20 @@ struct solib_ops
     (iterate_over_objfiles_in_search_order_cb_ftype cb,
      objfile *current_objfile) const;
 
+  /* Return the inferior entry point address.  This isn't always the entry
+     point of the main executable, but will be the actual entry point where
+     the inferior starts (or started) executing.
+
+     For example on SVR4 targets, for dynamically linked executables, this
+     will be the entry address of the dynamic linker.  But for statically
+     linked executables, this will be the entry point of the main
+     executable.
+
+     If the entry address cannot be found then an empty optional is
+     returned.  */
+  virtual std::optional<CORE_ADDR> inferior_entry_point_address () const
+  { return {}; }
+
 protected:
   /* The program space for which this solib_ops was created.  */
   program_space *m_pspace;
diff --git a/gdb/testsuite/gdb.base/bt-after-starti.exp b/gdb/testsuite/gdb.base/bt-after-starti.exp
new file mode 100644
index 00000000000..15a97f4c256
--- /dev/null
+++ b/gdb/testsuite/gdb.base/bt-after-starti.exp
@@ -0,0 +1,153 @@
+# Copyright 2026 Free Software Foundation, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Check that 'bt' from the very first instruction (where 'starti'
+# stops GDB) doesn't display any unexpected frames.
+
+require !use_gdb_stub
+
+standard_testfile main.c
+
+# Build default executable, hopefully dynamically linked, but we check
+# this below.
+if { [build_executable "failed to build" $testfile $srcfile] } {
+    return
+}
+
+# Build a statically linked executable.
+set testfile_static ${testfile}-static
+if { [build_executable "failed to build" $testfile_static $srcfile \
+	  {debug additional_flags=-static}] } {
+    return
+}
+
+# Run the 'maint info entry-address' command.  Expect INF_RE to match
+# the inferior entry address and EXE_RE to match the executable entry
+# address.  TESTNAME is used as the test name.
+proc check_maint_info_entry_addr { inf_re exe_re testname } {
+    gdb_test "maint info entry-address" \
+	[multi_line \
+	     "Inferior entry address: ${inf_re}" \
+	     "Executable entry address: ${exe_re}"] \
+	$testname
+}
+
+# Use 'readelf' to extract the entry point address from TESTFILE.
+proc get_exec_entry_address { testfile } {
+    set readelf_program [gdb_find_readelf]
+    set command "exec $readelf_program -Wh [standard_output_file $testfile]"
+    verbose -log "command is $command"
+    set result [catch {{*}$command} output]
+    verbose -log "result is $result"
+    verbose -log "output is $output"
+
+    set testname "get_exec_entry_address"
+
+    if {$result != 0} {
+	fail $testname
+	return "UNKNOWN"
+    }
+
+    if {![regexp "\n +Entry point address: +($::hex)\n" $output trash addr]} {
+	fail "$testname (no entry point address header)"
+	return "UNKNOWN"
+    }
+
+    return $addr
+}
+
+# Start TESTFILE using 'starti'.  Check if the 'backtrace' command
+# prints any additional frames; we don't expect any.
+#
+# When IS_DYNAMIC is true then TESTFILE is a dynamically linked
+# executable, otherwise TESTFILE is statically linked.
+proc run_test { testfile is_dynamic } {
+    clean_restart $testfile
+
+    set exe_entry_addr [get_exec_entry_address $testfile]
+
+    # The inferior entry address is always unknown before starting the
+    # inferior as at the point GDB has no solib_ops, and it is only
+    # through that that we figure out the inferior entry address.
+    check_maint_info_entry_addr "<unknown>" $exe_entry_addr \
+	"check 'maint info entry-address' before inferior starts"
+
+    # Start inferior with 'starti' and then wait for a prompt.
+    gdb_starti_cmd
+    gdb_test "" ".*" "prompt after starti"
+
+    # Only svr4 targets currently support querying the inferior entry
+    # address.
+    if {[istarget *-linux*]} {
+	set pc [get_hexadecimal_valueof "\$pc" "UNKNOWN" \
+		    "get current program counter"]
+
+	if { !$is_dynamic } {
+	    # In static binaries, the first address should be the first
+	    # address in the executable.
+	    gdb_assert { $pc == $exe_entry_addr } \
+		"stopped at executable entry address"
+	}
+
+	set inf_entry_addr $pc
+    } else {
+	set inf_entry_addr "<unknown>"
+    }
+
+    check_maint_info_entry_addr $inf_entry_addr $exe_entry_addr \
+	"check 'maint info entry-address' after starti"
+
+    # Allow backtrace past the entry frame, count how many frames GDB
+    # finds.  If on this target there are no additional frames then
+    # the following test isn't going to tell us much, so skip it.
+    gdb_test_no_output "set backtrace past-entry on"
+    set frame_count 0
+    gdb_test_multiple "bt" "count possible frames" {
+	-re "^#($::decimal)\\s+\[^\r\n\]+\r\n" {
+	    incr frame_count
+	    exp_continue
+	}
+	-re "^$::gdb_prompt $" {
+	    if { $frame_count > 1 } {
+		pass $gdb_test_name
+	    } else {
+		unsupported "$gdb_test_name (insufficient frames)"
+		return
+	    }
+	}
+	-re "^\[^\r\n\]*\r\n" {
+	    exp_continue
+	}
+    }
+
+    # Turn off backtrace past the entry frame.  Use the 'bt' command,
+    # and check we see only a single frame.
+    gdb_test_no_output "set backtrace past-entry off"
+    gdb_test "bt" "^#0  \[^\r\n\]+" \
+	"single frame when backtrace past-entry is off"
+}
+
+with_test_prefix "dynamic" {
+    set dyln_name [section_get $binfile .interp]
+    if { $dyln_name eq "" } {
+	unsupported "couldn't find dynamic linker name"
+    } else {
+	run_test $testfile true
+    }
+}
+
+with_test_prefix "static" {
+    run_test $testfile_static false
+}
-- 
2.25.4