Add SBDebugger::GetSetting() public API

[yinghuitan]

Summary

This patch adds new SBDebugger::GetSetting() API which
enables client to access settings as SBStructuredData.

Implementation wise, a new ToJSON() virtual function is added to OptionValue
class so that each concrete child class can override and provides its
own JSON representation. This patch aims to define the APIs and implement
a common set of OptionValue child classes, leaving the remaining for
future patches.

This patch is used later by auto deduce source map from source line breakpoint
feature for testing generated source map entries.

[yinghuitan]

Re-diff with clang-format

[jingham]

I'm a little sad that we don't yet have a way to read the current value of a setting into an SBStructuredData, so we do this piecemeal instead. But that's a bigger project, so if you need this now, it doesn't seem fair to block you on that. We should really name the output SBStructuredData keys more instructively, however.

lldb/include/lldb/API/SBTarget.h

91 ↗

(On Diff #457046)

You have to say what the structure is so people will know how to fetch the elements.

lldb/source/API/SBTarget.cpp

222 ↗

(On Diff #457046)

It seems a little round-about to convert the source map to JSON, then from JSON to an SBStructuredData. You should be able to write the elements directly. I'm not sure how much that matters, however.

lldb/source/Target/PathMappingList.cpp

138

Can we call these something more instructive than "first" and "second"? These are the "original" path and the "substitution" path, maybe those would be good keys?

[clayborg]

lldb/bindings/interface/SBTarget.i

969 ↗

(On Diff #457046)

Do we want to actually have something more like this:

lldb::SBStructuredData GetSetting(const char *setting);

That allows us to get any setting as structured data? We have a lot of settings and I would rather not have an API for each one of these added to the public API as we need them.

Eventually we could also have:

void SetSetting(lldb::SBStructuredData &data);

This would allow the output to contain multiple settings if needed. Hopefully the output would be in the format of:

{ "target.source-map": [["<orig-path>", "<replace-path>"], ...] }

This would allow us to export all settings, and then import them.

lldb/source/Target/PathMappingList.cpp

138

We can either do this as a key/value pair thing or just as a array of array path pairs in JSON?

[yinghuitan]

Address review feedback.

[clayborg]

lldb/bindings/interface/SBDebugger.i

228

remove this and document the function below such that "setting" can be NULL or empty for to get all settings. Maybe also document that anything that you can type as an argument for "settings show" should work here. See the output of "settings show target" for an example.

Examples that should work here are:

lldb::SBStructuredData settings = debugger.GetSetting(nullptr); // Get all settings
lldb::SBStructuredData settings = debugger.GetSetting(""); // Get all settings
lldb::SBStructuredData settings = debugger.GetSetting("target.arg0"); // Get 1 specific setting
lldb::SBStructuredData settings = debugger.GetSetting("target.arg0 target.language"); // Get 2 specific settings
lldb::SBStructuredData settings = debugger.GetSetting("target"); // Get all target specific settings

So basically anything you can type into "settings show" should work here.

lldb/include/lldb/API/SBDebugger.h

118

remove

lldb/include/lldb/Interpreter/OptionValue.h

88

89

lldb/source/API/SBDebugger.cpp

439–455

Remove this function. We should have only one that takes a "const char *settings"

464

No need to create a shared pointer here.

467

471

lldb/source/Interpreter/OptionValueArray.cpp

81–83

omit braces for single line for statement per llvm guidelines

lldb/source/Interpreter/OptionValueDictionary.cpp

89–90

Use modern C++ iterator style:

for (const auto &value: m_values) {

92–93

This is a dictionary, we already have a key/value to use

lldb/test/API/commands/settings/TestSettings.py

806

we should test values that have strings that contain reserved JSON characters. I believe '\' can be in a string and will need to be double desensitized. Also string values that contain the string quote characters like a string "hello \"world\""

[hawkinsw]

lldb/test/API/functionalities/source-map/TestTargetSourceMap.py

25

Sorry if this comment is not helpful, but I was wondering ...

Could we use source_map_setting_path here? That would make future changes easier?

[yinghuitan]

Address review comments

[yinghuitan]

This comment has been deleted.

lldb/test/API/functionalities/source-map/TestTargetSourceMap.py

25

@hawkinsw, sorry, almost missed your comment. There is no single value for source map path but a pair of original/replacement. In this case, original is "." while the replacement is "src_dir" so I think src_dir makes sense here.

[hawkinsw]

lldb/test/API/functionalities/source-map/TestTargetSourceMap.py

25

No problem! I am sorry I miscommunicated! I just meant, could we write something like

self.runCmd('settings set %s . "%s"' % (source_map_setting_path, src_dir))

[clayborg]

lldb/include/lldb/API/SBDebugger.h

119

We still don't need two actual APIs in SBDebugger.h. Remove this.

136

We can default "settings = nullptr" here so users can call without anything, but we should have only 1 API function for getting the settings.

lldb/include/lldb/Interpreter/OptionValue.h

89

Add a comment here. Suggested comment added.

lldb/include/lldb/Interpreter/OptionValueChar.h

34–37

Since this is actually a character, it should store what ever the character value is. So if the character is zero, it should store zero, not a string "(null)"

lldb/source/API/SBDebugger.cpp

439–443

Remove this and only keep the one that takes a 'const char *setting"'

lldb/source/Interpreter/OptionValueDictionary.cpp

92

I think this move can be removed? Watch for warnings here. Some buildbots have warnings as errors which could cause the submission to be reverted.

lldb/test/API/commands/settings/TestSettings.py

799

We need to set a few more settings for anything we support the ToJSON for to ensure they function as expected.

lldb/test/API/functionalities/source-map/TestTargetSourceMap.py

25

Good idea!

[yinghuitan]

lldb/include/lldb/Interpreter/OptionValueChar.h

34–37

I am not sure about this. This mimics what OptionValueChar::DumpValue() does. Do we want to keep consistence here?

[yinghuitan]

Address review comments

[clayborg]

Just a comment fix and allow the "char" option value to be saved as zero and this will be good to go.

lldb/include/lldb/API/SBDebugger.h

120–121

This comment is no longer true right? Any setting args that are accepted by settings show not longer is true right? It is just a single setting value you can either specify or not right?

lldb/include/lldb/Interpreter/OptionValueChar.h

34–37

if we want to set/restore this value, it should have the correct value. We aren't trying to mimic dump value here. So we should allow it to be set to zero.

34–37

[yinghuitan]

Address review comments

[JDevlieghere]

lldb/include/lldb/Core/UserSettingsController.h

62–64

A flag doesn't scale if we ever decide we need another format. An enum would solve that and would eliminate the need for a comment /*is_json=*/. I think the two values could be Plain` (or Text) and JSON.

lldb/include/lldb/Interpreter/OptionValue.h

86–87

Is this done?

lldb/source/Core/UserSettingsController.cpp

63

Earlier you said that ToJSON should never return NULL. We should enforce that with an assert here.

lldb/source/Interpreter/OptionValueArray.cpp

80–81

lldb/source/Interpreter/OptionValueDictionary.cpp

89–91

[yinghuitan]

lldb/include/lldb/Interpreter/OptionValue.h

86–87

No. My goal is simply adding a public API for testing auto deduce source map feature, this patch is much larger than I wanted to achieve so it focuses adding skeleton of the API and implements a subset of OptionValue child classes leaving the remaining for future patches (the implementation is not hard but adding test coverage takes some time).

lldb/bindings/interface/SBDebugger.i

%extend {
             return self->GetOutputFile().GetFile();
         }
 
         lldb::FileSP GetErrorFileHandle() {
             return self->GetErrorFile().GetFile();
         }
     }
 
+    lldb::SBStructuredData GetSetting(const char *setting = nullptr);
+
     SBError
     SetInputString (const char* data);
 
     SBError
     SetInputFile (SBFile file);
 
     SBError
     SetOutputFile (SBFile file);

lldb/include/lldb/API/SBDebugger.h

public:
   static void MemoryPressureDetected();
 
   explicit operator bool() const;
 
   bool IsValid() const;
 
   void Clear();
 
+  /// Getting a specific setting value into SBStructuredData format.
+  /// Client can specify empty string or null to get all settings.
+  ///
+  /// Example usages:
+  /// lldb::SBStructuredData settings = debugger.GetSetting();
+  /// lldb::SBStructuredData settings = debugger.GetSetting(nullptr);
+  /// lldb::SBStructuredData settings = debugger.GetSetting("");
+  /// lldb::SBStructuredData settings = debugger.GetSetting("target.arg0");
+  /// lldb::SBStructuredData settings = debugger.GetSetting("target");
+  ///
+  /// \param[out] setting
+  ///   Property setting path to retrieve values. e.g "target.source-map"
+  ///
+  lldb::SBStructuredData GetSetting(const char *setting = nullptr);
+
   void SetAsync(bool b);
 
   bool GetAsync();
 
   void SkipLLDBInitFiles(bool b);
 
   void SkipAppInitFiles(bool b);
 
   void SetInputFileHandle(FILE *f, bool transfer_ownership);
 
   void SetOutputFileHandle(FILE *f, bool transfer_ownership);
 

lldb/include/lldb/Core/UserSettingsController.h

public:
 
   virtual Status SetPropertyValue(const ExecutionContext *exe_ctx,
                                   VarSetOperationType op,
                                   llvm::StringRef property_path,
                                   llvm::StringRef value);
 
   virtual Status DumpPropertyValue(const ExecutionContext *exe_ctx,
                                    Stream &strm, llvm::StringRef property_path,
-                                   uint32_t dump_mask);
+                                   uint32_t dump_mask, bool is_json = false);
 
   virtual void DumpAllPropertyValues(const ExecutionContext *exe_ctx,
-                                     Stream &strm, uint32_t dump_mask);
+                                     Stream &strm, uint32_t dump_mask,
+                                     bool is_json = false);
 
   virtual void DumpAllDescriptions(CommandInterpreter &interpreter,
                                    Stream &strm) const;
 
   size_t Apropos(llvm::StringRef keyword,
                  std::vector<const Property *> &matching_properties) const;
 
   lldb::OptionValuePropertiesSP GetSubProperty(const ExecutionContext *exe_ctx,

lldb/include/lldb/Interpreter/OptionValue.h

 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Utility/Cloneable.h"
 #include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-private-enumerations.h"
 #include "lldb/lldb-private-interfaces.h"
+#include "llvm/Support/JSON.h"
 
 namespace lldb_private {
 
 // OptionValue
 class OptionValue {
 public:
   enum Type {
     eTypeInvalid = 0,
virtual const char *GetTypeAsCString() const {
     return GetBuiltinTypeAsCString(GetType());
   }
 
   static const char *GetBuiltinTypeAsCString(Type t);
 
   virtual void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                          uint32_t dump_mask) = 0;
 
+  // TODO: make this function pure virtual after implementing it in all
+  // child classes.
+  virtual llvm::json::Value ToJSON(const ExecutionContext *exe_ctx) {
+    // Return nullptr which will create a llvm::json::Value() that is a NULL
+    // value. No setting should ever really have a NULL value in JSON. This
+    // indicates an error occurred and if/when we add a FromJSON() it will know
+    // to fail if someone tries to set it with a NULL JSON value.
+    return nullptr;
+  }
+
   virtual Status
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign);
 
   virtual void Clear() = 0;
 
   virtual lldb::OptionValueSP
   DeepCopy(const lldb::OptionValueSP &new_parent) const;

lldb/include/lldb/Interpreter/OptionValueArray.h

public:
 
   // Virtual subclass pure virtual overrides
 
   OptionValue::Type GetType() const override { return eTypeArray; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
+  llvm::json::Value ToJSON(const ExecutionContext *exe_ctx) override;
+
   Status
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
 
   void Clear() override {
     m_values.clear();
     m_value_was_set = false;
   }

lldb/include/lldb/Interpreter/OptionValueBoolean.h

public:
 
   // Virtual subclass pure virtual overrides
 
   OptionValue::Type GetType() const override { return eTypeBoolean; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
+  llvm::json::Value ToJSON(const ExecutionContext *exe_ctx) override {
+    return m_current_value;
+  }
+
   Status
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
 
   void Clear() override {
     m_current_value = m_default_value;
     m_value_was_set = false;
   }

lldb/include/lldb/Interpreter/OptionValueChar.h

public:
 
   // Virtual subclass pure virtual overrides
 
   OptionValue::Type GetType() const override { return eTypeChar; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
+  llvm::json::Value ToJSON(const ExecutionContext *exe_ctx) override {
+    return m_current_value;
+  }
+
   Status
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
 
   void Clear() override {
     m_current_value = m_default_value;
     m_value_was_set = false;
   }
 

lldb/include/lldb/Interpreter/OptionValueDictionary.h

public:
 
   // Virtual subclass pure virtual overrides
 
   OptionValue::Type GetType() const override { return eTypeDictionary; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
+  llvm::json::Value ToJSON(const ExecutionContext *exe_ctx) override;
+
   Status
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
 
   void Clear() override {
     m_values.clear();
     m_value_was_set = false;
   }

lldb/include/lldb/Interpreter/OptionValueFileSpec.h

public:
 
   // Virtual subclass pure virtual overrides
 
   OptionValue::Type GetType() const override { return eTypeFileSpec; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
+  llvm::json::Value ToJSON(const ExecutionContext *exe_ctx) override {
+    return m_current_value.GetPath();
+  }
+
   Status
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
 
   void Clear() override {
     m_current_value = m_default_value;
     m_value_was_set = false;
     m_data_sp.reset();

lldb/include/lldb/Interpreter/OptionValueFormat.h

public:
 
   // Virtual subclass pure virtual overrides
 
   OptionValue::Type GetType() const override { return eTypeFormat; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
+  llvm::json::Value ToJSON(const ExecutionContext *exe_ctx) override;
+
   Status
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
 
   void Clear() override {
     m_current_value = m_default_value;
     m_value_was_set = false;
   }

lldb/include/lldb/Interpreter/OptionValueFormatEntity.h

public:
 
   // Virtual subclass pure virtual overrides
 
   OptionValue::Type GetType() const override { return eTypeFormatEntity; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
+  llvm::json::Value ToJSON(const ExecutionContext *exe_ctx) override;
+
   Status
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
 
   void Clear() override;
 
   void AutoComplete(CommandInterpreter &interpreter,
                     CompletionRequest &request) override;

lldb/include/lldb/Interpreter/OptionValueLanguage.h

public:
 
   // Virtual subclass pure virtual overrides
 
   OptionValue::Type GetType() const override { return eTypeLanguage; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
+  llvm::json::Value ToJSON(const ExecutionContext *exe_ctx) override;
+
   Status
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
 
   void Clear() override {
     m_current_value = m_default_value;
     m_value_was_set = false;
   }

lldb/include/lldb/Interpreter/OptionValuePathMappings.h

public:
 
   // Virtual subclass pure virtual overrides
 
   OptionValue::Type GetType() const override { return eTypePathMap; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
+  llvm::json::Value ToJSON(const ExecutionContext *exe_ctx) override;
+
   Status
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
 
   void Clear() override {
     m_path_mappings.Clear(m_notify_changes);
     m_value_was_set = false;
   }

lldb/include/lldb/Interpreter/OptionValueProperties.h

public:
 
   Status
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
+  llvm::json::Value ToJSON(const ExecutionContext *exe_ctx) override;
+
   ConstString GetName() const override { return m_name; }
 
   virtual Status DumpPropertyValue(const ExecutionContext *exe_ctx,
                                    Stream &strm, llvm::StringRef property_path,
-                                   uint32_t dump_mask);
+                                   uint32_t dump_mask, bool is_json = false);
 
   virtual void DumpAllDescriptions(CommandInterpreter &interpreter,
                                    Stream &strm) const;
 
   void Apropos(llvm::StringRef keyword,
                std::vector<const Property *> &matching_properties) const;
 
   void Initialize(const PropertyDefinitions &setting_definitions);

lldb/include/lldb/Interpreter/OptionValueRegex.h

public:
 
   // Virtual subclass pure virtual overrides
 
   OptionValue::Type GetType() const override { return eTypeRegex; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
+  llvm::json::Value ToJSON(const ExecutionContext *exe_ctx) override {
+    return m_regex.GetText();
+  }
+
   Status
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
 
   void Clear() override {
     m_regex = RegularExpression(m_default_regex_str);
     m_value_was_set = false;
   }

lldb/include/lldb/Interpreter/OptionValueSInt64.h

public:
 
   // Virtual subclass pure virtual overrides
 
   OptionValue::Type GetType() const override { return eTypeSInt64; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
+  llvm::json::Value ToJSON(const ExecutionContext *exe_ctx) override {
+    return m_current_value;
+  }
+
   Status
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
 
   void Clear() override {
     m_current_value = m_default_value;
     m_value_was_set = false;
   }

lldb/include/lldb/Interpreter/OptionValueString.h

public:
 
   // Virtual subclass pure virtual overrides
 
   OptionValue::Type GetType() const override { return eTypeString; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
+  llvm::json::Value ToJSON(const ExecutionContext *exe_ctx) override {
+    return m_current_value;
+  }
+
   Status
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
 
   void Clear() override {
     m_current_value = m_default_value;
     m_value_was_set = false;
   }
if (value && value[0])
       m_default_value.assign(value);
     else
       m_default_value.clear();
   }
 
   bool IsCurrentValueEmpty() const { return m_current_value.empty(); }
 
   bool IsDefaultValueEmpty() const { return m_default_value.empty(); }
-  
   void SetValidator(ValidatorCallback validator, void *baton = nullptr) {
     m_validator = validator;
     m_validator_baton = baton;
   }
 
 protected:
   std::string m_current_value;
   std::string m_default_value;
   Flags m_options;
   ValidatorCallback m_validator = nullptr;
   void *m_validator_baton = nullptr;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_OPTIONVALUESTRING_H

lldb/include/lldb/Interpreter/OptionValueUInt64.h

public:
   static lldb::OptionValueSP Create(llvm::StringRef value_str, Status &error);
   // Virtual subclass pure virtual overrides
 
   OptionValue::Type GetType() const override { return eTypeUInt64; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
+  llvm::json::Value ToJSON(const ExecutionContext *exe_ctx) override {
+    return m_current_value;
+  }
+
   Status
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
 
   void Clear() override {
     m_current_value = m_default_value;
     m_value_was_set = false;
   }

lldb/include/lldb/Interpreter/OptionValueUUID.h

public:
 
   // Virtual subclass pure virtual overrides
 
   OptionValue::Type GetType() const override { return eTypeUUID; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
+  llvm::json::Value ToJSON(const ExecutionContext *exe_ctx) override {
+    return m_uuid.GetAsString();
+  }
+
   Status
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
 
   void Clear() override {
     m_uuid.Clear();
     m_value_was_set = false;
   }

lldb/include/lldb/Target/PathMappingList.h

 //===-- PathMappingList.h ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_TARGET_PATHMAPPINGLIST_H
 #define LLDB_TARGET_PATHMAPPINGLIST_H
 
-#include <map>
-#include <vector>
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Status.h"
+#include "llvm/Support/JSON.h"
+#include <map>
+#include <vector>
 
 namespace lldb_private {
 
 class PathMappingList {
 public:
   typedef void (*ChangedCallback)(const PathMappingList &path_list,
                                   void *baton);
 
public:
 
   void Append(const PathMappingList &rhs, bool notify);
 
   void Clear(bool notify);
 
   // By default, dump all pairs.
   void Dump(Stream *s, int pair_index = -1);
 
+  llvm::json::Value ToJSON();
+
   bool IsEmpty() const { return m_pairs.empty(); }
 
   size_t GetSize() const { return m_pairs.size(); }
 
   bool GetPathsAtIndex(uint32_t idx, ConstString &path,
                        ConstString &new_path) const;
 
   void Insert(llvm::StringRef path, llvm::StringRef replacement,

lldb/source/API/SBDebugger.cpp

SBError SBDebugger::SetErrorFile(SBFile file) {
   if (!file) {
     error.ref().SetErrorString("invalid file");
     return error;
   }
   m_opaque_sp->SetErrorFile(file.m_opaque_sp);
   return error;
 }
 
+lldb::SBStructuredData SBDebugger::GetSetting(const char *setting) {
+  LLDB_INSTRUMENT_VA(this, setting);
+
+  SBStructuredData data;
+  if (!m_opaque_sp)
+    return data;
+
+  StreamString json_strm;
+  ExecutionContext exe_ctx(
+      m_opaque_sp->GetCommandInterpreter().GetExecutionContext());
+  if (setting && strlen(setting) > 0)
+    m_opaque_sp->DumpPropertyValue(&exe_ctx, json_strm, setting,
+                                   /*dump_mask*/ 0,
+                                   /*is_json*/ true);
+  else
+    m_opaque_sp->DumpAllPropertyValues(&exe_ctx, json_strm, /*dump_mask*/ 0,
+                                       /*is_json*/ true);
+
+  data.m_impl_up->SetObjectSP(
+      StructuredData::ParseJSON(json_strm.GetString().str()));
+  return data;
+}
+
 FILE *SBDebugger::GetInputFileHandle() {
   LLDB_INSTRUMENT_VA(this);
   if (m_opaque_sp) {
     File &file_sp = m_opaque_sp->GetInputFile();
     return file_sp.GetStream();
   }
   return nullptr;
 }
 
 SBFile SBDebugger::GetInputFile() {
   LLDB_INSTRUMENT_VA(this);
   if (m_opaque_sp) {
     return SBFile(m_opaque_sp->GetInputFileSP());
   }
   return SBFile();
 }
 
 FILE *SBDebugger::GetOutputFileHandle() {

lldb/source/Core/UserSettingsController.cpp

Status Properties::SetPropertyValue(const ExecutionContext *exe_ctx,
   if (properties_sp)
     return properties_sp->SetSubValue(exe_ctx, op, path, value);
   Status error;
   error.SetErrorString("no properties");
   return error;
 }
 
 void Properties::DumpAllPropertyValues(const ExecutionContext *exe_ctx,
-                                       Stream &strm, uint32_t dump_mask) {
+                                       Stream &strm, uint32_t dump_mask,
+                                       bool is_json) {
   OptionValuePropertiesSP properties_sp(GetValueProperties());
-  if (properties_sp)
-    return properties_sp->DumpValue(exe_ctx, strm, dump_mask);
+  if (!properties_sp)
+    return;
+
+  if (is_json) {
+    llvm::json::Value json = properties_sp->ToJSON(exe_ctx);
+    strm.Printf("%s", llvm::formatv("{0:2}", json).str().c_str());
+  } else
+    properties_sp->DumpValue(exe_ctx, strm, dump_mask);
 }
 
 void Properties::DumpAllDescriptions(CommandInterpreter &interpreter,
                                      Stream &strm) const {
   strm.PutCString("Top level variables:\n\n");
 
   OptionValuePropertiesSP properties_sp(GetValueProperties());
   if (properties_sp)
     return properties_sp->DumpAllDescriptions(interpreter, strm);
 }
 
 Status Properties::DumpPropertyValue(const ExecutionContext *exe_ctx,
                                      Stream &strm,
                                      llvm::StringRef property_path,
-                                     uint32_t dump_mask) {
+                                     uint32_t dump_mask, bool is_json) {
   OptionValuePropertiesSP properties_sp(GetValueProperties());
   if (properties_sp) {
     return properties_sp->DumpPropertyValue(exe_ctx, strm, property_path,
-                                            dump_mask);
+                                            dump_mask, is_json);
   }
   Status error;
   error.SetErrorString("empty property list");
   return error;
 }
 
 size_t
 Properties::Apropos(llvm::StringRef keyword,

lldb/source/Interpreter/OptionValueArray.cpp

for (uint32_t i = 0; i < size; ++i) {
         strm << ' ';
       }
     }
     if (!one_line)
       strm.IndentLess();
   }
 }
 
+llvm::json::Value OptionValueArray::ToJSON(const ExecutionContext *exe_ctx) {
+  llvm::json::Array json_array;
+  const uint32_t size = m_values.size();
+  for (uint32_t i = 0; i < size; ++i)
+    json_array.emplace_back(m_values[i]->ToJSON(exe_ctx));
+  return json_array;
+}
+
 Status OptionValueArray::SetValueFromString(llvm::StringRef value,
                                             VarSetOperationType op) {
   Args args(value.str());
   Status error = SetArgs(args, op);
   if (error.Success())
     NotifyValueChanged();
   return error;
 }

lldb/source/Interpreter/OptionValueDictionary.cpp

for (pos = m_values.begin(); pos != end; ++pos) {
         break;
       }
     }
     if (!one_line)
       strm.IndentLess();
   }
 }
 
+llvm::json::Value
+OptionValueDictionary::ToJSON(const ExecutionContext *exe_ctx) {
+  llvm::json::Object dict;
+  for (const auto &value : m_values) {
+    dict.try_emplace(value.first.GetCString(), value.second->ToJSON(exe_ctx));
+  }
+  return dict;
+}
+
 size_t OptionValueDictionary::GetArgs(Args &args) const {
   args.Clear();
   collection::const_iterator pos, end = m_values.end();
   for (pos = m_values.begin(); pos != end; ++pos) {
     StreamString strm;
     strm.Printf("%s=", pos->first.GetCString());
     pos->second->DumpValue(nullptr, strm, eDumpOptionValue | eDumpOptionRaw);
     args.AppendArgument(strm.GetString());

lldb/source/Interpreter/OptionValueFormat.cpp

if (dump_mask & eDumpOptionType)
     strm.Printf("(%s)", GetTypeAsCString());
   if (dump_mask & eDumpOptionValue) {
     if (dump_mask & eDumpOptionType)
       strm.PutCString(" = ");
     strm.PutCString(FormatManager::GetFormatAsCString(m_current_value));
   }
 }
 
+llvm::json::Value OptionValueFormat::ToJSON(const ExecutionContext *exe_ctx) {
+  return FormatManager::GetFormatAsCString(m_current_value);
+}
+
 Status OptionValueFormat::SetValueFromString(llvm::StringRef value,
                                              VarSetOperationType op) {
   Status error;
   switch (op) {
   case eVarSetOperationClear:
     Clear();
     NotifyValueChanged();
     break;

lldb/source/Interpreter/OptionValueFormatEntity.cpp

if (dump_mask & eDumpOptionValue) {
     if (dump_mask & eDumpOptionType)
       strm.PutCString(" = ");
     std::string escaped;
     EscapeBackticks(m_current_format, escaped);
     strm << '"' << escaped << '"';
   }
 }
 
+llvm::json::Value
+OptionValueFormatEntity::ToJSON(const ExecutionContext *exe_ctx) {
+  std::string escaped;
+  EscapeBackticks(m_current_format, escaped);
+  return escaped;
+}
+
 Status OptionValueFormatEntity::SetValueFromString(llvm::StringRef value_str,
                                                    VarSetOperationType op) {
   Status error;
   switch (op) {
   case eVarSetOperationClear:
     Clear();
     NotifyValueChanged();
     break;

lldb/source/Interpreter/OptionValueLanguage.cpp

void OptionValueLanguage::DumpValue(const ExecutionContext *exe_ctx,
   if (dump_mask & eDumpOptionValue) {
     if (dump_mask & eDumpOptionType)
       strm.PutCString(" = ");
     if (m_current_value != eLanguageTypeUnknown)
       strm.PutCString(Language::GetNameForLanguageType(m_current_value));
   }
 }
 
+llvm::json::Value OptionValueLanguage::ToJSON(const ExecutionContext *exe_ctx) {
+  return Language::GetNameForLanguageType(m_current_value);
+}
+
 Status OptionValueLanguage::SetValueFromString(llvm::StringRef value,
                                                VarSetOperationType op) {
   Status error;
   switch (op) {
   case eVarSetOperationClear:
     Clear();
     break;
 

lldb/source/Interpreter/OptionValuePathMappings.cpp

if (dump_mask & eDumpOptionType)
     strm.Printf("(%s)", GetTypeAsCString());
   if (dump_mask & eDumpOptionValue) {
     if (dump_mask & eDumpOptionType)
       strm.Printf(" =%s", (m_path_mappings.GetSize() > 0) ? "\n" : "");
     m_path_mappings.Dump(&strm);
   }
 }
 
+llvm::json::Value
+OptionValuePathMappings::ToJSON(const ExecutionContext *exe_ctx) {
+  return m_path_mappings.ToJSON();
+}
+
 Status OptionValuePathMappings::SetValueFromString(llvm::StringRef value,
                                                    VarSetOperationType op) {
   Status error;
   Args args(value.str());
   const size_t argc = args.GetArgumentCount();
 
   switch (op) {
   case eVarSetOperationClear:

lldb/source/Interpreter/OptionValueProperties.cpp

if (property) {
       const bool transparent_value = option_value->ValueIsTransparent();
       property->Dump(exe_ctx, strm, dump_mask);
       if (!transparent_value)
         strm.EOL();
     }
   }
 }
 
+llvm::json::Value
+OptionValueProperties::ToJSON(const ExecutionContext *exe_ctx) {
+  llvm::json::Object json_properties;
+  const size_t num_properties = m_properties.size();
+  for (size_t i = 0; i < num_properties; ++i) {
+    const Property *property = GetPropertyAtIndex(exe_ctx, false, i);
+    if (property) {
+      OptionValue *option_value = property->GetValue().get();
+      assert(option_value);
+      json_properties.try_emplace(property->GetName(),
+                                  option_value->ToJSON(exe_ctx));
+    }
+  }
+  return json_properties;
+}
+
 Status OptionValueProperties::DumpPropertyValue(const ExecutionContext *exe_ctx,
                                                 Stream &strm,
                                                 llvm::StringRef property_path,
-                                                uint32_t dump_mask) {
+                                                uint32_t dump_mask, bool is_json) {
   Status error;
   const bool will_modify = false;
   lldb::OptionValueSP value_sp(
       GetSubValue(exe_ctx, property_path, will_modify, error));
   if (value_sp) {
     if (!value_sp->ValueIsTransparent()) {
       if (dump_mask & eDumpOptionName)
         strm.PutCString(property_path);
       if (dump_mask & ~eDumpOptionName)
         strm.PutChar(' ');
     }
+    if (is_json) {
+      strm.Printf("%s", llvm::formatv("{0:2}", value_sp->ToJSON(exe_ctx)).str().c_str());
+    } else
       value_sp->DumpValue(exe_ctx, strm, dump_mask);
   }
   return error;
 }
 
 OptionValuePropertiesSP
 OptionValueProperties::CreateLocalCopy(const Properties &global_properties) {
   auto global_props_sp = global_properties.GetValueProperties();
   lldbassert(global_props_sp);

lldb/source/Target/PathMappingList.cpp

for (index = 0; index < numPairs; ++index)
                 m_pairs[index].second.GetCString());
   } else {
     if (static_cast<unsigned int>(pair_index) < numPairs)
       s->Printf("%s -> %s", m_pairs[pair_index].first.GetCString(),
                 m_pairs[pair_index].second.GetCString());
   }
 }
 
+llvm::json::Value PathMappingList::ToJSON() {
+  llvm::json::Array entries;
+  for (const auto &pair : m_pairs) {
+    llvm::json::Array entry{pair.first.GetStringRef().str(),
+                            pair.second.GetStringRef().str()};
+    entries.emplace_back(std::move(entry));
+  }
+  return entries;
+}
+
 void PathMappingList::Clear(bool notify) {
   if (!m_pairs.empty())
     ++m_mod_id;
   m_pairs.clear();
   if (notify && m_callback)
     m_callback(*this, m_callback_baton);
 }
 

lldb/test/API/commands/settings/TestSettings.py

 """
 Test lldb settings command.
 """
 
 
-
+import json
 import os
 import re
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
def do_test_run_args_and_env_vars(self, use_launchsimple):
                 break
         self.assertTrue(found_env_var,
                         "MY_ENV_VAR was not set in LunchInfo object")
 
         self.assertEqual(launch_info.GetNumArguments(), 3)
         self.assertEqual(launch_info.GetArgumentAtIndex(0), "A")
         self.assertEqual(launch_info.GetArgumentAtIndex(1), "B")
         self.assertEqual(launch_info.GetArgumentAtIndex(2), "C")
-        
         self.expect(
             'target show-launch-environment',
             substrs=["MY_ENV_VAR=YES"])
 
         wd = self.get_process_working_directory()
         if use_launchsimple:
             process = target.LaunchSimple(None, None, wd)
             self.assertTrue(process)
def test_settings_set_exists(self):
         cmdinterp = self.dbg.GetCommandInterpreter()
 
         # An unknown option should succeed.
         self.expect('settings set -e foo bar')
         self.expect('settings set --exists foo bar')
 
         # A known option should fail if its argument is invalid.
         self.expect("settings set auto-confirm bogus", error=True)
+
+    def get_setting_json(self, setting_path = None):
+        settings_data = self.dbg.GetSetting(setting_path)
+        stream = lldb.SBStream()
+        settings_data.GetAsJSON(stream)
+        return json.loads(stream.GetData())
+
+    def verify_setting_value_json(self, setting_path, setting_value):
+        self.runCmd("settings set %s %s" % (setting_path, setting_value))
+        settings_json = self.get_setting_json(setting_path)
+        self.assertEqual(settings_json, setting_value)
+
+    def test_settings_api(self):
+        """
+            Test that ensures SBDebugger::GetSetting() APIs
+            can correctly fetch settings.
+        """
+
+        # Test basic values and embedding special JSON escaping characters.
+        self.runCmd("settings set auto-confirm true")
+        self.runCmd("settings set tab-size 2")
+        arg_value = "hello \"world\""
+        self.runCmd('settings set target.arg0 %s' % arg_value)
+
+        settings_json = self.get_setting_json()
+        self.assertEqual(settings_json["auto-confirm"], True)
+        self.assertEqual(settings_json["tab-size"], 2)
+        self.assertEqual(settings_json["target"]["arg0"], arg_value)
+
+        settings_data = self.get_setting_json("target.arg0")
+        self.assertEqual(settings_data, arg_value)
+
+        # Test OptionValueFileSpec
+        self.verify_setting_value_json("platform.module-cache-directory", self.get_process_working_directory())
+
+        # Test OptionValueArray
+        setting_path = "target.run-args"
+        setting_value = ["value1", "value2", "value3"]
+        self.runCmd("settings set %s %s" % (setting_path, " ".join(setting_value)))
+        settings_json = self.get_setting_json(setting_path)
+        self.assertEqual(settings_json, setting_value)
+
+        # Test OptionValueFormatEntity
+        setting_value = """thread #${thread.index}{, name = \\'${thread.name}\\
+        '}{, queue = ${ansi.fg.green}\\'${thread.queue}\\'${ansi.normal}}{,
+        activity = ${ansi.fg.green}\\'${thread.info.activity.name}\\'${ansi.normal}}
+        {, ${thread.info.trace_messages} messages}{, stop reason = ${ansi.fg.red}$
+        {thread.stop-reason}${ansi.normal}}{\\\\nReturn value: ${thread.return-value}}
+        {\\\\nCompleted expression: ${thread.completed-expression}}\\\\n"""
+        self.verify_setting_value_json("thread-stop-format", setting_value)
+
+        # Test OptionValueRegex
+        self.verify_setting_value_json("target.process.thread.step-avoid-regexp", "^std::")
+
+        # Test OptionValueLanguage
+        self.verify_setting_value_json("repl-lang", "c++")

lldb/test/API/functionalities/source-map/TestTargetSourceMap.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
+import json
 import os
 
 
 class TestTargetSourceMap(TestBase):
 
     @no_debug_info_test
+    def test_source_map_via_setting_api(self):
+        """
+            Test that ensures SBDebugger::GetSetting("target.source-map") API
+            can correctly fetch source mapping entries.
+        """
+        # Set the target soure map to map "./" to the current test directory
+        src_dir = self.getSourceDir()
+
+        source_map_setting_path = "target.source-map"
+        initial_source_map = self.dbg.GetSetting(source_map_setting_path)
+        self.assertEquals(initial_source_map.GetSize(), 0,
+            "Initial source map should be empty")
+
+        src_dir = self.getSourceDir()
+        self.runCmd('settings set %s . "%s"' % (source_map_setting_path, src_dir))
+
+        source_map = self.dbg.GetSetting(source_map_setting_path)
+        self.assertEquals(source_map.GetSize(), 1,
+            "source map should be have one appended entry")
+
+        stream = lldb.SBStream()
+        source_map.GetAsJSON(stream)
+        serialized_source_map = json.loads(stream.GetData())
+
+        self.assertEquals(len(serialized_source_map[0]), 2,
+            "source map entry should have two parts")
+        self.assertEquals(serialized_source_map[0][0], ".",
+            "source map entry's first part does not match")
+        self.assertEquals(serialized_source_map[0][1], src_dir,
+            "source map entry's second part does not match")
+
+
+    @no_debug_info_test
     def test_source_map(self):
         """Test target.source-map' functionality."""
 
         def assertBreakpointWithSourceMap(src_path):
             # Set a breakpoint after we remap source and verify that it succeeds
             bp = target.BreakpointCreateByLocation(src_path, 2)
             self.assertEquals(bp.GetNumLocations(), 1,
                             "make sure breakpoint was resolved with map")