Implement qXfer:libraries:read.

[sas]

Summary

This is used on non-unix platforms, where qXfer:libraries-svr4:read
doesn't make sense. Windows uses that for instance.

[clayborg]

Looks good.

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

ProcessGDBRemote::GetLoadedModuleList (GDBLoadedModuleInfoList & list)
 
     Log *log = GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS);
     if (log)
         log->Printf ("ProcessGDBRemote::%s", __FUNCTION__);
 
     GDBRemoteCommunicationClient & comm = m_gdb_comm;
 
     // check that we have extended feature read support
-    if (!comm.GetQXferLibrariesSVR4ReadSupported ())
-        return Error (0, ErrorType::eErrorTypeGeneric);
-
+    if (comm.GetQXferLibrariesSVR4ReadSupported ()) {
         list.clear ();
 
         // request the loaded library list
         std::string raw;
         lldb_private::Error lldberr;
+
         if (!comm.ReadExtFeature (ConstString ("libraries-svr4"), ConstString (""), raw, lldberr))
           return Error (0, ErrorType::eErrorTypeGeneric);
 
         // parse the xml file in memory
         if (log)
             log->Printf ("parsing: %s", raw.c_str());
         XMLDocument doc;
         
         if (!doc.ParseMemory(raw.c_str(), raw.size(), "noname.xml"))
             return Error (0, ErrorType::eErrorTypeGeneric);
 
         XMLNode root_element = doc.GetRootElement("library-list-svr4");
         if (!root_element)
             return Error();
 
         // main link map structure
         llvm::StringRef main_lm = root_element.GetAttributeValue("main-lm");
         if (!main_lm.empty())
         {
             list.m_link_map = StringConvert::ToUInt64(main_lm.data(), LLDB_INVALID_ADDRESS, 0);
         }
 
         root_element.ForEachChildElementWithName("library", [log, &list](const XMLNode &library) -> bool {
 
             GDBLoadedModuleInfoList::LoadedModuleInfo module;
 
             library.ForEachAttribute([log, &module](const llvm::StringRef &name, const llvm::StringRef &value) -> bool {
                 
                 if (name == "name")
                     module.set_name (value.str());
                 else if (name == "lm")
                 {
                     // the address of the link_map struct.
                     module.set_link_map(StringConvert::ToUInt64(value.data(), LLDB_INVALID_ADDRESS, 0));
                 }
                 else if (name == "l_addr")
                 {
                     // the displacement as read from the field 'l_addr' of the link_map struct.
                     module.set_base(StringConvert::ToUInt64(value.data(), LLDB_INVALID_ADDRESS, 0));
                     
                 }
                 else if (name == "l_ld")
                 {
                     // the memory address of the libraries PT_DYAMIC section.
                     module.set_dynamic(StringConvert::ToUInt64(value.data(), LLDB_INVALID_ADDRESS, 0));
                 }
                 
                 return true; // Keep iterating over all properties of "library"
             });
 
             if (log)
             {
                 std::string name;
                 lldb::addr_t lm=0, base=0, ld=0;
 
                 module.get_name (name);
                 module.get_link_map (lm);
                 module.get_base (base);
                 module.get_dynamic (ld);
 
                 log->Printf ("found (link_map:0x08%" PRIx64 ", base:0x08%" PRIx64 ", ld:0x08%" PRIx64 ", name:'%s')", lm, base, ld, name.c_str());
             }
 
             list.add (module);
             return true; // Keep iterating over all "library" elements in the root node
         });
 
         if (log)
             log->Printf ("found %" PRId32 " modules in total", (int) list.m_list.size());
+    } else if (comm.GetQXferLibrariesReadSupported ()) {
+        list.clear ();
+
+        // request the loaded library list
+        std::string raw;
+        lldb_private::Error lldberr;
+
+        if (!comm.ReadExtFeature (ConstString ("libraries"), ConstString (""), raw, lldberr))
+          return Error (0, ErrorType::eErrorTypeGeneric);
+
+        if (log)
+            log->Printf ("parsing: %s", raw.c_str());
+        XMLDocument doc;
+
+        if (!doc.ParseMemory(raw.c_str(), raw.size(), "noname.xml"))
+            return Error (0, ErrorType::eErrorTypeGeneric);
+
+        XMLNode root_element = doc.GetRootElement("library-list");
+        if (!root_element)
+            return Error();
+
+        root_element.ForEachChildElementWithName("library", [log, &list](const XMLNode &library) -> bool {
+            GDBLoadedModuleInfoList::LoadedModuleInfo module;
+
+            llvm::StringRef name = library.GetAttributeValue("name");
+            module.set_name(name.str());
+
+            // The base address of a given library will be the address of its
+            // first section. Most remotes send only one section for Windows
+            // targets for example.
+            const XMLNode &section = library.FindFirstChildElementWithName("section");
+            llvm::StringRef address = section.GetAttributeValue("address");
+            module.set_base(StringConvert::ToUInt64(address.data(), LLDB_INVALID_ADDRESS, 0));
+
+            if (log)
+            {
+                std::string name;
+                lldb::addr_t base = 0;
+                module.get_name (name);
+                module.get_base (base);
+
+                log->Printf ("found (base:0x%" PRIx64 ", name:'%s')", base, name.c_str());
+            }
+
+            list.add (module);
+            return true; // Keep iterating over all "library" elements in the root node
+        });
+
+        if (log)
+            log->Printf ("found %" PRId32 " modules in total", (int) list.m_list.size());
+    } else {
+        return Error (0, ErrorType::eErrorTypeGeneric);
+    }
 
     return Error();
 }
 
 lldb::ModuleSP
 ProcessGDBRemote::LoadModuleAtAddress (const FileSpec &file, lldb::addr_t base_addr)
 {
     Target &target = m_process->GetTarget();