LLDB qXfer:features:read support

[ADodds]

Summary

This is a preliminary patch that adds lldb support for querying the register mapping from gdbserver remote targets using qXfer:features:read packet.
I have been testing this patch using x86 gdbserver running on the android emulator however I will be trying more gdbserver flavours (arm/mips) in the next few days.
Since this patch ties into a range of place in LLDB I thought It would be best to submit it early to get some feedback.

With this patch, upon connection to a remote, if lldb has no register information loaded and it sees the target supports qXfer:features:read, it will try to extract register info at that point.
It will parse all scalar registers, and translates this directly into gdb remote dynamic register info. Still to be implemented are vector register and flag register layout parsing.

This is currently enough to enable basic debugging via gdbserver from lldb with no prior knowledge of the target registers.

C&C will be appreciated.

A quick note on how I compiled libxml2 on windows and linked lldb against it:

I downloaded the latest libxml2 snapshot:
ftp://xmlsoft.org/libxml2/libxml2-git-snapshot.tar.gz

After unpacking I navigated to libxml2-2.9.2\win32.

I ran a configuration using the following command:
D:\libxml2\libxml2-2.9.2\win32>cscript configure.js compiler=msvc prefix=c:\opt include=c:\opt\include lib=c:\opt\lib debug=yes iconv=no

use [vcvars32.bat for 32bit] build, or [vcvars64.bat for 64bit] build

to kickstart compilation run:
D:\libxml2\libxml2-2.9.2\win32>nmake /f Makefile.msvc

The libs can be found in the following path:
D:\libxml2\libxml2-2.9.2\win32\bin.msvc

These libs were then supplied when running CMake for llvm:
  LIBXML2_INCLUDE_DIR=D:/libxml2/include
  LIBXML2_LIBRARIES=D:/libxml2/win32/bin.msvc/libxml2.lib

Also, here is a quick view of the initial gdb-rsp transcript for quick reference:

(lldb) log enable gdb-remote packets
(lldb) target create d:/test.so
Current executable set to 'd:/test.so' (i386).
(lldb) gdb-remote 1234
<   1> send packet: +
history[1] tid=0x1dac <   1> send packet: +
<  19> send packet: $QStartNoAckMode#b0
<   1> read packet: +
<   6> read packet: $OK#9a
<   1> send packet: +
<  41> send packet: $qSupported:xmlRegisters=i386,arm,mips#12
< 542> read packet: $PacketSize=3fff;QPassSignals+;QProgramSignals+;qXfer:libraries-svr4:read+;qXfer:auxv:read+;qXfer:spu:read+;qXfer:spu:wr
ite+;qXfer:siginfo:read+;qXfer:siginfo:write+;qXfer:features:read+;QStartNoAckMode+;qXfer:osdata:read+;multiprocess+;QNonStop+;qXfer:threads
:read+;ConditionalTracepoints+;TraceStateVariables+;TracepointSource+;DisconnectedTracing+;StaticTracepoints+;InstallInTrace+;qXfer:statictr
ace:read+;qXfer:traceframe-info:read+;EnableDisableTracepoints+;QTBuffer:size+;tracenz+;ConditionalBreakpoints+;BreakpointCommands+;QAgent+#
9f
<  40> send packet: $qXfer:features:read:target.xml:0,fff#7d
< 582> read packet: $6c3c3f786d6c2076657273696f6e3d22312e30223f3e0a3c212d2d20436f707972696768742028432920323031302d32303133204672656520536f6
6747761726520466f756e646174696f6e2c20496e632e0a0a202a21436f7079696e6720616e6420646973747269627574696f6e206f6620746869732066696c652c207769746
8206f7220776974686f7574206d6f64696669636174696f6e2c0a202a21617265207065726d697474656420696e20616e79206d656469756d20776974686f757420726f79616
c74792070726f76696465642074686520636f707972696768740a202a216e6f7469636520616e642074686973206e6f7469636520617265207072657365727665642e20202d2
d3e0a0a3c212d2d2049333836207769746820535345202d20496e636c75646573204c696e75782d6f6e6c79207370656369616c20227265676973746572222e20202d2d3e0a0
a3c21444f4354595045207461726765742053595354454d20226764622d7461726765742e647464223e0a3c7461726765743e0a20203c6172636869746563747572653e69333
8363c2f6172636869746563747572653e0a20203c6f736162693e474e552f4c696e75783c2f6f736162693e0a20203c78693a696e636c75646520687265663d2233326269742
d636f72652e786d6c222f3e0a20203c78693a696e636c75646520687265663d2233326269742d6c696e75782e786d6c222f3e0a20203c78693a696e636c75646520687265663
d2233326269742d7373652e786d6c222f3e0a3c2f7461726765743e0a#75
noname.xml:14: namespace error : Namespace prefix xi on include is not defined
  <xi:include href="32bit-core.xml"/>
                                   ^
noname.xml:15: namespace error : Namespace prefix xi on include is not defined
  <xi:include href="32bit-linux.xml"/>
                                    ^
noname.xml:16: namespace error : Namespace prefix xi on include is not defined
  <xi:include href="32bit-sse.xml"/>
                                  ^
<  44> send packet: $qXfer:features:read:32bit-core.xml:0,fff#70
<2736> read packet: $6c3c3f786d6c2076657273696f6e3d22312e30223f3e0a3c212d2d20436f707972696768742028432920323031302d32303133204672656520536f6
6747761726520466f756e646174696f6e2c20496e632e0a0a202a21436f7079696e6720616e6420646973747269627574696f6e206f6620746869732066696c652c207769746
8206f7220776974686f7574206d6f64696669636174696f6e2c0a202a21617265207065726d697474656420696e20616e79206d656469756d20776974686f757420726f79616
c74792070726f76696465642074686520636f707972696768740a202a216e6f7469636520616e642074686973206e6f7469636520617265207072657365727665642e20202d2
d3e0a0a3c21444f435459504520666561747572652053595354454d20226764622d7461726765742e647464223e0a3c66656174757265206e616d653d226f72672e676e752e6
764622e693338362e636f7265223e0a20203c666c6167732069643d22693338365f65666c616773222073697a653d2234223e0a202a203c6669656c64206e616d653d2243462
...

Unfortunately, by default libxml2 outputs warnings on stdout as it parses which is why the following messages show up. In a revised patch I will suppress this completely or pipe it into one of the logging channels.

noname.xml:16: namespace error : Namespace prefix xi on include is not defined
  <xi:include href="32bit-sse.xml"/>
                                  ^

[ADodds]

This change adds support for gdbserver running on android Arm. It also fixes a bug where register discovery would bomb out if the osabi name wasnt given in target.xml. I have moved gdbserver register discovery inside of BuildDynamicRegisterInfo() so it will only be used when registers dont already exist (as intended).

[clayborg]

Pretty close, just a few things to fix. We don't need the "gdbserver-compatibility" setting. We should always use the qRegisterInfo packets first, if those aren't supported, then fall back to the "qXfer:features:", and if that fails, then fall back to the target definition python file.

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

380–395 ↗

(On Diff #23677)

No one else is using this function, are you going to need it elsewhere? If not, just inline the contents in the one function that calls it. Otherwise this is fine.

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

110 ↗

(On Diff #23677)

Why do we need a setting for this? We should always try the qRegisterInfo first and then fall back to using the qXfer:features: stuff.

118 ↗

(On Diff #23677)

Do we need this? See comment on line 110 of ProcessGDBRemote.cpp.

164–169 ↗

(On Diff #23677)

Do we need this? See comment on line 110 of ProcessGDBRemote.cpp.

401–404 ↗

(On Diff #23677)

This code should be moved to just after the qRegisterInfo packets are called and it should only be executed if the qRegisterInfo packets are not supported. See non-inlined comments for more info.

1680 ↗

(On Diff #23677)

We should call this first and always try to use the qRegisterInfo packet, and if this fails, fall back to the qXfer:features: and then if that fails, use the target definition file.

[ADodds]

Thanks for having a look at my previous patch Greg. I have made a revision that hopefully addresses all the points you had raised earlier. Any other C&C is welcome.

[clayborg]

A few things to fix:

• remove the unused ePropertyGdbServerCompatibility enum
• Use StringStream instead of std::stringstream to keep things consistent with all other send packets

This:

+ // build the qSupported packet
+ std::vector<std::string> features = {"xmlRegisters=i386,arm,mips"};
+ std::stringstream packet;
+ packet << "qSupported";
+ for ( uint32_t i = 0; i < features.size( ); i++ )
+ packet << (i==0 ? ":" : ";") << features[i];

can become

std::vector<std::string> features = {"xmlRegisters=i386,arm,mips"};
StringStream packet;
packet.PutCString("qSupported");
for (const auto& feature: features)
{

packet.Printf("%c%s", (i==0 ? ':' : ';'), feature.c_str());

}

[ADodds]

Thanks again Greg.

I have hopefully addressed the things you pointed out, apart from one issue with the for loop. I would have liked to use a for each but unfortunately I need to append a different character on the first itteration of the loop, which makes it a little awkward. It seemed to me like the original for loop was less awkward then using a for each and having a new variable to track the first itteration.

[clayborg]

Very nice. All changes look good. Thanks for adding this and improving LLDB's GDB server support!

[dawn]

This comment was removed by dawn.

[dawn]

Removed comment (was added to wrong patch - oops)

[zturner]

I will to have a look, unfortunately after tomorrow I will be away for an
extended period of time and I need to finish something else up before then
too. That being said, I suspect this is just an issue of the number that
is being printed, and not of which tests are actually being run. I didn't
change anything related to what tests run, only how we display the number.
I'm betting those 548 tests are either skipped tests, xfail'ed tests, or
both.

lldb/trunk/cmake/modules/LLDBConfig.cmake

include_directories(BEFORE
   ${CMAKE_CURRENT_BINARY_DIR}/include
   ${CMAKE_CURRENT_SOURCE_DIR}/include
   )
 
 install(DIRECTORY include/
   DESTINATION include
   FILES_MATCHING
   PATTERN "*.h"
-  PATTERN ".svn" EXCLUDE
-  )
-
-
-# Find libraries or frameworks that may be needed
-if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
+  PATTERN ".svn" EXCLUDE
+  )
+
+if (NOT LIBXML2_FOUND)
+  find_package(LibXml2)
+endif()
+
+# Find libraries or frameworks that may be needed
+if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
   find_library(CARBON_LIBRARY Carbon)
   find_library(FOUNDATION_LIBRARY Foundation)
   find_library(CORE_FOUNDATION_LIBRARY CoreFoundation)
   find_library(CORE_SERVICES_LIBRARY CoreServices)
-  find_library(SECURITY_LIBRARY Security)
-  find_library(DEBUG_SYMBOLS_LIBRARY DebugSymbols PATHS "/System/Library/PrivateFrameworks")
-
-  if (NOT LIBXML2_FOUND)
-    find_package(LibXml2)
-  endif ()
-  list(APPEND system_libs xml2 ncurses panel)
-  list(APPEND system_libs ${CARBON_LIBRARY} ${FOUNDATION_LIBRARY}
-  ${CORE_FOUNDATION_LIBRARY} ${CORE_SERVICES_LIBRARY} ${SECURITY_LIBRARY}
-  ${DEBUG_SYMBOLS_LIBRARY})
-endif()
-
-if(LLDB_REQUIRES_EH)
+  find_library(SECURITY_LIBRARY Security)
+  find_library(DEBUG_SYMBOLS_LIBRARY DebugSymbols PATHS "/System/Library/PrivateFrameworks")
+
+  add_definitions( -DLIBXML2_DEFINED )
+  list(APPEND system_libs xml2 ncurses panel)
+  list(APPEND system_libs ${CARBON_LIBRARY} ${FOUNDATION_LIBRARY}
+  ${CORE_FOUNDATION_LIBRARY} ${CORE_SERVICES_LIBRARY} ${SECURITY_LIBRARY}
+  ${DEBUG_SYMBOLS_LIBRARY})
+
+else()
+
+  if (LIBXML2_FOUND)
+    add_definitions( -DLIBXML2_DEFINED )
+    list(APPEND system_libs ${LIBXML2_LIBRARIES})
+    include_directories(${LIBXML2_INCLUDE_DIR})
+  endif()
+
+endif()
+
+if(LLDB_REQUIRES_EH)
   set(LLDB_REQUIRES_RTTI ON)
 else()
   if(LLVM_COMPILER_IS_GCC_COMPATIBLE)
     set(LLDB_COMPILE_FLAGS "${LLDB_COMPILE_FLAGS} -fno-exceptions")
   elseif(MSVC)
     add_definitions( -D_HAS_EXCEPTIONS=0 )
     set(LLDB_COMPILE_FLAGS "${LLDB_COMPILE_FLAGS} /EHs-c-")
   endif()

lldb/trunk/source/Commands/CommandObjectRegister.cpp

DumpRegisterSet (const ExecutionContext &exe_ctx,
         uint32_t available_count = 0;
 
         if (!reg_ctx)
             return false; // thread has no registers (i.e. core files are corrupt, incomplete crash logs...)
 
         const RegisterSet * const reg_set = reg_ctx->GetRegisterSet(set_idx);
         if (reg_set)
         {
-            strm.Printf ("%s:\n", reg_set->name);
+            strm.Printf ("%s:\n", (reg_set->name ? reg_set->name : "unknown") );
             strm.IndentMore ();
             const size_t num_registers = reg_set->num_registers;
             for (size_t reg_idx = 0; reg_idx < num_registers; ++reg_idx)
             {
                 const uint32_t reg = reg_set->registers[reg_idx];
                 const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg);
                 // Skip the dumping of derived register if primitive_only is true.
                 if (primitive_only && reg_info && reg_info->value_regs)

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

public:
     GetQXferLibrariesSVR4ReadSupported ();
 
     uint64_t
     GetRemoteMaxPacketSize();
 
     bool
     GetAugmentedLibrariesSVR4ReadSupported ();
 
+    bool
+    GetQXferFeaturesReadSupported ();
+
     LazyBool
     SupportsAllocDeallocMemory () // const
     {
         // Uncomment this to have lldb pretend the debug server doesn't respond to alloc/dealloc memory packets.
         // m_supports_alloc_dealloc_memory = lldb_private::eLazyBoolNo;
         return m_supports_alloc_dealloc_memory;
     }
 
public:
     bool
     GetThreadExtendedInfoSupported();
 
     bool
     GetModuleInfo (const FileSpec& module_file_spec,
                    const ArchSpec& arch_spec,
                    ModuleSpec &module_spec);
 
+    bool
+    ReadExtFeature (const lldb_private::ConstString object,
+                    const lldb_private::ConstString annex,
+                    std::string & out,
+                    lldb_private::Error & err);
+
 protected:
 
     PacketResult
     SendPacketAndWaitForResponseNoLock (const char *payload,
                                         size_t payload_length,
                                         StringExtractorGDBRemote &response);
 
     bool
protected:
     LazyBool m_prepare_for_reg_writing_reply;
     LazyBool m_supports_p;
     LazyBool m_supports_x;
     LazyBool m_avoid_g_packets;
     LazyBool m_supports_QSaveRegisterState;
     LazyBool m_supports_qXfer_auxv_read;
     LazyBool m_supports_qXfer_libraries_read;
     LazyBool m_supports_qXfer_libraries_svr4_read;
+    LazyBool m_supports_qXfer_features_read;
     LazyBool m_supports_augmented_libraries_svr4_read;
     LazyBool m_supports_jThreadExtendedInfo;
 
     bool
         m_supports_qProcessInfoPID:1,
         m_supports_qfProcessInfo:1,
         m_supports_qUserName:1,
         m_supports_qGroupName:1,

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

GDBRemoteCommunicationClient::GDBRemoteCommunicationClient() :
     m_attach_or_wait_reply(eLazyBoolCalculate),
     m_prepare_for_reg_writing_reply (eLazyBoolCalculate),
     m_supports_p (eLazyBoolCalculate),
     m_supports_x (eLazyBoolCalculate),
     m_avoid_g_packets (eLazyBoolCalculate),
     m_supports_QSaveRegisterState (eLazyBoolCalculate),
     m_supports_qXfer_auxv_read (eLazyBoolCalculate),
     m_supports_qXfer_libraries_read (eLazyBoolCalculate),
+    m_supports_qXfer_features_read (eLazyBoolCalculate),
     m_supports_qXfer_libraries_svr4_read (eLazyBoolCalculate),
     m_supports_augmented_libraries_svr4_read (eLazyBoolCalculate),
     m_supports_jThreadExtendedInfo (eLazyBoolCalculate),
     m_supports_qProcessInfoPID (true),
     m_supports_qfProcessInfo (true),
     m_supports_qUserName (true),
     m_supports_qGroupName (true),
     m_supports_qThreadStopInfo (true),

 {
     if (m_supports_qXfer_auxv_read == eLazyBoolCalculate)
     {
         GetRemoteQSupported();
     }
     return (m_supports_qXfer_auxv_read == eLazyBoolYes);
 }
 
+bool
+GDBRemoteCommunicationClient::GetQXferFeaturesReadSupported ()
+{
+    if (m_supports_qXfer_features_read == eLazyBoolCalculate)
+    {
+        GetRemoteQSupported();
+    }
+    return (m_supports_qXfer_features_read == eLazyBoolYes);
+}
+
 uint64_t
 GDBRemoteCommunicationClient::GetRemoteMaxPacketSize()
 {
     if (m_max_packet_size == 0)
     {
         GetRemoteQSupported();
     }
     return m_max_packet_size;
GDBRemoteCommunicationClient::ResetDiscoverableSettings()
     m_supports_alloc_dealloc_memory = eLazyBoolCalculate;
     m_supports_memory_region_info = eLazyBoolCalculate;
     m_prepare_for_reg_writing_reply = eLazyBoolCalculate;
     m_attach_or_wait_reply = eLazyBoolCalculate;
     m_avoid_g_packets = eLazyBoolCalculate;
     m_supports_qXfer_auxv_read = eLazyBoolCalculate;
     m_supports_qXfer_libraries_read = eLazyBoolCalculate;
     m_supports_qXfer_libraries_svr4_read = eLazyBoolCalculate;
+    m_supports_qXfer_features_read = eLazyBoolCalculate;
     m_supports_augmented_libraries_svr4_read = eLazyBoolCalculate;
 
     m_supports_qProcessInfoPID = true;
     m_supports_qfProcessInfo = true;
     m_supports_qUserName = true;
     m_supports_qGroupName = true;
     m_supports_qThreadStopInfo = true;
     m_supports_z0 = true;

 void
 GDBRemoteCommunicationClient::GetRemoteQSupported ()
 {
     // Clear out any capabilities we expect to see in the qSupported response
     m_supports_qXfer_auxv_read = eLazyBoolNo;
     m_supports_qXfer_libraries_read = eLazyBoolNo;
     m_supports_qXfer_libraries_svr4_read = eLazyBoolNo;
     m_supports_augmented_libraries_svr4_read = eLazyBoolNo;
+    m_supports_qXfer_features_read = eLazyBoolNo;
     m_max_packet_size = UINT64_MAX;  // It's supposed to always be there, but if not, we assume no limit
 
+    // build the qSupported packet
+    std::vector<std::string> features = {"xmlRegisters=i386,arm,mips"};
+    StreamString packet;
+    packet.PutCString( "qSupported" );
+    for ( uint32_t i = 0; i < features.size( ); ++i )
+    {
+        packet.PutCString( i==0 ? ":" : ";");
+        packet.PutCString( features[i].c_str( ) );
+    }
+
     StringExtractorGDBRemote response;
-    if (SendPacketAndWaitForResponse("qSupported",
+    if (SendPacketAndWaitForResponse(packet.GetData(),
                                      response,
                                      /*send_async=*/false) == PacketResult::Success)
     {
         const char *response_cstr = response.GetStringRef().c_str();
         if (::strstr (response_cstr, "qXfer:auxv:read+"))
             m_supports_qXfer_auxv_read = eLazyBoolYes;
         if (::strstr (response_cstr, "qXfer:libraries-svr4:read+"))
             m_supports_qXfer_libraries_svr4_read = eLazyBoolYes;
         if (::strstr (response_cstr, "augmented-libraries-svr4-read"))
         {
             m_supports_qXfer_libraries_svr4_read = eLazyBoolYes;  // implied
             m_supports_augmented_libraries_svr4_read = eLazyBoolYes;
         }
         if (::strstr (response_cstr, "qXfer:libraries:read+"))
             m_supports_qXfer_libraries_read = eLazyBoolYes;
+        if (::strstr (response_cstr, "qXfer:features:read+"))
+            m_supports_qXfer_features_read = eLazyBoolYes;
 
         const char *packet_size_str = ::strstr (response_cstr, "PacketSize=");
         if (packet_size_str)
         {
             StringExtractorGDBRemote packet_response(packet_size_str + strlen("PacketSize="));
             m_max_packet_size = packet_response.GetHexMaxU64(/*little_endian=*/false, UINT64_MAX);
             if (m_max_packet_size == 0)
             {
while (response.GetNameColonValue (name, value))
             extractor.SetFilePos (0);
             extractor.GetHexByteString (value);
             module_spec.GetFileSpec () = FileSpec (value.c_str(), false);
         }
     }
 
     return true;
 }
+
+// query the target remote for extended information using the qXfer packet
+//
+// example: object='features', annex='target.xml', out=<xml output>
+// return:  'true'  on success
+//          'false' on failure (err set)
+bool
+GDBRemoteCommunicationClient::ReadExtFeature (const lldb_private::ConstString object,
+                                              const lldb_private::ConstString annex,
+                                              std::string & out,
+                                              lldb_private::Error & err) {
+
+    std::stringstream output;
+    StringExtractorGDBRemote chunk;
+
+    const int size   = 0xfff;
+    int       offset = 0;
+    bool      active = true;
+
+    // loop until all data has been read
+    while ( active ) {
+
+        // send query extended feature packet
+        std::stringstream packet;
+        packet << "qXfer:" 
+               << object.AsCString( ) << ":read:" 
+               << annex.AsCString( )  << ":" 
+               << std::hex << offset  << "," 
+               << std::hex << size;
+
+        GDBRemoteCommunication::PacketResult res =
+            SendPacketAndWaitForResponse( packet.str().c_str(),
+                                          chunk,
+                                          false );
+
+        if ( res != GDBRemoteCommunication::PacketResult::Success ) {
+            err.SetErrorString( "Error sending $qXfer packet" );
+            return false;
+        }
+
+        const std::string & str = chunk.GetStringRef( );
+        if ( str.length() == 0 ) {
+            // should have some data in chunk
+            err.SetErrorString( "Empty response from $qXfer packet" );
+            return false;
+        }
+
+        // check packet code
+        switch ( str[0] ) {
+            // last chunk
+        case ( 'l' ):
+            active = false;
+            // fall through intensional
+
+            // more chunks
+        case ( 'm' ) :
+            if ( str.length() > 1 )
+                output << &str[1];
+            break;
+
+            // unknown chunk
+        default:
+            err.SetErrorString( "Invalid continuation code from $qXfer packet" );
+            return false;
+        }
+    }
+
+    out = output.str( );
+    err.Success( );
+    return true;
+}

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

public:
     void
     SetUserSpecifiedMaxMemoryTransferSize (uint64_t user_specified_max);
 
     bool
     GetModuleSpec(const FileSpec& module_file_spec,
                   const ArchSpec& arch,
                   ModuleSpec &module_spec) override;
 
+    // query remote gdbserver for information
+    bool
+    GetGDBServerInfo ( );
+
 protected:
     friend class ThreadGDBRemote;
     friend class GDBRemoteCommunicationClient;
     friend class GDBRemoteRegisterContext;
 
     //----------------------------------------------------------------------
     // Accessors
     //----------------------------------------------------------------------

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

 #include <time.h>
 
 // C++ Includes
 #include <algorithm>
 #include <map>
 #include <mutex>
 
 // Other libraries and framework includes
+#if defined( LIBXML2_DEFINED )
+#include <libxml/xmlreader.h>
+#endif
 
 #include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Core/Module.h"
ProcessGDBRemote::BuildDynamicRegisterInfo (bool force)
     if (host_packet_timeout)
     {
         GetGlobalPluginProperties()->SetPacketTimeout(host_packet_timeout);
     }
     
 
     if (reg_num == 0)
     {
+        // try to extract information from servers target.xml
+        if ( GetGDBServerInfo( ) )
+            return;
+
         FileSpec target_definition_fspec = GetGlobalPluginProperties()->GetTargetDefinitionFile ();
         
         if (target_definition_fspec)
         {
             // See if we can get register definitions from a python file
             if (ParsePythonTargetDefinition (target_definition_fspec))
                 return;
         }
if (log)
         log->Printf ("ProcessGDBRemote::%s - got module info for (%s:%s) : %s",
                      __FUNCTION__, module_file_spec.GetPath ().c_str (),
                      arch.GetTriple ().getTriple ().c_str (), stream.GetString ().c_str ());
     }
 
     return true;
 }
 
+#if defined( LIBXML2_DEFINED )
+namespace {
+
+typedef std::vector<std::string> stringVec;
+typedef std::vector<xmlNodePtr> xmlNodePtrVec;
+
+struct GdbServerRegisterInfo {
+
+    struct {
+        bool m_has_name     : 1;
+        bool m_has_bitSize  : 1;
+        bool m_has_type     : 1;
+        bool m_has_group    : 1;
+        bool m_has_regNum   : 1;
+    }
+    m_flags;
+
+    std::string m_name;
+    std::string m_group;
+    uint32_t    m_bitSize;
+    uint32_t    m_regNum;
+
+    enum RegType {
+        eUnknown   ,
+        eCodePtr   ,
+        eDataPtr   ,
+        eInt32     ,
+        eI387Ext   ,
+    }
+    m_type;
+
+    void clear(  ) {
+        memset( &m_flags, 0, sizeof( m_flags ) );
+    }
+};
+
+typedef std::vector<struct GdbServerRegisterInfo> GDBServerRegisterVec;
+
+struct GdbServerTargetInfo {
+
+    std::string m_arch;
+    std::string m_osabi;
+};
+
+// conversion table between gdb register type and enum
+struct {
+    const char * m_name;
+    GdbServerRegisterInfo::RegType m_type;
+}
+RegTypeTable[] = {
+    { "int32"   , GdbServerRegisterInfo::eInt32    },
+    { "int"     , GdbServerRegisterInfo::eInt32    },
+    { "data_ptr", GdbServerRegisterInfo::eDataPtr  },
+    { "code_ptr", GdbServerRegisterInfo::eCodePtr  },
+    { "i387_ext", GdbServerRegisterInfo::eI387Ext  }, // 80bit fpu
+    { nullptr } // sentinel
+};
+
+// find the first sibling with a matching name
+xmlNodePtr
+xmlExFindSibling (xmlNodePtr node,
+                  const std::string & name) {
+
+    if ( !node ) return nullptr;
+    // iterate through all siblings
+    for ( xmlNodePtr temp = node; temp; temp=temp->next ) {
+        // we are looking for elements
+        if ( temp->type != XML_ELEMENT_NODE )
+            continue;
+        // check element name matches
+        if ( !temp->name ) continue;
+        if ( std::strcmp((const char*)temp->name, name.c_str() ) == 0 )
+            return temp;
+    }
+    // no sibling found
+    return nullptr;
+}
+
+// find an element from a given element path
+xmlNodePtr
+xmlExFindElement (xmlNodePtr node,
+                  const stringVec & path) {
+
+    if ( !node ) return nullptr;
+    xmlNodePtr temp = node;
+    // iterate all elements in path
+    for ( uint32_t i = 0; i < path.size( ); i++ ) {
+
+        // search for a sibling with this name
+        temp = xmlExFindSibling( temp, path[i] );
+        if ( !temp )
+            return nullptr;
+        // enter this node if we still need to search
+        if ( (i+1) < path.size() )
+            // enter the node we have found
+            temp = temp->children;
+    }
+    // note: node may still be nullptr at this step
+    return temp;
+}
+
+// locate a specific attribute in an element
+xmlAttr *
+xmlExFindAttribute (xmlNodePtr node, 
+                    const std::string & name) {
+
+    if ( !node )
+        return nullptr;
+    if ( node->type != XML_ELEMENT_NODE )
+        return nullptr;
+    // iterate over all attributes
+    for ( xmlAttrPtr attr = node->properties; attr != nullptr; attr=attr->next ) {
+        // check if name matches
+        if ( !attr->name ) continue;
+        if ( std::strcmp( (const char*)attr->name, name.c_str( ) ) == 0 )
+            return attr;
+    }
+    return nullptr;
+}
+
+// find all child elements with given name and add them to a vector
+//
+// input:   node = xml element to search
+//          name = name used when matching child elements
+// output:  out  = list of matches
+// return:  number of children added to 'out'
+int
+xmlExFindChildren (xmlNodePtr node, 
+                   const std::string & name, 
+                   xmlNodePtrVec & out) {
+
+    if ( !node ) return 0;
+    int count = 0;
+    // iterate over all children
+    for ( xmlNodePtr child = node->children; child; child = child->next ) {
+        // if name matches
+        if ( !child->name ) continue;
+        if ( std::strcmp( (const char*)child->name, name.c_str( ) ) == 0 ) {
+            // add to output list
+            out.push_back( child );
+            ++count;
+        }
+    }
+    return count;
+}
+
+// get the text content from an attribute
+std::string
+xmlExGetTextContent (xmlAttrPtr attr) {
+
+    if ( !attr )
+        return std::string( );
+    if ( attr->type != XML_ATTRIBUTE_NODE )
+        return std::string( );
+    // check child is a text node
+    xmlNodePtr child = attr->children;
+    if ( child->type != XML_TEXT_NODE )
+        return std::string( );
+    // access the content
+    assert( child->content != nullptr );
+    return std::string( (const char*) child->content );
+}
+
+// get the text content from an node
+std::string
+xmlExGetTextContent (xmlNodePtr node) {
+
+    if ( !node )
+        return std::string( );
+    if ( node->type != XML_ELEMENT_NODE )
+        return std::string( );
+    // check child is a text node
+    xmlNodePtr child = node->children;
+    if ( child->type != XML_TEXT_NODE )
+        return std::string( );
+    // access the content
+    assert( child->content != nullptr );
+    return std::string( (const char*) child->content );
+}
+
+// compile a list of xml includes from the target file
+// input:   doc = target.xml
+// output:  includes = list of .xml names specified in target.xml
+// return:  number of .xml files specified in target.xml and added to includes
+int
+parseTargetIncludes (xmlDocPtr doc, stringVec & includes) {
+
+    if ( !doc ) return 0;
+    int count = 0;
+    xmlNodePtr elm = xmlExFindElement( doc->children, { "target" } );
+    if (! elm ) return 0;
+    xmlNodePtrVec nodes;
+    xmlExFindChildren( elm, "xi:include", nodes );
+    // iterate over all includes
+    for ( uint32_t i = 0; i < nodes.size(); i++ ) {
+        xmlAttrPtr attr = xmlExFindAttribute( nodes[i], "href" );
+        if ( attr != nullptr ) {
+            std::string text = xmlExGetTextContent( attr );
+            includes.push_back( text );
+            ++count;
+        }
+    }
+    return count;
+}
+
+// extract target arch information from the target.xml file
+// input:   doc = target.xml document
+// output:  out = remote target information
+// return:  'true'  on success
+//          'false' on failure
+bool
+parseTargetInfo (xmlDocPtr doc, GdbServerTargetInfo & out) {
+
+    if ( !doc ) return false;
+    xmlNodePtr e1 = xmlExFindElement( doc->children, { "target", "architecture" } );
+    if ( !e1 ) return false;
+    out.m_arch = xmlExGetTextContent( e1 );
+    
+    xmlNodePtr e2 = xmlExFindElement( doc->children, { "target", "osabi" } );
+    if ( !e2 ) return false;
+    out.m_osabi = xmlExGetTextContent( e2 );
+
+    return true;
+}
+
+// extract register information from one of the xml files specified in target.xml
+// input:   doc = xml document
+// output:  regList = list of extracted register info
+// return:  'true'  on success
+//          'false' on failure
+bool
+parseRegisters (xmlDocPtr doc, GDBServerRegisterVec & regList) {
+
+    if ( !doc ) return false;
+    xmlNodePtr elm = xmlExFindElement( doc->children, { "feature" } );
+    if ( !elm ) return false;
+
+    xmlAttrPtr attr = nullptr;
+
+    xmlNodePtrVec regs;
+    xmlExFindChildren( elm, "reg", regs );
+    for ( int i = 0; i < regs.size( ); i++ ) {
+
+        GdbServerRegisterInfo reg;
+        reg.clear( );
+
+        if ( attr = xmlExFindAttribute( regs[i], "name" ) ) {
+            reg.m_name = xmlExGetTextContent( attr ).c_str();
+            reg.m_flags.m_has_name = true;
+        }
+
+        if ( attr = xmlExFindAttribute( regs[i], "bitsize" ) ) {
+            const std::string v = xmlExGetTextContent( attr );
+            reg.m_bitSize = atoi( v.c_str( ) );
+            reg.m_flags.m_has_bitSize = true;
+        }
+
+        if ( attr = xmlExFindAttribute( regs[i], "type" ) ) {
+            const std::string v = xmlExGetTextContent( attr );
+            reg.m_type = GdbServerRegisterInfo::eUnknown;
+
+            // search the type table for a match
+            for ( int j = 0; RegTypeTable[j].m_name !=nullptr ;++j ) {
+                if (RegTypeTable[j].m_name == v) {
+                    reg.m_type = RegTypeTable[j].m_type;
+                    break;
+                }
+            }
+
+            reg.m_flags.m_has_type = (reg.m_type != GdbServerRegisterInfo::eUnknown);
+        }
+
+        if ( attr = xmlExFindAttribute( regs[i], "group" ) ) {
+            reg.m_group = xmlExGetTextContent( attr );
+            reg.m_flags.m_has_group = true;
+        }
+
+        if ( attr = xmlExFindAttribute( regs[i], "regnum" ) ) {
+            const std::string v = xmlExGetTextContent( attr );
+            reg.m_regNum = atoi( v.c_str( ) );
+            reg.m_flags.m_has_regNum = true;
+        }
+
+        regList.push_back( reg );
+    }
+
+    //TODO: there is also a "vector" element to parse
+    //TODO: there is also eflags to parse
+
+    return true;
+}
+
+// build lldb gdb-remote's dynamic register info from a vector of gdb provided registers
+// input:   regList = register information provided by gdbserver
+// output:  regInfo = dynamic register information required by gdb-remote
+void
+BuildRegisters (const GDBServerRegisterVec & regList,
+                GDBRemoteDynamicRegisterInfo & regInfo) {
+
+    using namespace lldb_private;
+
+    const uint32_t defSize    = 32;
+          uint32_t regNum     = 0;
+          uint32_t byteOffset = 0;
+
+    for ( uint32_t i = 0; i < regList.size( ); ++i ) {
+
+        const GdbServerRegisterInfo & gdbReg = regList[i];
+
+        std::string name     = gdbReg.m_flags.m_has_name    ? gdbReg.m_name        : "unknown";
+        std::string group    = gdbReg.m_flags.m_has_group   ? gdbReg.m_group       : "general";
+        uint32_t    byteSize = gdbReg.m_flags.m_has_bitSize ? (gdbReg.m_bitSize/8) : defSize;
+
+        if ( gdbReg.m_flags.m_has_regNum )
+            regNum = gdbReg.m_regNum;
+
+        uint32_t regNumGcc     = LLDB_INVALID_REGNUM;
+        uint32_t regNumDwarf   = LLDB_INVALID_REGNUM;
+        uint32_t regNumGeneric = LLDB_INVALID_REGNUM;
+        uint32_t regNumGdb     = regNum;
+        uint32_t regNumNative  = regNum;
+
+        if ( name == "eip" || name == "pc" ) {
+            regNumGeneric = LLDB_REGNUM_GENERIC_PC;
+        }
+        if ( name == "esp" || name == "sp" ) {
+            regNumGeneric = LLDB_REGNUM_GENERIC_SP;
+        }
+        if ( name == "ebp") {
+            regNumGeneric = LLDB_REGNUM_GENERIC_FP;
+        }
+        if ( name == "lr" ) {
+            regNumGeneric = LLDB_REGNUM_GENERIC_RA;
+        }
+
+        RegisterInfo info = {
+            name.c_str(),
+            nullptr     ,
+            byteSize    ,
+            byteOffset  ,
+            lldb::Encoding::eEncodingUint,
+            lldb::Format::eFormatDefault,
+            { regNumGcc    , 
+              regNumDwarf  , 
+              regNumGeneric,
+              regNumGdb    ,
+              regNumNative },
+            nullptr,
+            nullptr
+        };
+
+        ConstString regName    = ConstString( gdbReg.m_name );
+        ConstString regAltName = ConstString( );
+        ConstString regGroup   = ConstString( group );
+        regInfo.AddRegister( info, regName, regAltName, regGroup );
+
+        // advance register info
+        byteOffset += byteSize;
+        regNum     += 1;
+    }
+
+    regInfo.Finalize ();
+}
+
+} // namespace {}
+
+void XMLCDECL
+libxml2NullErrorFunc (void *ctx, const char *msg, ...)
+{
+    // do nothing currently
+}
+
+// query the target of gdb-remote for extended target information
+// return:  'true'  on success
+//          'false' on failure
+bool
+ProcessGDBRemote::GetGDBServerInfo ()
+{
+
+    // redirect libxml2's error handler since the default prints to stdout
+    xmlGenericErrorFunc func = libxml2NullErrorFunc;
+    initGenericErrorDefaultFunc( &func );
+
+    GDBRemoteCommunicationClient & comm = m_gdb_comm;
+    GDBRemoteDynamicRegisterInfo & regInfo = m_register_info;
+
+    // check that we have extended feature read support
+    if ( !comm.GetQXferFeaturesReadSupported( ) )
+        return false;
+
+    // request the target xml file
+    std::string raw;
+    lldb_private::Error lldberr;
+    if (! comm.ReadExtFeature( ConstString( "features" ),
+                               ConstString( "target.xml" ),
+                               raw, 
+                               lldberr ) ) {
+        return false;
+    }
+
+    // parse the xml file in memory
+    xmlDocPtr doc = xmlReadMemory( raw.c_str( ), raw.size( ), "noname.xml", nullptr, 0 );
+    if ( doc == nullptr )
+        return false;
+
+    // extract target info from target.xml
+    GdbServerTargetInfo gdbInfo;
+    if ( parseTargetInfo( doc, gdbInfo ) ) {
+        // NOTE: We could deduce triple from gdbInfo if lldb doesn't already have one set
+    }
+
+    // collect registers from all of the includes
+    GDBServerRegisterVec regList;
+    stringVec includes;
+    if ( parseTargetIncludes( doc, includes ) > 0 ) {
+
+        for ( uint32_t i = 0; i < includes.size( ); ++i ) {
+
+            // request register file
+            if ( !comm.ReadExtFeature( ConstString( "features" ),
+                                       ConstString( includes[i] ),
+                                       raw,
+                                       lldberr ) )
+                continue;
+
+            // parse register file
+            xmlDocPtr regXml = xmlReadMemory( raw.c_str(), 
+                                              raw.size( ), 
+                                              includes[i].c_str(), 
+                                              nullptr, 
+                                              0 );
+            if ( !regXml )
+                continue;
+
+            // pass registers to lldb
+            parseRegisters( regXml, regList );
+        }
+    }
+
+    // pass all of these registers to lldb
+    BuildRegisters( regList, regInfo );
+
+    return true;
+}
+
+#else // if defined( LIBXML2_DEFINED )
+
+using namespace lldb_private::process_gdb_remote;
+
+bool
+ProcessGDBRemote::GetGDBServerInfo ()
+{
+    // stub (libxml2 not present)
+    return false;
+}
+
+#endif // if defined( LIBXML2_DEFINED )
+
+
 class CommandObjectProcessGDBRemotePacketHistory : public CommandObjectParsed
 {
 private:
     
 public:
     CommandObjectProcessGDBRemotePacketHistory(CommandInterpreter &interpreter) :
     CommandObjectParsed (interpreter,
                          "process plugin packet history",