diff --git a/gdb/arc-tdep.c b/gdb/arc-tdep.c
index 4936a5c8fbb..7ed83c4cae6 100644
--- a/gdb/arc-tdep.c
+++ b/gdb/arc-tdep.c
@@ -860,7 +860,7 @@ arc_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr,
 		     struct regcache *regcache)
 {
   *real_pc = funaddr;
-  *bp_addr = current_program_space->entry_point_address ();
+  *bp_addr = current_program_space->exec_entry_point_address ();
   return sp;
 }
 
diff --git a/gdb/arch-utils.c b/gdb/arch-utils.c
index e959788bd3b..88047731ce6 100644
--- a/gdb/arch-utils.c
+++ b/gdb/arch-utils.c
@@ -57,7 +57,7 @@ displaced_step_at_entry_point (struct gdbarch *gdbarch)
   CORE_ADDR addr;
   int bp_len;
 
-  addr = current_program_space->entry_point_address ();
+  addr = current_program_space->exec_entry_point_address ();
 
   /* Inferior calls also use the entry point as a breakpoint location.
      We don't want displaced stepping to interfere with those
diff --git a/gdb/frame.c b/gdb/frame.c
index b91e18fad99..a83f0b20686 100644
--- a/gdb/frame.c
+++ b/gdb/frame.c
@@ -2704,7 +2704,7 @@ static bool
 inside_entry_func (const frame_info_ptr &this_frame)
 {
   std::optional<CORE_ADDR> entry_point
-    = current_program_space->entry_point_address_query ();
+    = current_program_space->exec_entry_point_address_if_available ();
   if (!entry_point.has_value ())
     return false;
 
@@ -2780,7 +2780,7 @@ get_prev_frame (const frame_info_ptr &this_frame)
      added to work around that (now fixed) case.  */
   /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
      suggested having the inside_entry_func test use the
-     inside_main_func() msymbol trick (along with entry_point_address()
+     inside_main_func() msymbol trick (along with exec_entry_point_address()
      I guess) to determine the address range of the start function.
      That should provide a far better stopper than the current
      heuristics.  */
diff --git a/gdb/infcall.c b/gdb/infcall.c
index e6b24ff5310..6d26841ede3 100644
--- a/gdb/infcall.c
+++ b/gdb/infcall.c
@@ -1300,7 +1300,7 @@ call_function_by_hand_dummy (struct value *function,
 	CORE_ADDR dummy_addr;
 
 	real_pc = funaddr;
-	dummy_addr = current_program_space->entry_point_address ();
+	dummy_addr = current_program_space->exec_entry_point_address ();
 
 	/* A call dummy always consists of just a single breakpoint, so
 	   its address is the same as the address of the dummy.
diff --git a/gdb/linux-tdep.c b/gdb/linux-tdep.c
index bbc4009d43c..82d177d4dd8 100644
--- a/gdb/linux-tdep.c
+++ b/gdb/linux-tdep.c
@@ -2993,7 +2993,7 @@ linux_displaced_step_location (struct gdbarch *gdbarch)
 
   /* Determine entry point from target auxiliary vector.  This avoids
      the need for symbols.  Also, when debugging a stand-alone SPU
-     executable, entry_point_address () will point to an SPU
+     executable, exec_entry_point_address () will point to an SPU
      local-store address and is thus not usable as displaced stepping
      location.  The auxiliary vector gets us the PowerPC-side entry
      point address instead.  */
diff --git a/gdb/progspace.c b/gdb/progspace.c
index 988bb237030..3003a137c17 100644
--- a/gdb/progspace.c
+++ b/gdb/progspace.c
@@ -263,7 +263,7 @@ program_space::empty ()
 /* See progspace.h.  */
 
 std::optional<CORE_ADDR>
-program_space::entry_point_address_query () const
+program_space::exec_entry_point_address_if_available () const
 {
   objfile *objf = symfile_object_file;
   if (objf == NULL || !objf->per_bfd->ei.entry_point_p)
@@ -276,9 +276,9 @@ program_space::entry_point_address_query () const
 /* See progspace.h.  */
 
 CORE_ADDR
-program_space::entry_point_address () const
+program_space::exec_entry_point_address () const
 {
-  std::optional<CORE_ADDR> retval = entry_point_address_query ();
+  std::optional<CORE_ADDR> retval = exec_entry_point_address_if_available ();
 
   if (!retval.has_value ())
     error (_("Entry point address is not known."));
diff --git a/gdb/progspace.h b/gdb/progspace.h
index e9261ff8590..1ae1e42f3bb 100644
--- a/gdb/progspace.h
+++ b/gdb/progspace.h
@@ -323,13 +323,13 @@ struct program_space
     return m_target_sections;
   }
 
-  /* If there is a valid and known entry point in this program space,
-     return it.  Otherwise return an empty optional.  */
-  std::optional<CORE_ADDR> entry_point_address_query () 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;
 
-  /* Get the entry point address in this program space.  Call error if
-     it is not known.  */
-  CORE_ADDR entry_point_address () const;
+  /* Get the entry point address for the main executable in this program
+     space.  Call error if it is not known.  */
+  CORE_ADDR exec_entry_point_address () const;
 
   /* Return true if any objfile of this program space has partial
      symbols.  */
diff --git a/gdb/solib-frv.c b/gdb/solib-frv.c
index 08ee0a9578f..4284a711860 100644
--- a/gdb/solib-frv.c
+++ b/gdb/solib-frv.c
@@ -689,7 +689,7 @@ enable_break (void)
     }
 
   std::optional<CORE_ADDR> entry_point
-    = current_program_space->entry_point_address_query ();
+    = current_program_space->exec_entry_point_address_if_available ();
   if (!entry_point.has_value ())
     {
       solib_debug_printf ("Symbol file has no entry point.");