export StopDisassemblyType enum

eronnen · eronnen · commit 2ec7e347c7f2 · 2025-04-24T03:06:42.000+02:00
diff --git a/lldb/include/lldb/Core/Debugger.h b/lldb/include/lldb/Core/Debugger.h
@@ -232,14 +232,6 @@ class Debugger : public std::enable_shared_from_this<Debugger>,
 
   void SetLoggingCallback(lldb::LogOutputCallback log_callback, void *baton);
 
-  // Properties Functions
-  enum StopDisassemblyType {
-    eStopDisassemblyTypeNever = 0,
-    eStopDisassemblyTypeNoDebugInfo,
-    eStopDisassemblyTypeNoSource,
-    eStopDisassemblyTypeAlways
-  };
-
   Status SetPropertyValue(const ExecutionContext *exe_ctx,
                           VarSetOperationType op, llvm::StringRef property_path,
                           llvm::StringRef value) override;
@@ -336,7 +328,7 @@ class Debugger : public std::enable_shared_from_this<Debugger>,
 
   uint64_t GetStopSourceLineCount(bool before) const;
 
-  StopDisassemblyType GetStopDisassemblyDisplay() const;
+  lldb::StopDisassemblyType GetStopDisassemblyDisplay() const;
 
   uint64_t GetDisassemblyLineCount() const;
 
diff --git a/lldb/include/lldb/lldb-enumerations.h b/lldb/include/lldb/lldb-enumerations.h
@@ -1383,6 +1383,14 @@ enum CommandReturnObjectCallbackResult {
   eCommandReturnObjectPrintCallbackHandled = 1,
 };
 
+// Used to determine when to show disassembly
+enum StopDisassemblyType {
+  eStopDisassemblyTypeNever = 0,
+  eStopDisassemblyTypeNoDebugInfo,
+  eStopDisassemblyTypeNoSource,
+  eStopDisassemblyTypeAlways
+};
+
 } // namespace lldb
 
 #endif // LLDB_LLDB_ENUMERATIONS_H
diff --git a/lldb/source/Core/CoreProperties.td b/lldb/source/Core/CoreProperties.td
@@ -91,11 +91,13 @@ let Definition = "debugger" in {
     Global,
     DefaultUnsignedValue<4>,
     Desc<"The number of disassembly lines to show when displaying a stopped context.">;
-  def StopDisassemblyDisplay: Property<"stop-disassembly-display", "Enum">,
-    Global,
-    DefaultEnumValue<"Debugger::eStopDisassemblyTypeNoDebugInfo">,
-    EnumValues<"OptionEnumValues(g_show_disassembly_enum_values)">,
-    Desc<"Control when to display disassembly when displaying a stopped context.">;
+  def StopDisassemblyDisplay
+      : Property<"stop-disassembly-display", "Enum">,
+        Global,
+        DefaultEnumValue<"eStopDisassemblyTypeNoDebugInfo">,
+        EnumValues<"OptionEnumValues(g_show_disassembly_enum_values)">,
+        Desc<"Control when to display disassembly when displaying a stopped "
+             "context.">;
   def StopDisassemblyMaxSize: Property<"stop-disassembly-max-size", "UInt64">,
     Global,
     DefaultUnsignedValue<32000>,
diff --git a/lldb/source/Core/Debugger.cpp b/lldb/source/Core/Debugger.cpp
@@ -112,24 +112,24 @@ static llvm::DefaultThreadPool *g_thread_pool = nullptr;
 
 static constexpr OptionEnumValueElement g_show_disassembly_enum_values[] = {
     {
-        Debugger::eStopDisassemblyTypeNever,
+        lldb::eStopDisassemblyTypeNever,
         "never",
         "Never show disassembly when displaying a stop context.",
     },
     {
-        Debugger::eStopDisassemblyTypeNoDebugInfo,
+        lldb::eStopDisassemblyTypeNoDebugInfo,
         "no-debuginfo",
         "Show disassembly when there is no debug information.",
     },
     {
-        Debugger::eStopDisassemblyTypeNoSource,
+        lldb::eStopDisassemblyTypeNoSource,
         "no-source",
         "Show disassembly when there is no source information, or the source "
         "file "
         "is missing when displaying a stop context.",
     },
     {
-        Debugger::eStopDisassemblyTypeAlways,
+        lldb::eStopDisassemblyTypeAlways,
         "always",
         "Always show disassembly when displaying a stop context.",
     },
@@ -611,10 +611,10 @@ uint64_t Debugger::GetStopSourceLineCount(bool before) const {
       idx, g_debugger_properties[idx].default_uint_value);
 }
 
-Debugger::StopDisassemblyType Debugger::GetStopDisassemblyDisplay() const {
+lldb::StopDisassemblyType Debugger::GetStopDisassemblyDisplay() const {
   const uint32_t idx = ePropertyStopDisassemblyDisplay;
-  return GetPropertyAtIndexAs<Debugger::StopDisassemblyType>(
-      idx, static_cast<Debugger::StopDisassemblyType>(
+  return GetPropertyAtIndexAs<lldb::StopDisassemblyType>(
+      idx, static_cast<lldb::StopDisassemblyType>(
                g_debugger_properties[idx].default_uint_value));
 }
 
diff --git a/lldb/source/Interpreter/OptionValueEnumeration.cpp b/lldb/source/Interpreter/OptionValueEnumeration.cpp
@@ -41,9 +41,8 @@ llvm::json::Value
 OptionValueEnumeration::ToJSON(const ExecutionContext *exe_ctx) {
   const size_t count = m_enumerations.GetSize();
   for (size_t i = 0; i < count; ++i) {
-    if (m_enumerations.GetValueAtIndexUnchecked(i).value == m_current_value) {
+    if (m_enumerations.GetValueAtIndexUnchecked(i).value == m_current_value)
       return m_enumerations.GetCStringAtIndex(i).GetStringRef();
-    }
   }
 
   return m_current_value;
diff --git a/lldb/source/Target/StackFrame.cpp b/lldb/source/Target/StackFrame.cpp
@@ -2030,8 +2030,7 @@ bool StackFrame::GetStatus(Stream &strm, bool show_frame_info, bool show_source,
   if (show_source) {
     ExecutionContext exe_ctx(shared_from_this());
     bool have_source = false, have_debuginfo = false;
-    Debugger::StopDisassemblyType disasm_display =
-        Debugger::eStopDisassemblyTypeNever;
+    lldb::StopDisassemblyType disasm_display = lldb::eStopDisassemblyTypeNever;
     Target *target = exe_ctx.GetTargetPtr();
     if (target) {
       Debugger &debugger = target->GetDebugger();
@@ -2064,20 +2063,20 @@ bool StackFrame::GetStatus(Stream &strm, bool show_frame_info, bool show_source,
         }
       }
       switch (disasm_display) {
-      case Debugger::eStopDisassemblyTypeNever:
+      case lldb::eStopDisassemblyTypeNever:
         break;
 
-      case Debugger::eStopDisassemblyTypeNoDebugInfo:
+      case lldb::eStopDisassemblyTypeNoDebugInfo:
         if (have_debuginfo)
           break;
         [[fallthrough]];
 
-      case Debugger::eStopDisassemblyTypeNoSource:
+      case lldb::eStopDisassemblyTypeNoSource:
         if (have_source)
           break;
         [[fallthrough]];
 
-      case Debugger::eStopDisassemblyTypeAlways:
+      case lldb::eStopDisassemblyTypeAlways:
         if (target) {
           const uint32_t disasm_lines = debugger.GetDisassemblyLineCount();
           if (disasm_lines > 0) {
diff --git a/lldb/tools/lldb-dap/DAP.h b/lldb/tools/lldb-dap/DAP.h
@@ -202,10 +202,6 @@ struct DAP {
 
   lldb::SBFormat frame_format;
   lldb::SBFormat thread_format;
-
-  /// The value of stop-disassembly-display setting in LLDB.
-  std::string stop_disassembly_display;
-
   // This is used to allow request_evaluate to handle empty expressions
   // (ie the user pressed 'return' and expects the previous expression to
   // repeat). If the previous expression was a command, this string will be
diff --git a/lldb/tools/lldb-dap/Handler/AttachRequestHandler.cpp b/lldb/tools/lldb-dap/Handler/AttachRequestHandler.cpp
@@ -108,7 +108,6 @@ void AttachRequestHandler::operator()(const llvm::json::Object &request) const {
   }
 
   SetSourceMapFromArguments(*arguments);
-  SetStopDisassemblyDisplayFromSettings();
 
   lldb::SBError status;
   dap.SetTarget(dap.CreateTargetFromArguments(*arguments, status));
diff --git a/lldb/tools/lldb-dap/Handler/LaunchRequestHandler.cpp b/lldb/tools/lldb-dap/Handler/LaunchRequestHandler.cpp
@@ -95,7 +95,6 @@ void LaunchRequestHandler::operator()(const llvm::json::Object &request) const {
   }
 
   SetSourceMapFromArguments(*arguments);
-  SetStopDisassemblyDisplayFromSettings();
 
   lldb::SBError status;
   dap.SetTarget(dap.CreateTargetFromArguments(*arguments, status));
diff --git a/lldb/tools/lldb-dap/Handler/RequestHandler.cpp b/lldb/tools/lldb-dap/Handler/RequestHandler.cpp
@@ -99,10 +99,6 @@ void BaseRequestHandler::SetSourceMapFromArguments(
   }
 }
 
-void BaseRequestHandler::SetStopDisassemblyDisplayFromSettings() const {
-  dap.stop_disassembly_display = GetStopDisassemblyDisplay(dap.debugger);
-}
-
 static llvm::Error RunInTerminal(DAP &dap,
                                  const llvm::json::Object &launch_request,
                                  const uint64_t timeout_seconds) {
diff --git a/lldb/tools/lldb-dap/Handler/RequestHandler.h b/lldb/tools/lldb-dap/Handler/RequestHandler.h
@@ -63,9 +63,6 @@ class BaseRequestHandler {
   /// argument (or neither), from which we need to set the target.source-map.
   void SetSourceMapFromArguments(const llvm::json::Object &arguments) const;
 
-  /// Sets the stop-disassembly-display setting
-  void SetStopDisassemblyDisplayFromSettings() const;
-
   /// Prints a welcome message on the editor if the preprocessor variable
   /// LLDB_DAP_WELCOME_MESSAGE is defined.
   void PrintWelcomeMessage() const;
diff --git a/lldb/tools/lldb-dap/Handler/StackTraceRequestHandler.cpp b/lldb/tools/lldb-dap/Handler/StackTraceRequestHandler.cpp
@@ -9,7 +9,9 @@
 #include "DAP.h"
 #include "EventHelper.h"
 #include "JSONUtils.h"
+#include "LLDBUtils.h"
 #include "RequestHandler.h"
+#include "lldb/lldb-enumerations.h"
 
 namespace lldb_dap {
 
@@ -51,6 +53,8 @@ static constexpr int StackPageSize = 20;
 static bool FillStackFrames(DAP &dap, lldb::SBThread &thread,
                             llvm::json::Array &stack_frames, int64_t &offset,
                             const int64_t start_frame, const int64_t levels) {
+  lldb::StopDisassemblyType stop_disassembly_display =
+      GetStopDisassemblyDisplay(dap.debugger);
   bool reached_end_of_stack = false;
   for (int64_t i = start_frame;
        static_cast<int64_t>(stack_frames.size()) < levels; i++) {
@@ -67,8 +71,8 @@ static bool FillStackFrames(DAP &dap, lldb::SBThread &thread,
       break;
     }
 
-    stack_frames.emplace_back(CreateStackFrame(frame, dap.frame_format,
-                                               dap.stop_disassembly_display));
+    stack_frames.emplace_back(
+        CreateStackFrame(frame, dap.frame_format, stop_disassembly_display));
   }
 
   if (dap.configuration.displayExtendedBacktrace && reached_end_of_stack) {
diff --git a/lldb/tools/lldb-dap/JSONUtils.cpp b/lldb/tools/lldb-dap/JSONUtils.cpp
@@ -658,12 +658,13 @@ llvm::json::Value CreateSource(llvm::StringRef source_path) {
   return llvm::json::Value(std::move(source));
 }
 
-bool ShouldDisplayAssemblySource(const lldb::SBLineEntry &line_entry,
-                                 const std::string &stop_disassembly_display) {
-  if (stop_disassembly_display == "never")
+bool ShouldDisplayAssemblySource(
+    const lldb::SBLineEntry &line_entry,
+    lldb::StopDisassemblyType stop_disassembly_display) {
+  if (stop_disassembly_display == lldb::eStopDisassemblyTypeNever)
     return false;
 
-  if (stop_disassembly_display == "always")
+  if (stop_disassembly_display == lldb::eStopDisassemblyTypeAlways)
     return true;
 
   // A line entry of 0 indicates the line is compiler generated i.e. no source
@@ -673,7 +674,8 @@ bool ShouldDisplayAssemblySource(const lldb::SBLineEntry &line_entry,
       line_entry.GetLine() == LLDB_INVALID_LINE_NUMBER)
     return true;
 
-  if (stop_disassembly_display == "no-source" && !file_spec.Exists()) {
+  if (stop_disassembly_display == lldb::eStopDisassemblyTypeNoSource &&
+      !file_spec.Exists()) {
     return true;
   }
 
@@ -743,7 +745,7 @@ bool ShouldDisplayAssemblySource(const lldb::SBLineEntry &line_entry,
 // }
 llvm::json::Value
 CreateStackFrame(lldb::SBFrame &frame, lldb::SBFormat &format,
-                 const std::string &stop_disassembly_display) {
+                 lldb::StopDisassemblyType stop_disassembly_display) {
   llvm::json::Object object;
   int64_t frame_id = MakeDAPFrameID(frame);
   object.try_emplace("id", frame_id);
diff --git a/lldb/tools/lldb-dap/JSONUtils.h b/lldb/tools/lldb-dap/JSONUtils.h
@@ -356,8 +356,9 @@ llvm::json::Value CreateSource(llvm::StringRef source_path);
 /// \return
 ///     True if the line entry should be displayed as assembly, false
 ///     otherwise.
-bool ShouldDisplayAssemblySource(const lldb::SBLineEntry &line_entry,
-                                 const std::string &stop_disassembly_display);
+bool ShouldDisplayAssemblySource(
+    const lldb::SBLineEntry &line_entry,
+    lldb::StopDisassemblyType stop_disassembly_display);
 
 /// Create a "StackFrame" object for a LLDB frame object.
 ///
@@ -384,7 +385,7 @@ bool ShouldDisplayAssemblySource(const lldb::SBLineEntry &line_entry,
 ///     A "StackFrame" JSON object with that follows the formal JSON
 ///     definition outlined by Microsoft.
 llvm::json::Value CreateStackFrame(lldb::SBFrame &frame, lldb::SBFormat &format,
-                                   const std::string &stop_disassembly_display);
+                                   lldb::StopDisassemblyType);
 
 /// Create a "StackFrame" label object for a LLDB thread.
 ///
diff --git a/lldb/tools/lldb-dap/LLDBUtils.cpp b/lldb/tools/lldb-dap/LLDBUtils.cpp
@@ -10,6 +10,7 @@
 #include "DAP.h"
 #include "JSONUtils.h"
 #include "lldb/API/SBStringList.h"
+#include "llvm/ADT/StringSwitch.h"
 
 #include <mutex>
 
@@ -163,17 +164,31 @@ GetEnvironmentFromArguments(const llvm::json::Object &arguments) {
   return envs;
 }
 
-std::string GetStopDisassemblyDisplay(lldb::SBDebugger &debugger) {
-  lldb::SBStructuredData result =
+lldb::StopDisassemblyType
+GetStopDisassemblyDisplay(lldb::SBDebugger &debugger) {
+  lldb::StopDisassemblyType result =
+      lldb::StopDisassemblyType::eStopDisassemblyTypeNoDebugInfo;
+  lldb::SBStructuredData string_result =
       debugger.GetSetting("stop-disassembly-display");
-  const size_t result_length = result.GetStringValue(nullptr, 0);
+  const size_t result_length = string_result.GetStringValue(nullptr, 0);
   if (result_length > 0) {
     std::string result_string(result_length, '\0');
-    result.GetStringValue(result_string.data(), result_length + 1);
-    return result_string;
+    string_result.GetStringValue(result_string.data(), result_length + 1);
+
+    result =
+        llvm::StringSwitch<lldb::StopDisassemblyType>(result_string)
+            .Case("never", lldb::StopDisassemblyType::eStopDisassemblyTypeNever)
+            .Case("always",
+                  lldb::StopDisassemblyType::eStopDisassemblyTypeAlways)
+            .Case("no-source",
+                  lldb::StopDisassemblyType::eStopDisassemblyTypeNoSource)
+            .Case("no-debuginfo",
+                  lldb::StopDisassemblyType::eStopDisassemblyTypeNoDebugInfo)
+            .Default(
+                lldb::StopDisassemblyType::eStopDisassemblyTypeNoDebugInfo);
   }
 
-  return "no-debuginfo";
+  return result;
 }
 
 llvm::Error ToError(const lldb::SBError &error) {
diff --git a/lldb/tools/lldb-dap/LLDBUtils.h b/lldb/tools/lldb-dap/LLDBUtils.h
@@ -163,7 +163,7 @@ GetEnvironmentFromArguments(const llvm::json::Object &arguments);
 ///
 /// \return
 ///     The value of the stop-disassembly-display setting
-std::string GetStopDisassemblyDisplay(lldb::SBDebugger &debugger);
+lldb::StopDisassemblyType GetStopDisassemblyDisplay(lldb::SBDebugger &debugger);
 
 /// Take ownership of the stored error.
 llvm::Error ToError(const lldb::SBError &error);

Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,6 @@ void AttachRequestHandler::operator()(const llvm::json::Object &request) const {`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`SetSourceMapFromArguments(*arguments);`
`111`		`- SetStopDisassemblyDisplayFromSettings();`
`112`	`111`
`113`	`112`	`lldb::SBError status;`
`114`	`113`	`dap.SetTarget(dap.CreateTargetFromArguments(*arguments, status));`
Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,6 @@ void LaunchRequestHandler::operator()(const llvm::json::Object &request) const {`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`SetSourceMapFromArguments(*arguments);`
`98`		`- SetStopDisassemblyDisplayFromSettings();`
`99`	`98`
`100`	`99`	`lldb::SBError status;`
`101`	`100`	`dap.SetTarget(dap.CreateTargetFromArguments(*arguments, status));`
Original file line number	Diff line number	Diff line change
`@@ -99,10 +99,6 @@ void BaseRequestHandler::SetSourceMapFromArguments(`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`
`102`		`-void BaseRequestHandler::SetStopDisassemblyDisplayFromSettings() const {`
`103`		`- dap.stop_disassembly_display = GetStopDisassemblyDisplay(dap.debugger);`
`104`		`-}`
`105`		`-`
`106`	`102`	`static llvm::Error RunInTerminal(DAP &dap,`
`107`	`103`	`const llvm::json::Object &launch_request,`
`108`	`104`	`const uint64_t timeout_seconds) {`