Add new LLDB setting: use-source-cache

[emrekultursay]

Summary

LLDB memory-maps large source files, and at the same time, caches
all source files in the Source Cache.

On Windows, memory-mapped source files are not writeable, causing
bad user experience in IDEs (such as errors when saving edited files).
IDEs should have the ability to disable the Source Cache at LLDB
startup, so that users can edit source files while debugging.

Bug: llvm.org/PR45310

[JDevlieghere]

Testing the effect of this change might be hard, but please add or extend an existing test to check that you can set and read the new property.

[emrekultursay]

I did not see any existing tests that validate setting/reading of properties. Can you point to me if you know any that exists?

[labath]

Yeah, the differences between windows&posix handling of memory mapped files is quite annoying (though I can't really say that the windows behavior is worse than randomly sending out SIGBUSes).

The alternative (which is used in other tools like clangd, I believe) is to not use mmap when opening these kinds of files. But I am not sure if that is actually better than not caching at all.

In D76804#1942723, @emrekultursay wrote:

I did not see any existing tests that validate setting/reading of properties. Can you point to me if you know any that exists?

TestSettings.py does various setting-related things, but I'm not sure how much would reading/writing of this specific setting be valueable, as it would literally only test the single declaration in CoreProperties.td. It would be better to have a test which sets this setting to false and then demonstrates that one is able to read/write to the source file. This is something that already works elsewhere, but it would at least test this functionality on windows (and given that we don't have a failing test, we probably don't have a test for this functionality anyway).

lldb/source/Core/Debugger.cpp

355

this looks like copy-paste gone wrong. SetPrompt is present in the use-color setting because that actually affects the value of the prompt -- this doesn't.

But this does raise the question of whether we should nuke the existing cache when this setting is set to false (I think we should).

[emrekultursay]

• Apply code review comments from labath@
• Wipe source cache when user sets the property to false
• Also expose set/get methods for use-source-cache in SBDebugger

[emrekultursay]

I added an end-to-end test to the entire use-source-cache feature in https://reviews.llvm.org/D76806

lldb/include/lldb/API/SBDebugger.h

public:
   bool SetUseExternalEditor(bool input);
 
   bool GetUseExternalEditor();
 
   bool SetUseColor(bool use_color);
 
   bool GetUseColor() const;
 
+  bool SetUseSourceCache(bool use_source_cache);
+
+  bool GetUseSourceCache() const;
+
   static bool GetDefaultArchitecture(char *arch_name, size_t arch_name_len);
 
   static bool SetDefaultArchitecture(const char *arch_name);
 
   lldb::ScriptLanguage GetScriptingLanguage(const char *script_language_name);
 
   static const char *GetVersionString();
 

lldb/include/lldb/Core/Debugger.h

public:
   bool GetUseExternalEditor() const;
 
   bool SetUseExternalEditor(bool use_external_editor_p);
 
   bool GetUseColor() const;
 
   bool SetUseColor(bool use_color);
 
+  bool GetUseSourceCache() const;
+
+  bool SetUseSourceCache(bool use_source_cache);
+
   bool GetHighlightSource() const;
 
   lldb::StopShowColumn GetStopShowColumn() const;
 
   llvm::StringRef GetStopShowColumnAnsiPrefix() const;
 
   llvm::StringRef GetStopShowColumnAnsiSuffix() const;
 

lldb/include/lldb/Core/SourceManager.h

public:
   class SourceFileCache {
   public:
     SourceFileCache() = default;
     ~SourceFileCache() = default;
 
     void AddSourceFile(const FileSP &file_sp);
     FileSP FindSourceFile(const FileSpec &file_spec) const;
 
+    // Removes all elements from the cache.
+    void Clear() { m_file_cache.clear(); }
+
   protected:
     typedef std::map<FileSpec, FileSP> FileCache;
     FileCache m_file_cache;
   };
 
   // Constructors and Destructors
   // A source manager can be made with a non-null target, in which case it can
   // use the path remappings to find

lldb/source/API/SBDebugger.cpp

 }
 
 bool SBDebugger::GetUseColor() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseColor);
 
   return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false);
 }
 
+bool SBDebugger::SetUseSourceCache(bool value) {
+  LLDB_RECORD_METHOD(bool, SBDebugger, SetUseSourceCache, (bool), value);
+
+  return (m_opaque_sp ? m_opaque_sp->SetUseSourceCache(value) : false);
+}
+
+bool SBDebugger::GetUseSourceCache() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseSourceCache);
+
+  return (m_opaque_sp ? m_opaque_sp->GetUseSourceCache() : false);
+}
+
 bool SBDebugger::GetDescription(SBStream &description) {
   LLDB_RECORD_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &),
                      description);
 
   Stream &strm = description.ref();
 
   if (m_opaque_sp) {
     const char *name = m_opaque_sp->GetInstanceName().AsCString();

lldb/source/Core/CoreProperties.td

let Definition = "debugger" in {
   def UseExternalEditor: Property<"use-external-editor", "Boolean">,
     Global,
     DefaultFalse,
     Desc<"Whether to use an external editor or not.">;
   def UseColor: Property<"use-color", "Boolean">,
     Global,
     DefaultTrue,
     Desc<"Whether to use Ansi color codes or not.">;
+  def UseSourceCache: Property<"use-source-cache", "Boolean">,
+    Global,
+    DefaultTrue,
+    Desc<"Whether to cache source files in memory or not.">;
   def AutoOneLineSummaries: Property<"auto-one-line-summaries", "Boolean">,
     Global,
     DefaultTrue,
     Desc<"If true, LLDB will automatically display small structs in one-liner format (default: true).">;
   def AutoIndent: Property<"auto-indent", "Boolean">,
     Global,
     DefaultTrue,
     Desc<"If true, LLDB will auto indent/outdent code. Currently only supported in the REPL (default: true).">;

lldb/source/Core/Debugger.cpp

if (property_path == g_debugger_properties[ePropertyPrompt].name) {
       auto bytes = std::make_unique<EventDataBytes>(new_prompt);
       auto prompt_change_event_sp = std::make_shared<Event>(
           CommandInterpreter::eBroadcastBitResetPrompt, bytes.release());
       GetCommandInterpreter().BroadcastEvent(prompt_change_event_sp);
     } else if (property_path == g_debugger_properties[ePropertyUseColor].name) {
       // use-color changed. Ping the prompt so it can reset the ansi terminal
       // codes.
       SetPrompt(GetPrompt());
+    } else if (property_path == g_debugger_properties[ePropertyUseSourceCache].name) {
+      // use-source-cache changed. Wipe out the cache contents if it was disabled.
+      if (!GetUseSourceCache()) {
+        m_source_file_cache.Clear();
+      }
     } else if (is_load_script && target_sp &&
                load_script_old_value == eLoadScriptFromSymFileWarn) {
       if (target_sp->TargetProperties::GetLoadScriptFromSymbolFile() ==
           eLoadScriptFromSymFileTrue) {
         std::list<Status> errors;
         StreamString feedback_stream;
         if (!target_sp->LoadScriptingResources(errors, &feedback_stream)) {
           Stream &s = GetErrorStream();

 
 bool Debugger::SetUseColor(bool b) {
   const uint32_t idx = ePropertyUseColor;
   bool ret = m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
   SetPrompt(GetPrompt());
   return ret;
 }
 
+bool Debugger::GetUseSourceCache() const {
+  const uint32_t idx = ePropertyUseSourceCache;
+  return m_collection_sp->GetPropertyAtIndexAsBoolean(
+      nullptr, idx, g_debugger_properties[idx].default_uint_value != 0);
+}
+
+bool Debugger::SetUseSourceCache(bool b) {
+  const uint32_t idx = ePropertyUseSourceCache;
+  bool ret = m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
+  if (!ret) {
+    m_source_file_cache.Clear();
+  }
+  return ret;
+}
 bool Debugger::GetHighlightSource() const {
   const uint32_t idx = ePropertyHighlightSource;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_debugger_properties[idx].default_uint_value);
 }
 
 StopShowColumn Debugger::GetStopShowColumn() const {
   const uint32_t idx = ePropertyStopShowColumn;

lldb/source/Core/SourceManager.cpp

SourceManager::FileSP SourceManager::GetFile(const FileSpec &file_spec) {
   bool same_as_previous =
       m_last_file_sp &&
       FileSpec::Match(file_spec, m_last_file_sp->GetFileSpec());
 
   DebuggerSP debugger_sp(m_debugger_wp.lock());
   FileSP file_sp;
   if (same_as_previous)
     file_sp = m_last_file_sp;
-  else if (debugger_sp)
+  else if (debugger_sp && debugger_sp->GetUseSourceCache())
     file_sp = debugger_sp->GetSourceFileCache().FindSourceFile(file_spec);
 
   TargetSP target_sp(m_target_wp.lock());
 
   // It the target source path map has been updated, get this file again so we
   // can successfully remap the source file
   if (target_sp && file_sp &&
       file_sp->GetSourceMapModificationID() !=
           target_sp->GetSourcePathMap().GetModificationID())
     file_sp.reset();
 
   // Update the file contents if needed if we found a file
   if (file_sp)
     file_sp->UpdateIfNeeded();
 
   // If file_sp is no good or it points to a non-existent file, reset it.
   if (!file_sp || !FileSystem::Instance().Exists(file_sp->GetFileSpec())) {
     if (target_sp)
       file_sp = std::make_shared<File>(file_spec, target_sp.get());
     else
       file_sp = std::make_shared<File>(file_spec, debugger_sp);
 
-    if (debugger_sp)
+    if (debugger_sp && debugger_sp->GetUseSourceCache())
       debugger_sp->GetSourceFileCache().AddSourceFile(file_sp);
   }
   return file_sp;
 }
 
 static bool should_highlight_source(DebuggerSP debugger_sp) {
   if (!debugger_sp)
     return false;