[PATCH v3 10/44] gdb, gdbserver, rsp, ze: acknowledge libraries

[Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>]

From: Markus Metzger <markus.t.metzger@intel.com>

On some accelerator devices, device shared libraries are loaded from a
host thread rather than from a device thread.  The reporting entity may
not be the one that actually does the load.

Intel GPU devices, for example, that are based on Level-Zero, will report
shared library events via the device's debug interface.  This is triggered
from a host thread calling the run-time interface for loading a device
shared library.

The Level-Zero run-time ensures that this host thread will not return
until the respective debug event has been acknowledged by the debugger.
This allows debuggers to set breakpoints before the new library is used.

Add a mechanism that allows gdbserver to request acknowledgement of newly
reported shared libraries and GDB to acknowledge requested libraries after
placing breakpoints.

Reviewed-By: Eli Zaretskii <eliz@gnu.org>
---
 gdb/NEWS                      |   7 +++
 gdb/doc/gdb.texinfo           |  76 ++++++++++++++++++++---
 gdb/features/library-list.dtd |  24 +++----
 gdb/remote.c                  | 114 ++++++++++++++++++++++++++++++++++
 gdb/solib-target.c            |  58 ++++++++++++++++-
 gdb/solib-target.h            |   1 +
 gdb/solib.c                   |  14 ++++-
 gdb/solib.h                   |   4 ++
 gdb/target-delegates-gen.c    |  50 +++++++++++++++
 gdb/target.c                  |  16 +++++
 gdb/target.h                  |  21 +++++++
 gdbserver/dll.cc              |  94 ++++++++++++++++++++++++++--
 gdbserver/dll.h               |  28 ++++++---
 gdbserver/server.cc           | 141 +++++++++++++++++++++++++++++++++++++++---
 gdbserver/server.h            |   4 ++
 gdbserver/target.cc           |  14 +++++
 gdbserver/target.h            |  20 ++++++
 17 files changed, 644 insertions(+), 42 deletions(-)

diff --git a/gdb/NEWS b/gdb/NEWS
index 36944e1a0a408aab3200bcd32c8ee462bb06428e..e95550496c4190f7032e917329ce497844a79e67 100644
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -202,6 +202,13 @@ qXfer:libraries:read's response
   indicates support by supplying qXfer:libraries:read:in-memory-library+ in the
   qSupported packet.
 
+vAck:library
+vAck:in-memory-library
+
+  Acknowledge libraries to gdbserver when requested.  Libraries are acknowledged
+  after the initial processing by GDB such as loading symbols and placing
+  breakpoints.
+
 * Changed remote packets
 
 qXfer:threads:read
diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo
index 628ee49b703c23888f518af584128111c9473ef9..faa93177e0e9f0a6b83ec9dda1031276ae1c114d 100644
--- a/gdb/doc/gdb.texinfo
+++ b/gdb/doc/gdb.texinfo
@@ -43660,6 +43660,44 @@ for success (@pxref{Stop Reply Packets})
 @cindex @samp{vStopped} packet
 @xref{Notification Packets}.
 
+@item vAck:@var{type}:@var{arg}[,@var{arg}@dots{}][;@var{type}:@var{arg}[,@var{arg}@dots{}]]@dots{}
+@cindex @samp{vAck} packet
+@anchor{vAck packet}
+
+Acknowledge a @samp{;}-separated list of remote stub responses, each
+with a @samp{,}-separated list of arguments defined by its @var{type}.
+The following @var{type}s with their respective arguments are
+supported:
+
+@table @samp
+@item library:@var{name}
+Acknowledge the shared library that had been reported as
+@samp{<library name="@var{name}" ack="yes">} in the remote stub's
+@samp{qXfer:libraries:read} response.  @value{GDBN} acknowledges
+libraries after initial processing like loading symbols and placing
+breakpoints.  The file name is a hex-encoded string.
+
+@item in-memory-library:@var{begin},@var{end}
+Acknowledge the shared library that had been reported as
+@samp{<in-memory-library begin="@var{begin}" end="@var{end}" ack="yes">}
+in the remote stub's @samp{qXfer:libraries:read} response.
+@value{GDBN} acknowledges libraries after initial processing like
+loading symbols and placing breakpoints.  Both arguments are unsigned
+integers.
+@end table
+
+Reply:
+@table @samp
+@item OK
+for success
+@item E @var{nn}
+for an error
+@end table
+
+@value{GDBN} indicates support for acknowledging individual types of
+responses by supplying an appropriate @samp{qSupported} feature
+(@pxref{qSupported}) for each type that it supports.
+
 @item x @var{addr},@var{length}
 @anchor{x packet}
 @cindex @samp{x} packet
@@ -45029,6 +45067,14 @@ didn't support @samp{E.@var{errtext}}, and older versions of
 
 New packets should be written to support @samp{E.@var{errtext}}
 regardless of this feature being true or not.
+
+@item vAck:library
+This feature indicates whether @value{GDBN} supports acknowledging
+libraries reported by name.
+
+@item vAck:in-memory-library
+This feature indicates whether @value{GDBN} supports acknowledging
+in-memory libraries reported by begin and end target address.
 @end table
 
 Stubs should ignore any unknown values for
@@ -48303,6 +48349,13 @@ associated name or begin and end addresses and one or more segment or
 section base addresses, which report where the library was loaded in
 memory.
 
+It may optionally contain a request for acknowledging that library.
+@value{GDBN} indicates support for acknowledging libraries by
+supplying an appropriate @samp{qSupported} feature
+(@pxref{qSupported}).  The remote stub must not request
+acknowledgement of libraries unless @value{GDBN} indicated support for
+it.
+
 For the common case of libraries that are fully linked binaries, the
 library should have a list of segments.  If the target supports
 dynamic linking of a relocatable object file, its library XML element
@@ -48328,16 +48381,21 @@ offset, looks like this:
 </library-list>
 @end smallexample
 
-A corresponding memory map for an in-memory library looks like this:
+A corresponding memory map for an in-memory library with a request for
+acknowledgement looks like this:
 
 @smallexample
 <library-list>
-  <in-memory-library begin="0xa000000" end="0xa001000">
+  <in-memory-library begin="0xa000000" end="0xa001000" ack="yes">
     <segment address="0x10000000"/>
   </in-memory-library>
 </library-list>
 @end smallexample
 
+@value{GDBN} will acknowledge the library with a @samp{vAck;library}
+or, as in this case, a @samp{vAck;in-memory-library} packet.
+@xref{vAck packet}.
+
 Another simple memory map, with one loaded library with three
 allocated sections (.text, .data, .bss), looks like this:
 
@@ -48356,16 +48414,18 @@ The format of a library list is described by this DTD:
 @smallexample
 <!-- library-list: Root element with versioning -->
 <!ELEMENT library-list            (library | in-memory-library)*>
-<!ATTLIST library-list            version CDATA   #FIXED  "1.1">
+<!ATTLIST library-list            version CDATA           #FIXED  "1.1">
 <!ELEMENT library                 (segment*, section*)>
-<!ATTLIST library                 name    CDATA   #REQUIRED>
+<!ATTLIST library                 name    CDATA           #REQUIRED
+                                  ack     (yes | no)      'no'>
 <!ELEMENT in-memory-library       (segment*, section*)>
-<!ATTLIST in-memory-library       begin    CDATA   #REQUIRED
-                                  end      CDATA   #REQUIRED>
+<!ATTLIST in-memory-library       begin   CDATA           #REQUIRED
+                                  end     CDATA           #REQUIRED
+                                  ack     (yes | no)      'no'>
 <!ELEMENT segment                 EMPTY>
-<!ATTLIST segment                 address CDATA   #REQUIRED>
+<!ATTLIST segment                 address CDATA           #REQUIRED>
 <!ELEMENT section                 EMPTY>
-<!ATTLIST section                 address CDATA   #REQUIRED>
+<!ATTLIST section                 address CDATA           #REQUIRED>
 @end smallexample
 
 In addition, segments and section descriptors cannot be mixed within a
diff --git a/gdb/features/library-list.dtd b/gdb/features/library-list.dtd
index baa01485af950c58e9e242229365501c043e2fe1..0ee7eb364b97c61180fcaecca3637a081e32736b 100644
--- a/gdb/features/library-list.dtd
+++ b/gdb/features/library-list.dtd
@@ -5,18 +5,20 @@
      notice and this notice are preserved.  -->
 
 <!-- library-list: Root element with versioning -->
-<!ELEMENT library-list  (library | in-memory-library)*>
-<!ATTLIST library-list  version CDATA   #FIXED  "1.1">
+<!ELEMENT library-list          (library | in-memory-library)*>
+<!ATTLIST library-list          version CDATA         #FIXED  "1.1">
 
-<!ELEMENT library       (segment*, section*)>
-<!ATTLIST library       name    CDATA   #REQUIRED>
+<!ELEMENT library               (segment*, section*)>
+<!ATTLIST library               name    CDATA         #REQUIRED
+                                ack     (yes | no)    'no'>
 
-<!ELEMENT in-memory-library       (segment*, section*)>
-<!ATTLIST in-memory-library       begin    CDATA   #REQUIRED
-                                  end      CDATA   #REQUIRED>
+<!ELEMENT in-memory-library     (segment*, section*)>
+<!ATTLIST in-memory-library     begin   CDATA         #REQUIRED
+                                end     CDATA         #REQUIRED
+                                ack     (yes | no)    'no'>
 
-<!ELEMENT segment       EMPTY>
-<!ATTLIST segment       address CDATA   #REQUIRED>
+<!ELEMENT segment               EMPTY>
+<!ATTLIST segment               address CDATA         #REQUIRED>
 
-<!ELEMENT section       EMPTY>
-<!ATTLIST section       address CDATA   #REQUIRED>
+<!ELEMENT section               EMPTY>
+<!ATTLIST section               address CDATA         #REQUIRED>
diff --git a/gdb/remote.c b/gdb/remote.c
index 3d3acd19a53c3665055f8e27cc8669916083f562..a4daca885f77803374384adbe13524af3e62b12b 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -379,6 +379,12 @@ enum {
   /* Support remote CTRL-C.  */
   PACKET_vCtrlC,
 
+  /* Support acknowledging libraries.  */
+  PACKET_vAck_library,
+
+  /* Support acknowledging in-memory-libraries.  */
+  PACKET_vAck_in_memory_library,
+
   /* Support TARGET_WAITKIND_NO_RESUMED.  */
   PACKET_no_resumed,
 
@@ -1157,6 +1163,9 @@ class remote_target : public process_stratum_target
 
   bool is_address_tagged (gdbarch *gdbarch, CORE_ADDR address) override;
 
+  void ack_library (const char *name) override;
+  void ack_in_memory_library (CORE_ADDR begin, CORE_ADDR end) override;
+
 public: /* Remote specific methods.  */
 
   void remote_download_command_source (int num, ULONGEST addr,
@@ -5864,6 +5873,10 @@ static const struct protocol_feature remote_protocol_features[] = {
   { "error-message", PACKET_ENABLE, remote_supported_packet,
     PACKET_accept_error_message },
   { "binary-upload", PACKET_DISABLE, remote_supported_packet, PACKET_x },
+  { "vAck:library", PACKET_DISABLE, remote_supported_packet,
+    PACKET_vAck_library },
+  { "vAck:in-memory-library", PACKET_DISABLE, remote_supported_packet,
+    PACKET_vAck_in_memory_library },
 };
 
 static char *remote_support_xml;
@@ -5978,6 +5991,14 @@ remote_target::remote_query_supported ()
       remote_query_supported_append
 	(&q, "qXfer:libraries:read:in-memory-library+");
 
+      if (m_features.packet_set_cmd_state (PACKET_vAck_library)
+	  != AUTO_BOOLEAN_FALSE)
+	remote_query_supported_append (&q, "vAck:library+");
+
+      if (m_features.packet_set_cmd_state (PACKET_vAck_in_memory_library)
+	  != AUTO_BOOLEAN_FALSE)
+	remote_query_supported_append (&q, "vAck:in-memory-library+");
+
       /* Keep this one last to work around a gdbserver <= 7.10 bug in
 	 the qSupported:xmlRegisters=i386 handling.  */
       if (remote_support_xml != NULL
@@ -15760,6 +15781,94 @@ remote_target::vcont_r_supported ()
 	  && get_remote_state ()->supports_vCont.r);
 }
 
+/* Acknowledge processing of library NAME is complete.  */
+
+void
+remote_target::ack_library (const char *name)
+{
+  if (m_features.packet_support (PACKET_vAck_library) == PACKET_DISABLE)
+    error (_("vAck:library packet disabled."));
+
+  remote_state *rs = get_remote_state ();
+  char *p = rs->buf.data ();
+  long size = get_remote_packet_size ();
+
+  int written = snprintf (p, size, "vAck:library:");
+  if (written == size)
+    error (_("Remote packet buffer too small for vAck:library packet."));
+
+  p += written;
+  size -= written;
+
+  int len = strnlen (name, size);
+  if (size <= (2 * len))
+    error (_("Library name too long for vAck:library packet."));
+
+  int converted = bin2hex ((const gdb_byte *) name, p, len);
+  if (converted < len)
+    error (_("Failed to encode library name for vAck:library packet."));
+
+  written = 2 * converted;
+  p += written;
+  size -= written;
+
+  gdb_assert (size > 0);
+  *p = 0;
+
+  putpkt (rs->buf);
+  getpkt (&rs->buf, 0);
+
+  packet_result result = m_features.packet_ok (rs->buf, PACKET_vAck_library);
+  switch (result.status ())
+    {
+    case PACKET_OK:
+      break;
+    case PACKET_UNKNOWN:
+      error (_("No support for acknowledging libraries."));
+    case PACKET_ERROR:
+      error (_("Acknowledging library '%s' failed: '%s'"), name,
+	     rs->buf.data ());
+    }
+}
+
+/* Acknowledge processing of in-memory library BEGIN..END is complete.  */
+
+void
+remote_target::ack_in_memory_library (CORE_ADDR begin, CORE_ADDR end)
+{
+  if (m_features.packet_support (PACKET_vAck_in_memory_library)
+      == PACKET_DISABLE)
+    error (_("vAck:in-memory-library packet disabled."));
+
+  remote_state *rs = get_remote_state ();
+  char *p = rs->buf.data ();
+  long size = get_remote_packet_size ();
+
+  int written = snprintf (p, size, "vAck:in-memory-library:%s,%s",
+			  core_addr_to_string_nz (begin),
+			  core_addr_to_string_nz (end));
+  if (written == size)
+    error (_("Remote packet buffer too small for vAck:in-memory-library "
+	     "packet."));
+
+  putpkt (rs->buf);
+  getpkt (&rs->buf, 0);
+
+  packet_result result
+    = m_features.packet_ok (rs->buf, PACKET_vAck_in_memory_library);
+  switch (result.status ())
+    {
+    case PACKET_OK:
+      break;
+    case PACKET_UNKNOWN:
+      error (_("No support for acknowledging in-memory libraries."));
+    case PACKET_ERROR:
+      error (_("Failed to acknowledge in-memory library %s-%s: %s"),
+	     core_addr_to_string_nz (begin), core_addr_to_string_nz (end),
+	     rs->buf.data ());
+    }
+}
+
 /* The "set/show range-stepping" set hook.  */
 
 static void
@@ -16525,6 +16634,11 @@ Show the maximum size of the address (in bits) in a memory packet."), NULL,
 
   add_packet_config_cmd (PACKET_vCtrlC, "vCtrlC", "ctrl-c", 0);
 
+  add_packet_config_cmd (PACKET_vAck_library, "vAck:library", "ack-library", 0);
+
+  add_packet_config_cmd (PACKET_vAck_in_memory_library,
+			 "vAck:in-memory-library", "ack-in-memory-library", 0);
+
   add_packet_config_cmd (PACKET_QThreadEvents, "QThreadEvents", "thread-events",
 			 0);
 
diff --git a/gdb/solib-target.c b/gdb/solib-target.c
index 5d9bc8f53204eb7e629f3807bcb170c6ace357aa..304237e9d60c0661e65ea6ae86c165bd02d125e5 100644
--- a/gdb/solib-target.c
+++ b/gdb/solib-target.c
@@ -53,6 +53,11 @@ struct lm_info_target final : public lm_info
      This is only valid if location == lm_in_memory.  */
   CORE_ADDR begin = 0ull, end = 0ull;
 
+  /* A flag saying whether library load and unload need to be acknowledged
+     to the target after processing the library and placing/removing
+     breakpoints.  */
+  bool need_ack = false;
+
   /* The target can either specify segment bases or section bases, not
      both.  */
 
@@ -132,6 +137,24 @@ library_list_start_section (struct gdb_xml_parser *parser,
   last->section_bases.push_back (address);
 }
 
+/* Handle the 'ack' attribute of <library> and <in-memory-library>.  */
+
+static void
+library_ack (lm_info_target &item, std::vector<gdb_xml_value> &attributes)
+{
+  gdb_xml_value *ack = xml_find_attribute (attributes, "ack");
+  if (ack != nullptr)
+    {
+      const char *value = (const char *) ack->value.get ();
+      if (strcmp (value, "yes") == 0)
+	item.need_ack = true;
+      else if (strcmp (value, "no") == 0)
+	item.need_ack = false;
+      else
+	warning (_("bad attribute value for library:ack"));
+    }
+}
+
 /* Handle the start of a <library> element.  */
 
 static void
@@ -146,6 +169,8 @@ library_list_start_library (struct gdb_xml_parser *parser,
   item->name
     = (const char *) xml_find_attribute (attributes, "name")->value.get ();
 
+  library_ack (*item, attributes);
+
   list->emplace_back (item);
 }
 
@@ -165,6 +190,8 @@ in_memory_library_list_start_library (struct gdb_xml_parser *parser,
   item->end = (CORE_ADDR) *(ULONGEST *)
     xml_find_attribute (attributes, "end")->value.get ();
 
+  library_ack (*item, attributes);
+
   list->emplace_back (item);
 }
 
@@ -196,7 +223,8 @@ library_list_start_list (struct gdb_xml_parser *parser,
     {
       const char *string = (const char *) version->value.get ();
 
-      if ((strcmp (string, "1.0") != 0) && (strcmp (string, "1.1") != 0))
+      if ((strcmp (string, "1.0") != 0) && (strcmp (string, "1.1") != 0)
+	  && (strcmp (string, "1.2") != 0))
 	gdb_xml_error (parser,
 		       _("Library list has unsupported version \"%s\""),
 		       string);
@@ -228,12 +256,14 @@ static const struct gdb_xml_element library_children[] = {
 
 static const struct gdb_xml_attribute library_attributes[] = {
   { "name", GDB_XML_AF_NONE, NULL, NULL },
+  { "ack", GDB_XML_AF_OPTIONAL, NULL, NULL },
   { NULL, GDB_XML_AF_NONE, NULL, NULL }
 };
 
 static const struct gdb_xml_attribute in_memory_library_attributes[] = {
   { "begin", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
   { "end", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
+  { "ack", GDB_XML_AF_OPTIONAL, NULL, NULL },
   { NULL, GDB_XML_AF_NONE, NULL, NULL }
 };
 
@@ -464,6 +494,32 @@ target_solib_ops::bfd_open_from_target_memory (CORE_ADDR addr,
   return gdb_bfd_open_from_target_memory (addr, size, target);
 }
 
+void
+target_solib_ops::ack_library (solib &so) const
+{
+  lm_info_target *lm
+    = gdb::checked_static_cast<lm_info_target *> (so.lm_info.get ());
+
+  if (!lm->need_ack)
+    return;
+
+  /* Try only once, whether we succeed or not.  */
+  lm->need_ack = false;
+  switch (lm->location)
+    {
+    case lm_on_disk:
+      target_ack_library (so.original_name.c_str ());
+      return;
+
+    case lm_in_memory:
+      target_ack_in_memory_library (lm->begin, lm->end);
+      return;
+    }
+
+  gdb_assert_not_reached ("bad solib location '%d' for %s.", lm->location,
+			  so.original_name.c_str ());
+}
+
 /* See solib-target.h.  */
 
 solib_ops_up
diff --git a/gdb/solib-target.h b/gdb/solib-target.h
index ecd67658c71cb854f012c4311ba79bb40a2ca1b1..a417052b541dbe75fee7f455ec907e2e1c843a05 100644
--- a/gdb/solib-target.h
+++ b/gdb/solib-target.h
@@ -31,6 +31,7 @@ struct target_solib_ops : solib_ops
   bool in_dynsym_resolve_code (CORE_ADDR pc) const override;
   gdb_bfd_ref_ptr bfd_open_from_target_memory
     (CORE_ADDR addr, CORE_ADDR size, const char *target) const override;
+  void ack_library (solib &so) const override;
 };
 
 /* Return a new solib_ops for systems fetching solibs from the target.  */
diff --git a/gdb/solib.c b/gdb/solib.c
index f2b26d4e9f9b56b0d174e5223669bd392c3114de..b7a552e80dc34ea5b69f55f4e25f5a390a57c2da 100644
--- a/gdb/solib.c
+++ b/gdb/solib.c
@@ -984,6 +984,7 @@ solib_add (const char *pattern, int from_tty, int readsyms)
     if (from_tty)
       add_flags |= SYMFILE_VERBOSE;
 
+    std::list<solib *> added_solibs;
     for (solib &gdb : current_program_space->solibs ())
       if (!pattern || re_exec (gdb.name.c_str ()))
 	{
@@ -1006,14 +1007,23 @@ solib_add (const char *pattern, int from_tty, int readsyms)
 				styled_string (file_name_style.style (),
 					       gdb.name.c_str ()));
 		}
-	      else if (solib_read_symbols (gdb, add_flags))
-		loaded_any_symbols = true;
+	      else
+		added_solibs.push_back (&gdb);
 	    }
 	}
 
+    for (solib *gdb : added_solibs)
+      if (solib_read_symbols (*gdb, add_flags))
+	loaded_any_symbols = true;
+
     if (loaded_any_symbols || !current_program_space->deleted_solibs.empty ())
       breakpoint_re_set ();
 
+    /* Acknowledge loading of new solibs.  This must be called after
+       breakpoints have been set in this newly loaded solib.  */
+    for (solib *gdb : added_solibs)
+      gdb->ops ().ack_library (*gdb);
+
     if (from_tty && pattern && !any_matches)
       gdb_printf ("No loaded shared libraries match the pattern `%s'.\n",
 		  pattern);
diff --git a/gdb/solib.h b/gdb/solib.h
index 32101d27cc5acae22939eb6a9f72239aaf4812a4..2790603ea5bb3e0b0463c8c2254e69ea4e5c0a31 100644
--- a/gdb/solib.h
+++ b/gdb/solib.h
@@ -269,6 +269,10 @@ struct solib_ops
      The TARGET string is used to identify the target.  */
   virtual gdb_bfd_ref_ptr bfd_open_from_target_memory
     (CORE_ADDR addr, CORE_ADDR size, const char *target) const;
+
+  /* Acknowledge a library.  This is called from add_solib after
+     loading symbols and placing breakpoints.  */
+  virtual void ack_library (solib &so) const {}
 };
 
 /* A unique pointer to an solib_ops.  */
diff --git a/gdb/target-delegates-gen.c b/gdb/target-delegates-gen.c
index 164ddbb9a2ea2da5fe4e02f78c3fa82d5e9eaf18..a311ff3daa8789524b18a52985c6e204f4c090a0 100644
--- a/gdb/target-delegates-gen.c
+++ b/gdb/target-delegates-gen.c
@@ -190,6 +190,8 @@ struct dummy_target : public target_ops
   void call_history_from (ULONGEST arg0, int arg1, record_print_flags arg2) override;
   void call_history_range (ULONGEST arg0, ULONGEST arg1, record_print_flags arg2) override;
   bool augmented_libraries_svr4_read () override;
+  void ack_library (const char *arg0) override;
+  void ack_in_memory_library (CORE_ADDR arg0, CORE_ADDR arg1) override;
   const struct frame_unwind *get_unwinder () override;
   const struct frame_unwind *get_tailcall_unwinder () override;
   void prepare_to_generate_core () override;
@@ -371,6 +373,8 @@ struct debug_target : public target_ops
   void call_history_from (ULONGEST arg0, int arg1, record_print_flags arg2) override;
   void call_history_range (ULONGEST arg0, ULONGEST arg1, record_print_flags arg2) override;
   bool augmented_libraries_svr4_read () override;
+  void ack_library (const char *arg0) override;
+  void ack_in_memory_library (CORE_ADDR arg0, CORE_ADDR arg1) override;
   const struct frame_unwind *get_unwinder () override;
   const struct frame_unwind *get_tailcall_unwinder () override;
   void prepare_to_generate_core () override;
@@ -4202,6 +4206,52 @@ debug_target::augmented_libraries_svr4_read ()
   return result;
 }
 
+void
+target_ops::ack_library (const char *arg0)
+{
+  this->beneath ()->ack_library (arg0);
+}
+
+void
+dummy_target::ack_library (const char *arg0)
+{
+  tcomplain ();
+}
+
+void
+debug_target::ack_library (const char *arg0)
+{
+  gdb_printf (gdb_stdlog, "-> %s->ack_library (...)\n", this->beneath ()->shortname ());
+  this->beneath ()->ack_library (arg0);
+  gdb_printf (gdb_stdlog, "<- %s->ack_library (", this->beneath ()->shortname ());
+  target_debug_print_const_char_p (arg0);
+  gdb_puts (")\n", gdb_stdlog);
+}
+
+void
+target_ops::ack_in_memory_library (CORE_ADDR arg0, CORE_ADDR arg1)
+{
+  this->beneath ()->ack_in_memory_library (arg0, arg1);
+}
+
+void
+dummy_target::ack_in_memory_library (CORE_ADDR arg0, CORE_ADDR arg1)
+{
+  tcomplain ();
+}
+
+void
+debug_target::ack_in_memory_library (CORE_ADDR arg0, CORE_ADDR arg1)
+{
+  gdb_printf (gdb_stdlog, "-> %s->ack_in_memory_library (...)\n", this->beneath ()->shortname ());
+  this->beneath ()->ack_in_memory_library (arg0, arg1);
+  gdb_printf (gdb_stdlog, "<- %s->ack_in_memory_library (", this->beneath ()->shortname ());
+  target_debug_print_CORE_ADDR (arg0);
+  gdb_puts (", ", gdb_stdlog);
+  target_debug_print_CORE_ADDR (arg1);
+  gdb_puts (")\n", gdb_stdlog);
+}
+
 const struct frame_unwind *
 target_ops::get_unwinder ()
 {
diff --git a/gdb/target.c b/gdb/target.c
index f7c43f69a288728750b5dc85626742bca013e694..c141de22ef6b2138bf6aa357d1214e9c9ae43bc8 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -4237,6 +4237,22 @@ target_done_generating_core (void)
   current_inferior ()->top_target ()->done_generating_core ();
 }
 
+/* See target.h.  */
+
+void
+target_ack_library (const char *name)
+{
+  current_inferior ()->top_target ()->ack_library (name);
+}
+
+/* See target.h.  */
+
+void
+target_ack_in_memory_library (CORE_ADDR begin, CORE_ADDR end)
+{
+  current_inferior ()->top_target ()->ack_in_memory_library (begin, end);
+}
+
 \f
 
 static char targ_desc[] =
diff --git a/gdb/target.h b/gdb/target.h
index 365e894efe6918db9653218b178c9a36206829b1..70478834fe69f6720d91949cfe572e4fd900ee5f 100644
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -1324,6 +1324,21 @@ struct target_ops
     virtual bool augmented_libraries_svr4_read ()
       TARGET_DEFAULT_RETURN (false);
 
+    /* Acknowledge a library reported by name.
+
+       Libraries are acknowledged after initial processing like loading
+       symbols and placing breakpoints on request from the target.  */
+    virtual void ack_library (const char *name)
+      TARGET_DEFAULT_NORETURN (tcomplain ());
+
+    /* Acknowledge an in-memory library reported by begin and end target
+       addresses.
+
+       Libraries are acknowledged after initial processing like loading
+       symbols and placing breakpoints on request from the target.  */
+    virtual void ack_in_memory_library (CORE_ADDR begin, CORE_ADDR end)
+      TARGET_DEFAULT_NORETURN (tcomplain ());
+
     /* Those unwinders are tried before any other arch unwinders.  If
        SELF doesn't have unwinders, it should delegate to the
        "beneath" target.  */
@@ -2660,4 +2675,10 @@ extern void target_prepare_to_generate_core (void);
 /* See to_done_generating_core.  */
 extern void target_done_generating_core (void);
 
+/* See target_ops::ack_library.  */
+extern void target_ack_library (const char *name);
+
+/* See target_ops::ack_in_memory_library.  */
+extern void target_ack_in_memory_library (CORE_ADDR begin, CORE_ADDR end);
+
 #endif /* GDB_TARGET_H */
diff --git a/gdbserver/dll.cc b/gdbserver/dll.cc
index c8e7c03012a6fd1650a7f7a4827f79b3735d624b..e6cb597ca90855e6932ed6c22c266ba1fefe3e31 100644
--- a/gdbserver/dll.cc
+++ b/gdbserver/dll.cc
@@ -25,18 +25,24 @@
 /* Record a newly loaded DLL at BASE_ADDR for the current process.  */
 
 void
-loaded_dll (const char *name, CORE_ADDR base_addr)
+loaded_dll (const char *name, CORE_ADDR base_addr, bool need_ack)
 {
-  loaded_dll (current_process (), name, base_addr);
+  loaded_dll (current_process (), name, base_addr, need_ack);
 }
 
 /* Record a newly loaded DLL at BASE_ADDR for PROC.  */
 
 void
-loaded_dll (process_info *proc, const char *name, CORE_ADDR base_addr)
+loaded_dll (process_info *proc, const char *name, CORE_ADDR base_addr,
+	    bool need_ack)
 {
+  if (need_ack && !get_client_state ().vack_library_supported)
+    throw_error (NOT_SUPPORTED_ERROR,
+		 _("library acknowledgement not supported."));
+
   gdb_assert (proc != nullptr);
-  proc->all_dlls.emplace_back (name != nullptr ? name : "", base_addr);
+  proc->all_dlls.emplace_back (name != nullptr ? name : "", base_addr,
+			       need_ack);
   proc->dlls_changed = true;
 }
 
@@ -44,8 +50,14 @@ loaded_dll (process_info *proc, const char *name, CORE_ADDR base_addr)
 
 void
 loaded_dll (process_info *proc, CORE_ADDR begin, CORE_ADDR end,
-	    CORE_ADDR base_addr)
+	    CORE_ADDR base_addr, bool need_ack)
 {
+  /* It suffices to assert support for on-disk library acknowledgement since we
+     can fall back to that.  */
+  if (need_ack && !get_client_state ().vack_library_supported)
+    throw_error (NOT_SUPPORTED_ERROR,
+		 _("library acknowledgement not supported."));
+
   gdb_assert (proc != nullptr);
 
   /* We do not support duplicate in-memory libraries.  */
@@ -61,7 +73,7 @@ loaded_dll (process_info *proc, CORE_ADDR begin, CORE_ADDR end,
     error (_("Duplicate in-memory library; begin: %s, end: %s, base: %s."),
 	   paddress (begin), paddress (end), paddress (base_addr));
 
-  proc->all_dlls.emplace_back (begin, end, base_addr);
+  proc->all_dlls.emplace_back (begin, end, base_addr, need_ack);
   proc->dlls_changed = true;
 }
 
@@ -74,6 +86,74 @@ unloaded_dll (const char *name, CORE_ADDR base_addr)
   unloaded_dll (current_process (), name, base_addr);
 }
 
+static void
+ack_dll (process_info *process, dll_info &dll)
+{
+  gdb_assert (dll.need_ack);
+
+  switch (dll.location)
+    {
+    case dll_info::on_disk:
+      /* Check if this is a temporary file for an in-memory library.  */
+      if (dll.begin == 0)
+	{
+	  target_ack_library (process, dll.name.c_str ());
+	  dll.need_ack = false;
+	  return;
+	}
+
+      [[fallthrough]];
+    case dll_info::in_memory:
+      target_ack_in_memory_library (process, dll.begin, dll.end);
+      dll.need_ack = false;
+      return;
+    }
+
+  internal_error (_("bad library location: %d."), dll.location);
+}
+
+void
+ack_dll (process_info *proc, const char *name)
+{
+  std::list<dll_info> &dlls = proc->all_dlls;
+  std::list<dll_info>::iterator it
+    = std::find_if (dlls.begin (), dlls.end (),
+		    [name] (const dll_info &dll)
+	{
+	  return (dll.name == std::string (name));
+	});
+
+  if (it != dlls.end ())
+    ack_dll (proc, *it);
+}
+
+void
+ack_dll (const char *name)
+{
+  ack_dll (current_process (), name);
+}
+
+void
+ack_dll (process_info *proc, CORE_ADDR begin, CORE_ADDR end)
+{
+  std::list<dll_info> &dlls = proc->all_dlls;
+  std::list<dll_info>::iterator it
+    = std::find_if (dlls.begin (), dlls.end (),
+		    [begin, end] (const dll_info &dll)
+	{
+	  return ((dll.begin == begin) && (dll.end == end));
+	});
+
+  if (it != dlls.end ())
+    ack_dll (proc, *it);
+}
+
+void
+ack_dll (CORE_ADDR begin, CORE_ADDR end)
+{
+  ack_dll (current_process (), begin, end);
+}
+
 static void
 unload_dll_if (process_info *proc,
 	       std::function<bool (const dll_info &)> pred)
@@ -95,6 +175,8 @@ unload_dll_if (process_info *proc,
     {
       /* DLL has been found so remove the entry and free associated
 	 resources.  */
+      if (iter->need_ack)
+	ack_dll (proc, *iter);
       proc->all_dlls.erase (iter);
       proc->dlls_changed = true;
     }
diff --git a/gdbserver/dll.h b/gdbserver/dll.h
index a3af86dd6122ff8b8c47a335890f54a906f6d5be..8ddd323aa228fa02b1925e871313b07c3d1b3aa5 100644
--- a/gdbserver/dll.h
+++ b/gdbserver/dll.h
@@ -31,12 +31,15 @@ struct dll_info
     in_memory
   };
 
-  dll_info (const std::string &name_, CORE_ADDR base_addr_)
-    : location (on_disk), name (name_), base_addr (base_addr_)
+  dll_info (const std::string &name_, CORE_ADDR base_addr_, bool need_ack_)
+    : location (on_disk), name (name_), begin (0), end (0),
+      base_addr (base_addr_), need_ack (need_ack_)
   {}
 
-  dll_info (CORE_ADDR begin_, CORE_ADDR end_, CORE_ADDR base_addr_)
-    : location (in_memory), begin (begin_), end (end_), base_addr (base_addr_)
+  dll_info (CORE_ADDR begin_, CORE_ADDR end_, CORE_ADDR base_addr_,
+	    bool need_ack_)
+    : location (in_memory), begin (begin_), end (end_), base_addr (base_addr_),
+      need_ack (need_ack_)
   {}
 
   /* Where the library bits are stored.  */
@@ -58,17 +61,28 @@ struct dll_info
 
   /* The base address at which the library is loaded.  */
   CORE_ADDR base_addr;
+
+  /* Whether we need to acknowledge that we processed the library event,
+     e.g. that we inserted pending breakpoints.  */
+  bool need_ack;
 };
 
-extern void loaded_dll (const char *name, CORE_ADDR base_addr);
+/* Throws NOT_SUPPORTED_ERROR if library acknowledgement is requested
+  (NEED_ACK = TRUE) and not supported.  */
+extern void loaded_dll (const char *name, CORE_ADDR base_addr,
+			bool need_ack = false);
 extern void loaded_dll (process_info *proc, const char *name,
-			CORE_ADDR base_addr);
+			CORE_ADDR base_addr, bool need_ack = false);
 extern void loaded_dll (process_info *proc, CORE_ADDR begin, CORE_ADDR end,
-			CORE_ADDR base_addr);
+			CORE_ADDR base_addr, bool need_ack = false);
 extern void unloaded_dll (const char *name, CORE_ADDR base_addr);
 extern void unloaded_dll (process_info *proc, const char *name,
 			  CORE_ADDR base_addr);
 extern void unloaded_dll (process_info *proc, CORE_ADDR begin, CORE_ADDR end,
 			  CORE_ADDR base_addr);
+extern void ack_dll (const char *name);
+extern void ack_dll (process_info *proc, const char *name);
+extern void ack_dll (CORE_ADDR begin, CORE_ADDR end);
+extern void ack_dll (process_info *proc, CORE_ADDR begin, CORE_ADDR end);
 
 #endif /* GDBSERVER_DLL_H */
diff --git a/gdbserver/server.cc b/gdbserver/server.cc
index aa695f2f2f80686ea6dc2ae3ae1bfd7c081067bf..1993a56fa78dc4b6dcd70beb0c1becddf34ff933 100644
--- a/gdbserver/server.cc
+++ b/gdbserver/server.cc
@@ -1944,18 +1944,22 @@ dll_to_tmpfile (dll_info &dll)
 static std::string
 print_qxfer_libraries_entry (dll_info &dll)
 {
+  const client_state &cs = get_client_state ();
+
   switch (dll.location)
     {
     case dll_info::in_memory:
-      if (get_client_state ().in_memory_library_supported)
+      if (cs.in_memory_library_supported
+	  && (!dll.need_ack || cs.vack_in_memory_library_supported))
 	return string_printf
-	  ("  <in-memory-library begin=\"0x%s\" end=\"0x%s\">"
+	  ("  <in-memory-library begin=\"0x%s\" end=\"0x%s\"%s>"
 	   "<segment address=\"0x%s\"/></in-memory-library>\n",
 	   paddress (dll.begin), paddress (dll.end),
-	   paddress (dll.base_addr));
+	   dll.need_ack ? " ack=\"yes\"" : "", paddress (dll.base_addr));
 
-      /* GDB does not support in-memory-library.  Fall back to storing it in a
-	 temporary file and report that file to GDB.  */
+      /* GDB does not support in-memory-library or acknowledging
+	 in-memory libraries.  Fall back to storing it in a temporary
+	 file and report that file to GDB.  */
       try
 	{
 	  dll_to_tmpfile (dll);
@@ -1968,9 +1972,13 @@ print_qxfer_libraries_entry (dll_info &dll)
 
       [[fallthrough]];
     case dll_info::on_disk:
+      /* We checked this when requesting acknowledgement for DLL.  */
+      gdb_assert (!dll.need_ack || cs.vack_library_supported);
+
       return string_printf
-	("  <library name=\"%s\"><segment address=\"0x%s\"/></library>\n",
-	 dll.name.c_str (), paddress (dll.base_addr));
+	("  <library name=\"%s\"%s><segment address=\"0x%s\"/></library>\n",
+	 dll.name.c_str (), dll.need_ack ? " ack=\"yes\"" : "",
+	 paddress (dll.base_addr));
     }
 
   gdb_assert_not_reached ("unknown dll location: %x", dll.location);
@@ -2002,6 +2010,18 @@ library_list_version_needed (const std::list<dll_info> &dlls)
 	    }
 	  break;
 	}
+
+      if (dll.need_ack)
+	{
+	  /* We checked support for acknowledgement when we inserted DLL.
+
+	     It suffices to assert support for on-disk library acknowledgement
+	     since we can fall back to that.  */
+	  gdb_assert (!dll.need_ack || cs.vack_library_supported);
+
+	  major = std::max (major, 1);
+	  minor = std::max (minor, 2);
+	}
     }
 
   return std::to_string (major) + std::string (".") + std::to_string (minor);
@@ -2866,6 +2886,10 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
 		cs.error_message_supported = true;
 	      else if (feature == "qXfer:libraries:read:in-memory-library+")
 		cs.in_memory_library_supported = true;
+	      else if (feature == "vAck:library+")
+		cs.vack_library_supported = true;
+	      else if (feature == "vAck:in-memory-library+")
+		cs.vack_in_memory_library_supported = true;
 	      else
 		{
 		  /* Move the unknown features all together.  */
@@ -2994,6 +3018,9 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
       if (target_supports_memory_tagging ())
 	strcat (own_buf, ";memory-tagging+");
 
+      strcat (own_buf, ";vAck:library+");
+      strcat (own_buf, ";vAck:in-memory-library+");
+
       /* Reinitialize components as needed for the new connection.  */
       hostio_handle_new_gdb_connection ();
       target_handle_new_gdb_connection ();
@@ -3381,6 +3408,100 @@ err:
   return;
 }
 
+/* Parse vAck packets.  */
+
+static void
+handle_v_ack (char *own_buf)
+{
+  client_state &cs = get_client_state ();
+  const char *libstr = "library:";
+  const char *imlibstr = "in-memory-library:";
+
+  /* Move past vAck: to the first type string.  */
+  char *p = &own_buf[5];
+  do
+    {
+      if (strncmp (p, libstr, strlen (libstr)) == 0)
+	{
+	  if (!cs.vack_library_supported)
+	    {
+	      sprintf (own_buf,
+		       "E.vAck:library packet not supported.");
+	      return;
+	    }
+
+	  p += strlen (libstr);
+
+	  /* We expect a single argument: the filename.  */
+	  const char *hex = p;
+
+	  p = strchr (p, ';');
+	  if (p == hex)
+	    {
+	      sprintf (own_buf, "E.missing argument in vAck:library.");
+	      return;
+	    }
+
+	  if (p != nullptr)
+	    *p++ = '\0';
+
+	  std::string name = hex2str (hex);
+	  if (strlen (hex) < (name.size () * 2))
+	    {
+	      sprintf (own_buf, "E.failed to convert library name '%s' in "
+		       "vAck:library.", hex);
+	      return;
+	    }
+
+	  ack_dll (name.c_str ());
+	}
+      else if (strncmp (p, imlibstr, strlen (imlibstr)) == 0)
+	{
+	  if (!cs.vack_in_memory_library_supported)
+	    {
+	      sprintf (own_buf,
+		       "E.vAck:in-memory-library packet not supported.");
+	      return;
+	    }
+
+	  p += strlen (imlibstr);
+
+	  /* We expect two arguments: begin and end address.  */
+	  CORE_ADDR begin, end;
+
+	  begin = (CORE_ADDR) strtoull (p, &p, 16);
+	  if ((*p == 0) || (*p == ';'))
+	    {
+	      sprintf (own_buf,
+		       "E.missing argument in vAck:in-memory-library.");
+	      return;
+	    }
+
+	  if (*p != ',')
+	    break;
+
+	  end = (CORE_ADDR) strtoull (p+1, &p, 16);
+	  if (*p == ';')
+	    p += 1;
+	  else if (*p != 0)
+	    break;
+
+	  ack_dll (begin, end);
+	}
+      else
+	break;
+    }
+  while (p != nullptr && *p != 0);
+
+  if (p == nullptr || *p == 0)
+    write_ok (own_buf);
+  else
+    {
+      std::string junk { p };
+      sprintf (own_buf, "E.junk in vAck: '%s'.", junk.c_str ());
+    }
+}
+
 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements.  */
 
 static void
@@ -3723,6 +3844,12 @@ handle_v_requests (char *own_buf, int packet_len, int *new_packet_len)
       return;
     }
 
+  if (startswith (own_buf, "vAck:"))
+    {
+      handle_v_ack (own_buf);
+      return;
+    }
+
   if (handle_notif_ack (own_buf, packet_len))
     return;
 
diff --git a/gdbserver/server.h b/gdbserver/server.h
index ebb5980f70dd778abfaade1086b4b89a529b4298..5552588c947a522b3aaa314015352d7e3d75c8b9 100644
--- a/gdbserver/server.h
+++ b/gdbserver/server.h
@@ -199,6 +199,10 @@ struct client_state
 
   /* True if qXfer:libraries:read supports in-memory-library.  */
   bool in_memory_library_supported = false;
+
+  /* Track supported packets.  */
+  bool vack_library_supported = false;
+  bool vack_in_memory_library_supported = false;
 };
 
 client_state &get_client_state ();
diff --git a/gdbserver/target.cc b/gdbserver/target.cc
index c400174c47cfd0e2ad218fbcd95abfd5b468be60..65308b78497cd235165b7e1368480bb4b0644f26 100644
--- a/gdbserver/target.cc
+++ b/gdbserver/target.cc
@@ -441,6 +441,20 @@ process_stratum_target::store_memtags (CORE_ADDR address, size_t len,
   gdb_assert_not_reached ("target op store_memtags not supported");
 }
 
+void
+process_stratum_target::ack_library (process_info *process, const char *name)
+{
+  gdb_assert_not_reached ("target op ack_library not supported");
+}
+
+void
+process_stratum_target::ack_in_memory_library (process_info *process,
+					       CORE_ADDR begin,
+					       CORE_ADDR end)
+{
+  gdb_assert_not_reached ("target op ack_in_memory_library not supported");
+}
+
 int
 process_stratum_target::read_offsets (CORE_ADDR *text, CORE_ADDR *data)
 {
diff --git a/gdbserver/target.h b/gdbserver/target.h
index 66ca72fec17ef16b5aa094c060b617813590b6fd..a98dd33676dc2156f94a08f93177ace3a0d5153d 100644
--- a/gdbserver/target.h
+++ b/gdbserver/target.h
@@ -530,6 +530,13 @@ class process_stratum_target
      Returns true if successful and false otherwise.  */
   virtual bool store_memtags (CORE_ADDR address, size_t len,
 			      const gdb::byte_vector &tags, int type);
+
+  /* Acknowledge a library reported by name.  */
+  virtual void ack_library (process_info *process, const char *name);
+
+  /* Acknowledge an in-memory library reported by address.  */
+  virtual void ack_in_memory_library (process_info *process, CORE_ADDR begin,
+				      CORE_ADDR end);
 };
 
 extern process_stratum_target *the_target;
@@ -727,6 +734,19 @@ target_thread_pending_child (thread_info *thread, target_waitkind *kind)
   return the_target->thread_pending_child (thread, kind);
 }
 
+static inline void
+target_ack_library (process_info *process, const char *name)
+{
+  the_target->ack_library (process, name);
+}
+
+static inline void
+target_ack_in_memory_library (process_info *process,  CORE_ADDR begin,
+			      CORE_ADDR end)
+{
+  the_target->ack_in_memory_library (process, begin, end);
+}
+
 /* Read LEN bytes from MEMADDR in the buffer MYADDR.  Return 0 if the read
    is successful, otherwise, return a non-zero error code.  */
 

-- 
2.34.1

Intel Deutschland GmbH
Registered Address: Am Campeon 10, 85579 Neubiberg, Germany
Tel: +49 89 99 8853-0, www.intel.de
Managing Directors: Sean Fennelly, Jeffrey Schneiderman, Tiffany Doon Silva
Chairperson of the Supervisory Board: Nicole Lau
Registered Office: Munich
Commercial Register: Amtsgericht Muenchen HRB 186928