Add SBDebugger::GetBuildConfiguration and use it to skip an XML test

[labath]

Summary

This adds a SBDebugger::GetBuildConfiguration static function, which
returns a SBStructuredData describing the the build parameters of
liblldb. Right now, it just contains one entry: whether we were built
with XML support.

I use the new functionality to skip a test which requires XML support,
but concievably the new function could be useful to other liblldb
clients as well (making sure the library supports the feature they are
about to use).

[clayborg]

Think if we want to cache the configuration in case we start using this a lot more in the test suite. Doesn't need to be done now.

packages/Python/lldbsuite/test/decorators.py

767–771 ↗

(On Diff #134403)

Might be nice to read all values from lldb.SBDebugger.GetBuildConfiguration() and store them one time? If we start using this all the time for many decorators, it would be a good idea to cache it. Thinking something like:

lldb_config = None
def getLLDBConfig():
  global lldb_config
  if lldb_config is None:
      lldb_config = lldb.SBDebugger.GetBuildConfiguration()
  return lldb_config

def skipIfXmlSupportMissing(func):
  config = getLLDBConfig()
  ...

[jingham]

Caching this value wouldn't hurt, but the the multi-process runner will mostly defeat that so it doesn't seem crucial.

The API is fine, the name is pretty obvious, but still some doc wouldn't hurt.

I was wondering if there was a straightforward way we could document the elements. Be nice not to have to read source to see what these mean. OTOH, I don't think we want to produce it in this dictionary, that makes the checks more expensive. So if we find we need it we can add a doc API that generates a parallel doc tree. But I don't think it's necessary to do that right now.

[clayborg]

source/API/SBDebugger.cpp

497 ↗

(On Diff #134403)

Do we want a more self documenting format of the JSON? Maybe "xml" is a dictionary instead of just a value?

{ 
  "xml" : {
    "value" : true, 
    "description" : "A boolean value that indicates if XML support is enabled in LLDB" 
  }
}

[labath]

I've updated the format to include a description of the item. I don't we need to
worry about the expensiveness of this data structure too much, as it should
never be used in a hot loop (the only use case I can think of is querying the
configuration at start-up).

[clayborg]

Looks good. Self describing and concise.

[jingham]

Excellent, thanks.

lldb/trunk/include/lldb/API/SBDebugger.h

public:
   static bool SetDefaultArchitecture(const char *arch_name);
 
   lldb::ScriptLanguage GetScriptingLanguage(const char *script_language_name);
 
   static const char *GetVersionString();
 
   static const char *StateAsCString(lldb::StateType state);
 
+  static SBStructuredData GetBuildConfiguration();
+
   static bool StateIsRunningState(lldb::StateType state);
 
   static bool StateIsStoppedState(lldb::StateType state);
 
   bool EnableLog(const char *channel, const char **categories);
 
   void SetLoggingCallback(lldb::LogOutputCallback log_callback, void *baton);
 

lldb/trunk/packages/Python/lldbsuite/test/decorators.py

def is_compiler_with_address_sanitizer(self):
         cmd = "echo 'int main() {}' | %s -x c -o %s -" % (compiler_path, f.name)
         if os.popen(cmd).close() is not None:
             return None  # The compiler cannot compile at all, let's *not* skip the test
         cmd = "echo 'int main() {}' | %s -fsanitize=address -x c -o %s -" % (compiler_path, f.name)
         if os.popen(cmd).close() is not None:
             return "Compiler cannot compile with -fsanitize=address"
         return None
     return skipTestIfFn(is_compiler_with_address_sanitizer)(func)
+
+def skipIfXmlSupportMissing(func):
+    config = lldb.SBDebugger.GetBuildConfiguration()
+    xml = config.GetValueForKey("xml")
+
+    fail_value = True # More likely to notice if something goes wrong
+    have_xml = xml.GetValueForKey("value").GetBooleanValue(fail_value)
+    return unittest2.skipIf(not have_xml, "requires xml support")(func)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/gdb_remote_client/TestTargetXMLArch.py

 from __future__ import print_function
 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 from gdbclientutils import *
 
 class TestTargetXMLArch(GDBRemoteTestBase):
 
-    @skipIf(hostoslist=no_match(lldbplatformutil.getDarwinOSTriples()))
+    @skipIfXmlSupportMissing
     @expectedFailureAll(archs=["i386"])
     @skipIfRemote
     def test(self):
         """
         Test lldb's parsing of the <architecture> tag in the target.xml register
         description packet.
         """
         class MyResponder(MockGDBServerResponder):

lldb/trunk/scripts/interface/SBDebugger.i

public:
     GetScriptingLanguage (const char *script_language_name);
 
     static const char *
     GetVersionString ();
 
     static const char *
     StateAsCString (lldb::StateType state);
 
+    static SBStructuredData GetBuildConfiguration();
+
     static bool
     StateIsRunningState (lldb::StateType state);
 
     static bool
     StateIsStoppedState (lldb::StateType state);
 
     bool
     EnableLog (const char *channel, const char ** types);

lldb/trunk/source/API/SBDebugger.cpp

 #include "lldb/API/SystemInitializerFull.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/DataFormatters/DataVisualization.h"
+#include "lldb/Host/XML.h"
 #include "lldb/Initialization/SystemLifetimeManager.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/OptionGroupPlatform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/TargetList.h"
 
 #include "llvm/ADT/STLExtras.h"

 const char *SBDebugger::GetVersionString() {
   return lldb_private::GetVersion();
 }
 
 const char *SBDebugger::StateAsCString(StateType state) {
   return lldb_private::StateAsCString(state);
 }
 
+static void AddBoolConfigEntry(StructuredData::Dictionary &dict,
+                               llvm::StringRef name, bool value,
+                               llvm::StringRef description) {
+  auto entry_up = llvm::make_unique<StructuredData::Dictionary>();
+  entry_up->AddBooleanItem("value", value);
+  entry_up->AddStringItem("description", description);
+  dict.AddItem(name, std::move(entry_up));
+}
+
+SBStructuredData SBDebugger::GetBuildConfiguration() {
+  auto config_up = llvm::make_unique<StructuredData::Dictionary>();
+  AddBoolConfigEntry(
+      *config_up, "xml", XMLDocument::XMLEnabled(),
+      "A boolean value that indicates if XML support is enabled in LLDB");
+
+  SBStructuredData data;
+  data.m_impl_up->SetObjectSP(std::move(config_up));
+  return data;
+}
+
 bool SBDebugger::StateIsRunningState(StateType state) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   const bool result = lldb_private::StateIsRunningState(state);
   if (log)
     log->Printf("SBDebugger::StateIsRunningState (state=%s) => %i",
                 StateAsCString(state), result);