Add target.xml support for qXfer request.

[PatriosTheGreat]

Summary

Requesting registers one by one takes a while in our project.
We want to get rid of it by using target.xml.

[jarin]

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

2903

As discussed offline, this should not be hard-coded, register context provides register count.

2909

Fill all the relevant fields, please (everything that the qRegisterInfo handler provides).

[labath]

Yeah, we should fill in the other attributes too. As that will probably noticeably increase the amount of code, it would be good to put this stuff into a separate function (or two..). For a test, you could create some kind of a lldb-server test (packages/Python/lldbsuite/test/tools/lldb-server/). I am imagining something that will check that this parses as valid xml, and then does some kind of basic validation on the contents.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

2916

"target.xml" would be a better buffer name than __FUNCTION__.

[labath]

I think this is looking pretty good overall. I just have a bunch of stylistic remarks...

lldb/packages/Python/lldbsuite/test/tools/lldb-server/registers-target-xml-reading/main.cpp

2

I don't think the choice of inferior really matters here. This code could just be like int main(){}

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

850

You can put this outside the #ifdef

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

380–459

These should return a llvm::StringRef to avoid copies, and take the argument as a reference to convey non-nullness.

2873–2997

Please move this into a separate function

2875–2879

This check could be factored to the front of the function (the svr4 branch does currently not have it, but it most likely should).

2928–2930

We generally don't put curly braces around statements which fit on a single line.

2958–2981

Make a utility function (lambda?) for this?

[labath]

Just a couple of comments to make this code more llvm-y. Without those, we have just moved the place which constructs the temporary std::string. I haven't highlighted all the uses, but overall I'd recommend using the Format function or something similar instead of Printf, as the latter can be error-prone (because of the need to pass the right PRIx macro to get the integer size right) and/or inefficient (need to do the .str().c_str() dance on StringRefs).

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

1794

Despite the name, PutCString actually takes a StringRef, so you can just drop the .str().c_str() thingy. In fact, I'd consider just writing response << "encoding:" << encoding << ';';

2783

Similarly, response << "encoding='" << encoding << "' ", or response.Format("encoding='{0}'", encoding) would be shorter, and avoid string copying.

2875

no braces

[labath]

Just one more thing I didn't catch in the previous round :(.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

461–481

Sorry I wasn't clear about this, but my idea was to make a _single_ utility function for this. If you pass in the uint32_t* to the function instead of the whole RegisterInfo struct, then you can use the same code in both places..

[labath]

Looks good. Thanks for doing this.

[PatriosTheGreat]

Hi Pavel,
Thank you for review.
Could you also commit this to master, since I don't have commit access?

[labath]

Committed as aedc196101e33bd58f7443c5b93398418ce55edf. I've updated the commit message to include a better description of what is being changed.

[omjavaid]

This breaks LLDB AArch64 Linux buildbot http://lab.llvm.org:8011/builders/lldb-aarch64-ubuntu/builds/1713

[omjavaid]

I have reverted this change temporarily. Please look at the test failure. I ll also do the same at my end. Thanks!

[jarin]

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

465

I think this is not correct: target.xml expects this to be decimal. (This is different from qRegisterInfo, which expects hex.)

[jarin]

lldb/packages/Python/lldbsuite/test/tools/lldb-server/registers-target-xml-reading/TestGdbRemoteTargetXmlPacket.py

70

Why don't you test all the fields here?

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

2783

Nit: Now it is a funny mixture of operator<<, Printfs and PutCString. Is there a reason not to use << for everything? (I guess PutHex8 can't be easily done with <<, but everything else can?)

[jarin]

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

2917

I know this is copy&paste from qRegisterInfo, but should not this be if (reg_info->invalidate_regs && reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM)?

[labath]

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

2783

Yeah, I'm all for using anything else than printf (operator<<, the Format function, etc.). I just didn't feel like raising this point at that time. :/

[PatriosTheGreat]

Hi Muhammad,

Thank you for finding this issue.
After I fix that, could I update current review or should I create new one?

[labath]

Please update the current one to keep the context together.

[PatriosTheGreat]

In this revision I fix value_regnums and invalidate_regnums serialization in target.xml.
However I'm not so sure that this is the cause of problem with ARM tests.

From tests log it seems like there are some unexpected value in register.
Is it possible to get logs output from this test run http://lab.llvm.org:8011/builders/lldb-aarch64-ubuntu/builds/1713/steps/test/logs/stdio that would help us a lot to fix it.

[omjavaid]

I have tested this not sure why it actually failed on the buildbot. The test seems to pass independently. Lets see if the new version fixes the issue.

[PatriosTheGreat]

Hi Muhammad,
Thank you for review.
Could you or Pavel commit this to master, since I don't have commit access?

[omjavaid]

In D74217#1882539, @PatriosTheGreat wrote:

Hi Muhammad,
Thank you for review.
Could you or Pavel commit this to master, since I don't have commit access?

Hi Patrios,

There was some problem with our buildbot and it went down overnight. I have put it back in place and will commit your patch today.

lldb/packages/Python/lldbsuite/test/tools/lldb-server/registers-target-xml-reading/Makefile

+CXX_SOURCES := main.cpp
+
+include Makefile.rules

lldb/packages/Python/lldbsuite/test/tools/lldb-server/registers-target-xml-reading/TestGdbRemoteTargetXmlPacket.py

+
+
+import gdbremote_testcase
+import textwrap
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+import re
+import xml.etree.ElementTree as ET
+
+class TestGdbRemoteTargetXmlPacket(gdbremote_testcase.GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @expectedFailureNetBSD
+    @llgs_test
+    def test_g_target_xml_returns_correct_data(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+
+        procs = self.prep_debug_monitor_and_inferior()
+
+        OFFSET = 0
+        LENGTH = 0x1ffff0
+        self.test_sequence.add_log_lines([
+            "read packet: $qXfer:features:read:target.xml:{:x},{:x}#00".format(
+                    OFFSET,
+                    LENGTH),
+            {   
+                "direction": "send", 
+                "regex": re.compile("^\$l(.+)#[0-9a-fA-F]{2}$"), 
+                "capture": {1: "target_xml"}
+            }],
+            True)
+        context = self.expect_gdbremote_sequence()
+
+        target_xml = context.get("target_xml")
+        
+        root = ET.fromstring(target_xml)
+        self.assertIsNotNone(root)
+        self.assertEqual(root.tag, "target")
+
+        architecture = root.find("architecture")
+        self.assertIsNotNone(architecture)
+        self.assertEqual(architecture.text, self.getArchitecture())
+
+        feature = root.find("feature")
+        self.assertIsNotNone(feature)
+
+        target_xml_registers = feature.findall("reg")
+        self.assertTrue(len(target_xml_registers) > 0)
+
+        # registers info collected by qRegisterInfo
+        self.add_register_info_collection_packets()
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+        q_info_registers = self.parse_register_info_packets(context)
+
+        self.assertTrue(len(target_xml_registers) == len(q_info_registers))
+        for register in zip(target_xml_registers, q_info_registers):
+            xml_info_reg = register[0]
+            q_info_reg = register[1]
+            self.assertEqual(q_info_reg["name"], xml_info_reg.get("name"))
+            self.assertEqual(q_info_reg["set"], xml_info_reg.get("group"))
+            self.assertEqual(q_info_reg["format"], xml_info_reg.get("format"))
+            self.assertEqual(q_info_reg["bitsize"], xml_info_reg.get("bitsize"))
+            self.assertEqual(q_info_reg["offset"], xml_info_reg.get("offset"))
+            self.assertEqual(q_info_reg["encoding"], xml_info_reg.get("encoding"))
 No newline at end of file

lldb/packages/Python/lldbsuite/test/tools/lldb-server/registers-target-xml-reading/main.cpp

+int main() {}

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

GDBRemoteCommunicationServerCommon::Handle_qSupported(
   uint32_t max_packet_size = 128 * 1024; // 128KBytes is a reasonable max packet
                                          // size--debugger can always use less
   response.Printf("PacketSize=%x", max_packet_size);
 
   response.PutCString(";QStartNoAckMode+");
   response.PutCString(";QThreadSuffixSupported+");
   response.PutCString(";QListThreadsInStopReply+");
   response.PutCString(";qEcho+");
+  response.PutCString(";qXfer:features:read+");
 #if defined(__linux__) || defined(__NetBSD__)
   response.PutCString(";QPassSignals+");
   response.PutCString(";qXfer:auxv:read+");
   response.PutCString(";qXfer:libraries-svr4:read+");
 #endif
 
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_QThreadSuffixSupported(
     StringExtractorGDBRemote &packet) {

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h

FileSpec FindModuleFile(const std::string &module_path,
                           const ArchSpec &arch) override;
 
   llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
   ReadXferObject(llvm::StringRef object, llvm::StringRef annex);
 
   static std::string XMLEncodeAttributeValue(llvm::StringRef value);
 
 private:
+  llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> BuildTargetXml();
+
   void HandleInferiorState_Exited(NativeProcessProtocol *process);
 
   void HandleInferiorState_Stopped(NativeProcessProtocol *process);
 
   NativeThreadProtocol *GetThreadFromSuffix(StringExtractorGDBRemote &packet);
 
   uint32_t GetNextSavedRegistersID();
 

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

if (swap) {
     for (i = buf_size - 1; i >= 0; i--)
       response.PutHex8(buf[i]);
   } else {
     for (i = 0; i < buf_size; i++)
       response.PutHex8(buf[i]);
   }
 }
 
+static llvm::StringRef GetEncodingNameOrEmpty(const RegisterInfo *reg_info) {
+  switch (reg_info->encoding) {
+  case eEncodingUint:
+    return "uint";
+  case eEncodingSint:
+    return "sint";
+  case eEncodingIEEE754:
+    return "ieee754";
+  case eEncodingVector:
+    return "vector";
+  default:
+    return "";
+  }
+}
+
+static llvm::StringRef GetFormatNameOrEmpty(const RegisterInfo *reg_info) {
+  switch (reg_info->format) {
+  case eFormatBinary:
+    return "binary";
+  case eFormatDecimal:
+    return "decimal";
+  case eFormatHex:
+    return "hex";
+  case eFormatFloat:
+    return "float";
+  case eFormatVectorOfSInt8:
+    return "vector-sint8";
+  case eFormatVectorOfUInt8:
+    return "vector-uint8";
+  case eFormatVectorOfSInt16:
+    return "vector-sint16";
+  case eFormatVectorOfUInt16:
+    return "vector-uint16";
+  case eFormatVectorOfSInt32:
+    return "vector-sint32";
+  case eFormatVectorOfUInt32:
+    return "vector-uint32";
+  case eFormatVectorOfFloat32:
+    return "vector-float32";
+  case eFormatVectorOfUInt64:
+    return "vector-uint64";
+  case eFormatVectorOfUInt128:
+    return "vector-uint128";
+  default:
+    return "";
+  };
+}
+
+static llvm::StringRef GetKindGenericOrEmpty(const RegisterInfo *reg_info) {
+  switch (reg_info->kinds[RegisterKind::eRegisterKindGeneric]) {
+  case LLDB_REGNUM_GENERIC_PC:
+    return "pc";
+  case LLDB_REGNUM_GENERIC_SP:
+    return "sp";
+  case LLDB_REGNUM_GENERIC_FP:
+    return "fp";
+  case LLDB_REGNUM_GENERIC_RA:
+    return "ra";
+  case LLDB_REGNUM_GENERIC_FLAGS:
+    return "flags";
+  case LLDB_REGNUM_GENERIC_ARG1:
+    return "arg1";
+  case LLDB_REGNUM_GENERIC_ARG2:
+    return "arg2";
+  case LLDB_REGNUM_GENERIC_ARG3:
+    return "arg3";
+  case LLDB_REGNUM_GENERIC_ARG4:
+    return "arg4";
+  case LLDB_REGNUM_GENERIC_ARG5:
+    return "arg5";
+  case LLDB_REGNUM_GENERIC_ARG6:
+    return "arg6";
+  case LLDB_REGNUM_GENERIC_ARG7:
+    return "arg7";
+  case LLDB_REGNUM_GENERIC_ARG8:
+    return "arg8";
+  default:
+    return "";
+  }
+}
+
+static void CollectRegNums(const uint32_t *reg_num,
+                           lldb_private::StreamString response) {
+  for (int i = 0; *reg_num != LLDB_INVALID_REGNUM; ++reg_num, ++i) {
+    if (i > 0)
+      response.PutChar(',');
+    response.Printf("%" PRIx32, *reg_num);
+  }
+}
+
 static void WriteRegisterValueInHexFixedWidth(
     StreamString &response, NativeRegisterContext &reg_ctx,
     const RegisterInfo &reg_info, const RegisterValue *reg_value_p,
     lldb::ByteOrder byte_order) {
   RegisterValue reg_value;
   if (!reg_value_p) {
     Status error = reg_ctx.ReadRegister(&reg_info, reg_value);
     if (error.Success())
       reg_value_p = &reg_value;
     // else log.
   }
 
   if (reg_value_p) {
     AppendHexValue(response, (const uint8_t *)reg_value_p->GetBytes(),
                    reg_value_p->GetByteSize(),
                    byte_order == lldb::eByteOrderLittle);
   } else {
     // Zero-out any unreadable values.
     if (reg_info.byte_size > 0) {
       std::basic_string<uint8_t> zeros(reg_info.byte_size, '\0');
if (reg_info->alt_name && reg_info->alt_name[0]) {
     response.PutCString("alt-name:");
     response.PutCString(reg_info->alt_name);
     response.PutChar(';');
   }
 
   response.Printf("bitsize:%" PRIu32 ";offset:%" PRIu32 ";",
                   reg_info->byte_size * 8, reg_info->byte_offset);
 
-  switch (reg_info->encoding) {
-  case eEncodingUint:
-    response.PutCString("encoding:uint;");
-    break;
-  case eEncodingSint:
-    response.PutCString("encoding:sint;");
-    break;
-  case eEncodingIEEE754:
-    response.PutCString("encoding:ieee754;");
-    break;
-  case eEncodingVector:
-    response.PutCString("encoding:vector;");
-    break;
-  default:
-    break;
-  }
-
-  switch (reg_info->format) {
-  case eFormatBinary:
-    response.PutCString("format:binary;");
-    break;
-  case eFormatDecimal:
-    response.PutCString("format:decimal;");
-    break;
-  case eFormatHex:
-    response.PutCString("format:hex;");
-    break;
-  case eFormatFloat:
-    response.PutCString("format:float;");
-    break;
-  case eFormatVectorOfSInt8:
-    response.PutCString("format:vector-sint8;");
-    break;
-  case eFormatVectorOfUInt8:
-    response.PutCString("format:vector-uint8;");
-    break;
-  case eFormatVectorOfSInt16:
-    response.PutCString("format:vector-sint16;");
-    break;
-  case eFormatVectorOfUInt16:
-    response.PutCString("format:vector-uint16;");
-    break;
-  case eFormatVectorOfSInt32:
-    response.PutCString("format:vector-sint32;");
-    break;
-  case eFormatVectorOfUInt32:
-    response.PutCString("format:vector-uint32;");
-    break;
-  case eFormatVectorOfFloat32:
-    response.PutCString("format:vector-float32;");
-    break;
-  case eFormatVectorOfUInt64:
-    response.PutCString("format:vector-uint64;");
-    break;
-  case eFormatVectorOfUInt128:
-    response.PutCString("format:vector-uint128;");
-    break;
-  default:
-    break;
-  };
+  llvm::StringRef encoding = GetEncodingNameOrEmpty(reg_info);
+  if (!encoding.empty())
+    response << "encoding:" << encoding << ';';
+
+  llvm::StringRef format = GetFormatNameOrEmpty(reg_info);
+  if (!format.empty())
+    response << "format:" << format << ';';
 
   const char *const register_set_name =
       reg_context.GetRegisterSetNameForRegisterAtIndex(reg_index);
-  if (register_set_name) {
-    response.PutCString("set:");
-    response.PutCString(register_set_name);
-    response.PutChar(';');
-  }
+  if (register_set_name)
+    response << "set:" << register_set_name << ';';
 
   if (reg_info->kinds[RegisterKind::eRegisterKindEHFrame] !=
       LLDB_INVALID_REGNUM)
     response.Printf("ehframe:%" PRIu32 ";",
                     reg_info->kinds[RegisterKind::eRegisterKindEHFrame]);
 
   if (reg_info->kinds[RegisterKind::eRegisterKindDWARF] != LLDB_INVALID_REGNUM)
     response.Printf("dwarf:%" PRIu32 ";",
                     reg_info->kinds[RegisterKind::eRegisterKindDWARF]);
 
-  switch (reg_info->kinds[RegisterKind::eRegisterKindGeneric]) {
-  case LLDB_REGNUM_GENERIC_PC:
-    response.PutCString("generic:pc;");
-    break;
-  case LLDB_REGNUM_GENERIC_SP:
-    response.PutCString("generic:sp;");
-    break;
-  case LLDB_REGNUM_GENERIC_FP:
-    response.PutCString("generic:fp;");
-    break;
-  case LLDB_REGNUM_GENERIC_RA:
-    response.PutCString("generic:ra;");
-    break;
-  case LLDB_REGNUM_GENERIC_FLAGS:
-    response.PutCString("generic:flags;");
-    break;
-  case LLDB_REGNUM_GENERIC_ARG1:
-    response.PutCString("generic:arg1;");
-    break;
-  case LLDB_REGNUM_GENERIC_ARG2:
-    response.PutCString("generic:arg2;");
-    break;
-  case LLDB_REGNUM_GENERIC_ARG3:
-    response.PutCString("generic:arg3;");
-    break;
-  case LLDB_REGNUM_GENERIC_ARG4:
-    response.PutCString("generic:arg4;");
-    break;
-  case LLDB_REGNUM_GENERIC_ARG5:
-    response.PutCString("generic:arg5;");
-    break;
-  case LLDB_REGNUM_GENERIC_ARG6:
-    response.PutCString("generic:arg6;");
-    break;
-  case LLDB_REGNUM_GENERIC_ARG7:
-    response.PutCString("generic:arg7;");
-    break;
-  case LLDB_REGNUM_GENERIC_ARG8:
-    response.PutCString("generic:arg8;");
-    break;
-  default:
-    break;
-  }
+  llvm::StringRef kind_generic = GetKindGenericOrEmpty(reg_info);
+  if (!kind_generic.empty())
+    response << "generic:" << kind_generic << ';';
 
   if (reg_info->value_regs && reg_info->value_regs[0] != LLDB_INVALID_REGNUM) {
     response.PutCString("container-regs:");
-    int i = 0;
-    for (const uint32_t *reg_num = reg_info->value_regs;
-         *reg_num != LLDB_INVALID_REGNUM; ++reg_num, ++i) {
-      if (i > 0)
-        response.PutChar(',');
-      response.Printf("%" PRIx32, *reg_num);
-    }
+    CollectRegNums(reg_info->value_regs, response);
     response.PutChar(';');
   }
 
   if (reg_info->invalidate_regs && reg_info->invalidate_regs[0]) {
     response.PutCString("invalidate-regs:");
-    int i = 0;
-    for (const uint32_t *reg_num = reg_info->invalidate_regs;
-         *reg_num != LLDB_INVALID_REGNUM; ++reg_num, ++i) {
-      if (i > 0)
-        response.PutChar(',');
-      response.Printf("%" PRIx32, *reg_num);
-    }
+    CollectRegNums(reg_info->invalidate_regs, response);
     response.PutChar(';');
   }
 
   if (reg_info->dynamic_size_dwarf_expr_bytes) {
     const size_t dwarf_opcode_len = reg_info->dynamic_size_dwarf_len;
     response.PutCString("dynamic_size_dwarf_expr_bytes:");
     for (uint32_t i = 0; i < dwarf_opcode_len; ++i)
       response.PutHex8(reg_info->dynamic_size_dwarf_expr_bytes[i]);
if (error.Fail()) {
     return SendErrorResponse(0x49);
   }
 
   // No response here - the stop or exit will come from the resulting action.
   return PacketResult::Success;
 }
 
 llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
+GDBRemoteCommunicationServerLLGS::BuildTargetXml() {
+  // Ensure we have a thread.
+  NativeThreadProtocol *thread = m_debugged_process_up->GetThreadAtIndex(0);
+  if (!thread)
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "No thread available");
+
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
+  // Get the register context for the first thread.
+  NativeRegisterContext &reg_context = thread->GetRegisterContext();
+
+  StreamString response;
+
+  response.Printf("<?xml version=\"1.0\"?>");
+  response.Printf("<target version=\"1.0\">");
+
+  response.Printf("<architecture>%s</architecture>",
+                  m_debugged_process_up->GetArchitecture()
+                      .GetTriple()
+                      .getArchName()
+                      .str()
+                      .c_str());
+
+  response.Printf("<feature>");
+
+  const int registers_count = reg_context.GetUserRegisterCount();
+  for (int reg_index = 0; reg_index < registers_count; reg_index++) {
+    const RegisterInfo *reg_info =
+        reg_context.GetRegisterInfoAtIndex(reg_index);
+
+    if (!reg_info) {
+      LLDB_LOGF(log,
+                "%s failed to get register info for register index %" PRIu32,
+                "target.xml", reg_index);
+      continue;
+    }
+
+    response.Printf("<reg name=\"%s\" bitsize=\"%" PRIu32 "\" offset=\"%" PRIu32
+                    "\" regnum=\"%d\" ",
+                    reg_info->name, reg_info->byte_size * 8,
+                    reg_info->byte_offset, reg_index);
+
+    if (reg_info->alt_name && reg_info->alt_name[0])
+      response.Printf("altname=\"%s\" ", reg_info->alt_name);
+
+    llvm::StringRef encoding = GetEncodingNameOrEmpty(reg_info);
+    if (!encoding.empty())
+      response << "encoding=\"" << encoding << "\" ";
+
+    llvm::StringRef format = GetFormatNameOrEmpty(reg_info);
+    if (!format.empty())
+      response << "format=\"" << format << "\" ";
+
+    const char *const register_set_name =
+        reg_context.GetRegisterSetNameForRegisterAtIndex(reg_index);
+    if (register_set_name)
+      response << "group=\"" << register_set_name << "\" ";
+
+    if (reg_info->kinds[RegisterKind::eRegisterKindEHFrame] !=
+        LLDB_INVALID_REGNUM)
+      response.Printf("ehframe_regnum=\"%" PRIu32 "\" ",
+                      reg_info->kinds[RegisterKind::eRegisterKindEHFrame]);
+
+    if (reg_info->kinds[RegisterKind::eRegisterKindDWARF] !=
+        LLDB_INVALID_REGNUM)
+      response.Printf("dwarf_regnum=\"%" PRIu32 "\" ",
+                      reg_info->kinds[RegisterKind::eRegisterKindDWARF]);
+
+    llvm::StringRef kind_generic = GetKindGenericOrEmpty(reg_info);
+    if (!kind_generic.empty())
+      response << "generic=\"" << kind_generic << "\" ";
+
+    if (reg_info->value_regs &&
+        reg_info->value_regs[0] != LLDB_INVALID_REGNUM) {
+      response.PutCString("value_regnums=\"");
+      CollectRegNums(reg_info->value_regs, response);
+      response.Printf("\" ");
+    }
+
+    if (reg_info->invalidate_regs && reg_info->invalidate_regs[0]) {
+      response.PutCString("invalidate_regnums=\"");
+      CollectRegNums(reg_info->invalidate_regs, response);
+      response.Printf("\" ");
+    }
+
+    if (reg_info->dynamic_size_dwarf_expr_bytes) {
+      const size_t dwarf_opcode_len = reg_info->dynamic_size_dwarf_len;
+      response.PutCString("dynamic_size_dwarf_expr_bytes=\"");
+      for (uint32_t i = 0; i < dwarf_opcode_len; ++i)
+        response.PutHex8(reg_info->dynamic_size_dwarf_expr_bytes[i]);
+      response.Printf("\" ");
+    }
+
+    response.Printf("/>");
+  }
+
+  response.Printf("</feature>");
+  response.Printf("</target>");
+  return MemoryBuffer::getMemBufferCopy(response.GetString(), "target.xml");
+}
+
+llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
 GDBRemoteCommunicationServerLLGS::ReadXferObject(llvm::StringRef object,
                                                  llvm::StringRef annex) {
-  if (object == "auxv") {
-    // Make sure we have a valid process.
-    if (!m_debugged_process_up ||
-        (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
-      return llvm::createStringError(llvm::inconvertibleErrorCode(),
-                                     "No process available");
-    }
 
+  if (object == "auxv") {
     // Grab the auxv data.
     auto buffer_or_error = m_debugged_process_up->GetAuxvData();
     if (!buffer_or_error)
       return llvm::errorCodeToError(buffer_or_error.getError());
     return std::move(*buffer_or_error);
   }
 
   if (object == "libraries-svr4") {
for (auto const &library : *library_list) {
       response.Printf("lm=\"0x%" PRIx64 "\" ", library.link_map);
       response.Printf("l_addr=\"0x%" PRIx64 "\" ", library.base_addr);
       response.Printf("l_ld=\"0x%" PRIx64 "\" />", library.ld_addr);
     }
     response.Printf("</library-list-svr4>");
     return MemoryBuffer::getMemBufferCopy(response.GetString(), __FUNCTION__);
   }
 
+  if (object == "features" && annex == "target.xml")
+    return BuildTargetXml();
+
   return llvm::make_error<PacketUnimplementedError>(
       "Xfer object not supported");
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qXfer(
     StringExtractorGDBRemote &packet) {
   SmallVector<StringRef, 5> fields;
   // The packet format is "qXfer:<object>:<action>:<annex>:offset,length"
   StringRef(packet.GetStringRef()).split(fields, ':', 4);
   if (fields.size() != 5)
     return SendIllFormedResponse(packet, "malformed qXfer packet");
   StringRef &xfer_object = fields[1];
   StringRef &xfer_action = fields[2];
   StringRef &xfer_annex = fields[3];
   StringExtractor offset_data(fields[4]);
   if (xfer_action != "read")
     return SendUnimplementedResponse("qXfer action not supported");
   // Parse offset.
   const uint64_t xfer_offset =
       offset_data.GetHexMaxU64(false, std::numeric_limits<uint64_t>::max());
   if (xfer_offset == std::numeric_limits<uint64_t>::max())
     return SendIllFormedResponse(packet, "qXfer packet missing offset");
   // Parse out comma.
   if (offset_data.GetChar() != ',')
     return SendIllFormedResponse(packet,
                                  "qXfer packet missing comma after offset");
   // Parse out the length.
   const uint64_t xfer_length =
       offset_data.GetHexMaxU64(false, std::numeric_limits<uint64_t>::max());
   if (xfer_length == std::numeric_limits<uint64_t>::max())
     return SendIllFormedResponse(packet, "qXfer packet missing length");
 
   // Get a previously constructed buffer if it exists or create it now.
   std::string buffer_key = (xfer_object + xfer_action + xfer_annex).str();
   auto buffer_it = m_xfer_buffer_map.find(buffer_key);
   if (buffer_it == m_xfer_buffer_map.end()) {
     auto buffer_up = ReadXferObject(xfer_object, xfer_annex);
     if (!buffer_up)
       return SendErrorResponse(buffer_up.takeError());
     buffer_it = m_xfer_buffer_map
                     .insert(std::make_pair(buffer_key, std::move(*buffer_up)))
                     .first;
   }
 
   // Send back the response
   StreamGDBRemote response;
   bool done_with_buffer = false;
   llvm::StringRef buffer = buffer_it->second->getBuffer();
   if (xfer_offset >= buffer.size()) {
     // We have nothing left to send.  Mark the buffer as complete.
     response.PutChar('l');
     done_with_buffer = true;
   } else {
     // Figure out how many bytes are available starting at the given offset.
     buffer = buffer.drop_front(xfer_offset);
     // Mark the response type according to whether we're reading the remainder
     // of the data.
     if (xfer_length >= buffer.size()) {
       // There will be nothing left to read after this
       response.PutChar('l');
       done_with_buffer = true;
     } else {
       // There will still be bytes to read after this request.
       response.PutChar('m');
       buffer = buffer.take_front(xfer_length);
     }
     // Now write the data in encoded binary form.
     response.PutEscapedBytes(buffer.data(), buffer.size());
   }
 
   if (done_with_buffer)
     m_xfer_buffer_map.erase(buffer_it);
 
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState(
     StringExtractorGDBRemote &packet) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
 
   // Move past packet name.
   packet.SetFilePos(strlen("QSaveRegisterState"));
 
   // Get the thread to use.
   NativeThreadProtocol *thread = GetThreadFromSuffix(packet);
   if (!thread) {
     if (m_thread_suffix_supported)
       return SendIllFormedResponse(
           packet, "No thread specified in QSaveRegisterState packet");
     else
       return SendIllFormedResponse(packet,
                                    "No thread was is set with the Hg packet");
   }
 
   // Grab the register context for the thread.
   NativeRegisterContext& reg_context = thread->GetRegisterContext();
 
   // Save registers to a buffer.
   DataBufferSP register_data_sp;
   Status error = reg_context.ReadAllRegisterValues(register_data_sp);
   if (error.Fail()) {
     LLDB_LOG(log, "pid {0} failed to save all register values: {1}",
              m_debugged_process_up->GetID(), error);
     return SendErrorResponse(0x75);
   }
 
   // Allocate a new save id.
   const uint32_t save_id = GetNextSavedRegistersID();
   assert((m_saved_registers_map.find(save_id) == m_saved_registers_map.end()) &&
          "GetNextRegisterSaveID() returned an existing register save id");
 
   // Save the register data buffer under the save id.
   {
     std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
     m_saved_registers_map[save_id] = register_data_sp;
   }
 
   // Write the response.
   StreamGDBRemote response;
   response.Printf("%" PRIu32, save_id);
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState(
     StringExtractorGDBRemote &packet) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));