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

2816

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

2822

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

2829

"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

1

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

849

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.

2786–2910

Please move this into a separate function

2788–2792

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

2841–2843

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

2871–2894

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

1786

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 << ';';

2788

no braces

2798

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

[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

2798

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

2830

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

2798

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

+#include <cstdint>
+
+int main() {
+#if defined(__x86_64__)
+  struct alignas(16) xmm_t {
+    uint64_t a, b;
+  };
+  uint64_t r8 = 0x0102030405060708;
+  uint64_t r9 = 0x1112131415161718;
+  uint64_t r10 = 0x2122232425262728;
+  uint64_t r11 = 0x3132333435363738;
+  uint64_t r12 = 0x4142434445464748;
+  uint64_t r13 = 0x5152535455565758;
+  uint64_t r14 = 0x6162636465666768;
+  uint64_t r15 = 0x7172737475767778;
+
+  xmm_t xmm8 = {0x020406080A0C0E01, 0x030507090B0D0F00};
+  xmm_t xmm9 = {0x121416181A1C1E11, 0x131517191B1D1F10};
+  xmm_t xmm10 = {0x222426282A2C2E21, 0x232527292B2D2F20};
+  xmm_t xmm11 = {0x323436383A3C3E31, 0x333537393B3D3F30};
+  xmm_t xmm12 = {0x424446484A4C4E41, 0x434547494B4D4F40};
+  xmm_t xmm13 = {0x525456585A5C5E51, 0x535557595B5D5F50};
+  xmm_t xmm14 = {0x626466686A6C6E61, 0x636567696B6D6F60};
+  xmm_t xmm15 = {0x727476787A7C7E71, 0x737577797B7D7F70};
+
+  asm volatile("movq    %0, %%r8\n\t"
+               "movq    %1, %%r9\n\t"
+               "movq    %2, %%r10\n\t"
+               "movq    %3, %%r11\n\t"
+               "movq    %4, %%r12\n\t"
+               "movq    %5, %%r13\n\t"
+               "movq    %6, %%r14\n\t"
+               "movq    %7, %%r15\n\t"
+               "\n\t"
+               "movaps  %8, %%xmm8\n\t"
+               "movaps  %9, %%xmm9\n\t"
+               "movaps  %10, %%xmm10\n\t"
+               "movaps  %11, %%xmm11\n\t"
+               "movaps  %12, %%xmm12\n\t"
+               "movaps  %13, %%xmm13\n\t"
+               "movaps  %14, %%xmm14\n\t"
+               "movaps  %15, %%xmm15\n\t"
+               "\n\t"
+               "int3"
+               :
+               : "g"(r8), "g"(r9), "g"(r10), "g"(r11), "g"(r12), "g"(r13),
+                 "g"(r14), "g"(r15), "m"(xmm8), "m"(xmm9), "m"(xmm10),
+                 "m"(xmm11), "m"(xmm12), "m"(xmm13), "m"(xmm14), "m"(xmm15)
+               : "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15",
+                 "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13",
+                 "%xmm14", "%xmm15");
+#endif
+  return 0;
+}

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

GDBRemoteCommunicationServerCommon::Handle_qSupported(
 
   response.PutCString(";QStartNoAckMode+");
   response.PutCString(";QThreadSuffixSupported+");
   response.PutCString(";QListThreadsInStopReply+");
   response.PutCString(";qEcho+");
 #if defined(__linux__) || defined(__NetBSD__)
   response.PutCString(";QPassSignals+");
   response.PutCString(";qXfer:auxv:read+");
+  response.PutCString(";qXfer:features:read+");
   response.PutCString(";qXfer:libraries-svr4:read+");
 #endif
 
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_QThreadSuffixSupported(

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 std::string 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 std::string 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 std::string 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 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');
       AppendHexValue(response, zeros.data(), zeros.size(), false);
     }
   }
 }
 
 static llvm::Expected<json::Object>
 GetRegistersAsJSON(NativeThreadProtocol &thread) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
 
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;
+  std::string encoding = GetEncodingNameOrEmpty(reg_info);
+  if (!encoding.empty()) {
+    response.PutCString("encoding:");
+    response.PutCString(encoding.c_str());
+    response.PutChar(';');
   }
 
-  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;
-  };
+  std::string format = GetFormatNameOrEmpty(reg_info);
+  if (!format.empty()) {
+    response.PutCString("format:");
+    response.PutCString(format.c_str());
+    response.PutChar(';');
+  }
 
   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 (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;
+  std::string kind_generic = GetKindGenericOrEmpty(reg_info);
+  if (!kind_generic.empty()) {
+    response.PutCString("generic:");
+    response.PutCString(kind_generic.c_str());
+    response.PutChar(';');
   }
 
   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)
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") {
+    // 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");
+    }
+
+    // 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);
+      }
+
+      std::string encoding = GetEncodingNameOrEmpty(reg_info);
+      if (!encoding.empty()) {
+        response.Printf("encoding=\"%s\" ", encoding.c_str());
+      }
+
+      std::string format = GetFormatNameOrEmpty(reg_info);
+      if (!format.empty()) {
+        response.Printf("format=\"%s\" ", format.c_str());
+      }
+
+      const char *const register_set_name =
+          reg_context.GetRegisterSetNameForRegisterAtIndex(reg_index);
+      if (register_set_name) {
+        response.Printf("group=\"%s\" ", 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]);
+
+      std::string kind_generic = GetKindGenericOrEmpty(reg_info);
+      if (!kind_generic.empty()) {
+        response.Printf("generic=\"%s\" ", kind_generic.c_str());
+      }
+
+      if (reg_info->value_regs &&
+          reg_info->value_regs[0] != LLDB_INVALID_REGNUM) {
+        response.PutCString("value_regnums=\"");
+        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);
+        }
+        response.Printf("\" ");
+      }
+
+      if (reg_info->invalidate_regs && reg_info->invalidate_regs[0]) {
+        response.PutCString("invalidate_regnums=\"");
+        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);
+        }
+        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");
+  }
+
   return llvm::make_error<PacketUnimplementedError>(
       "Xfer object not supported");
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qXfer(
     StringExtractorGDBRemote &packet) {
   SmallVector<StringRef, 5> fields;