[Driver] Change the way we deal with local lldbinit files.

[JDevlieghere]

Summary

Currently we have special handling for local lldbinit files in the driver. At the same time, we have an SB API named SourceInitFileInCurrentWorkingDirectory that does the same thing. This patch removes the special handling from the driver and uses the API instead. In addition to the obvious advantages of having one canonical way of doing things and removing code duplication, this change also means that the code path is the same for global and local lldb init files. This is important for another patch I have in the pipeline.

[labath]

Looks good to me. The way we were working around this thing in the driver always looked like a hack to me.

lldb/lit/Driver/Inputs/.lldbinit

+settings set -f frame-format "bogus"

lldb/lit/Driver/LocalLLDBInit.test

+# RUN: mkdir -p %t.root
+# RUN: cp %S/Inputs/.lldbinit %t.root
+# RUN: cd %t.root
+# RUN: %lldb-init -o 'settings show frame-format' 2>&1 | FileCheck %s --check-prefix=INIT --check-prefix=CHECK
+# RUN: %lldb -o 'settings show frame-format' 2>&1 | FileCheck %s --check-prefix=NOINIT --check-prefix=CHECK
+
+# INIT: There is a .lldbinit file in the current directory which is not being read.
+# NOINIT-NOT: There is a .lldbinit file in the current directory which is not being read.
+# CHECK-NOT: bogus

lldb/lit/helper/toolchain.py

if config.llvm_libs_dir:
         build_script_args.append('--libs-dir={0}'.format(config.llvm_libs_dir))
 
     primary_tools = [
         ToolSubst('%lldb',
                   command=FindTool('lldb'),
                   extra_args=['--no-lldbinit', '-S',
                               os.path.join(config.test_source_root,
                                            'lit-lldb-init')]),
+        ToolSubst('%lldb-init',
+                  command=FindTool('lldb'),
+                  extra_args=['-S',
+                              os.path.join(config.test_source_root,
+                                           'lit-lldb-init')]),
         lldbmi,
         ToolSubst('%debugserver',
                   command=FindTool(dsname),
                   extra_args=dsargs,
                   unresolved='ignore'),
         ToolSubst('%platformserver',
                   command=FindTool('lldb-server'),
                   extra_args=['platform'],

lldb/source/Interpreter/CommandInterpreter.cpp

 
   return position;
 }
 
 void CommandInterpreter::SourceInitFile(bool in_cwd,
                                         CommandReturnObject &result) {
   FileSpec init_file;
   if (in_cwd) {
-    ExecutionContext exe_ctx(GetExecutionContext());
-    Target *target = exe_ctx.GetTargetPtr();
-    if (target) {
+    lldb::TargetPropertiesSP properties = Target::GetGlobalProperties();
+    if (properties) {
       // In the current working directory we don't load any program specific
       // .lldbinit files, we only look for a ".lldbinit" file.
       if (m_skip_lldbinit_files)
         return;
 
-      LoadCWDlldbinitFile should_load =
-          target->TargetProperties::GetLoadCWDlldbinitFile();
+      LoadCWDlldbinitFile should_load = properties->GetLoadCWDlldbinitFile();
       if (should_load == eLoadCWDlldbinitWarn) {
         FileSpec dot_lldb(".lldbinit");
         FileSystem::Instance().Resolve(dot_lldb);
         llvm::SmallString<64> home_dir_path;
         llvm::sys::path::home_directory(home_dir_path);
         FileSpec homedir_dot_lldb(home_dir_path.c_str());
         homedir_dot_lldb.AppendPathComponent(".lldbinit");
         FileSystem::Instance().Resolve(homedir_dot_lldb);

lldb/tools/driver/Driver.h

public:
   int MainLoop();
 
   lldb::SBError ProcessArgs(const llvm::opt::InputArgList &args, bool &exiting);
 
   void WriteCommandsForSourcing(CommandPlacement placement,
                                 lldb::SBStream &strm);
 
   struct OptionData {
-    void AddLocalLLDBInit();
     void AddInitialCommand(std::string command, CommandPlacement placement,
                            bool is_file, lldb::SBError &error);
 
     struct InitialCmdEntry {
       InitialCmdEntry(std::string contents, bool in_is_file,
-                      bool is_cwd_lldbinit_file_read, bool in_quiet = false)
+                      bool in_quiet = false)
           : contents(std::move(contents)), is_file(in_is_file),
-            source_quietly(in_quiet),
-            is_cwd_lldbinit_file_read(is_cwd_lldbinit_file_read) {}
+            source_quietly(in_quiet) {}
 
       std::string contents;
       bool is_file;
       bool source_quietly;
-
-      /// Remember if this is reading the local lldbinit file so we can skip it
-      /// if not permitted.
-      bool is_cwd_lldbinit_file_read;
     };
 
     std::vector<std::string> m_args;
 
     lldb::LanguageType m_repl_lang = lldb::eLanguageTypeUnknown;
     lldb::pid_t m_process_pid = LLDB_INVALID_PROCESS_ID;
 
     std::string m_core_file;

lldb/tools/driver/Driver.cpp

Driver::Driver()
   // We want to be able to handle CTRL+D in the terminal to have it terminate
   // certain input
   m_debugger.SetCloseInputOnEOF(false);
   g_driver = this;
 }
 
 Driver::~Driver() { g_driver = nullptr; }
 
-void Driver::OptionData::AddLocalLLDBInit() {
-  // If there is a local .lldbinit, add that to the list of things to be
-  // sourced, if the settings permit it.
-  SBFileSpec local_lldbinit(".lldbinit", true);
-  SBFileSpec homedir_dot_lldb = SBHostOS::GetUserHomeDirectory();
-  homedir_dot_lldb.AppendPathComponent(".lldbinit");
-
-  // Only read .lldbinit in the current working directory if it's not the same
-  // as the .lldbinit in the home directory (which is already being read in).
-  if (local_lldbinit.Exists() && strcmp(local_lldbinit.GetDirectory(),
-                                        homedir_dot_lldb.GetDirectory()) != 0) {
-    char path[PATH_MAX];
-    local_lldbinit.GetPath(path, sizeof(path));
-    InitialCmdEntry entry(path, true, true, true);
-    m_after_file_commands.push_back(entry);
-  }
-}
-
 void Driver::OptionData::AddInitialCommand(std::string command,
                                            CommandPlacement placement,
                                            bool is_file, SBError &error) {
   std::vector<InitialCmdEntry> *command_set;
   switch (placement) {
   case eCommandPlacementBeforeFile:
     command_set = &(m_initial_commands);
     break;
   case eCommandPlacementAfterFile:
     command_set = &(m_after_file_commands);
     break;
   case eCommandPlacementAfterCrash:
     command_set = &(m_after_crash_commands);
     break;
   }
 
   if (is_file) {
     SBFileSpec file(command.c_str());
     if (file.Exists())
-      command_set->push_back(InitialCmdEntry(command, is_file, false));
+      command_set->push_back(InitialCmdEntry(command, is_file));
     else if (file.ResolveExecutableLocation()) {
       char final_path[PATH_MAX];
       file.GetPath(final_path, sizeof(final_path));
-      command_set->push_back(InitialCmdEntry(final_path, is_file, false));
+      command_set->push_back(InitialCmdEntry(final_path, is_file));
     } else
       error.SetErrorStringWithFormat(
           "file specified in --source (-s) option doesn't exist: '%s'",
           command.c_str());
   } else
-    command_set->push_back(InitialCmdEntry(command, is_file, false));
+    command_set->push_back(InitialCmdEntry(command, is_file));
 }
 
 void Driver::WriteCommandsForSourcing(CommandPlacement placement,
                                       SBStream &strm) {
   std::vector<OptionData::InitialCmdEntry> *command_set;
   switch (placement) {
   case eCommandPlacementBeforeFile:
     command_set = &m_option_data.m_initial_commands;
     break;
   case eCommandPlacementAfterFile:
     command_set = &m_option_data.m_after_file_commands;
     break;
   case eCommandPlacementAfterCrash:
     command_set = &m_option_data.m_after_crash_commands;
     break;
   }
 
   for (const auto &command_entry : *command_set) {
     const char *command = command_entry.contents.c_str();
     if (command_entry.is_file) {
-      // If this command_entry is a file to be sourced, and it's the ./.lldbinit
-      // file (the .lldbinit
-      // file in the current working directory), only read it if
-      // target.load-cwd-lldbinit is 'true'.
-      if (command_entry.is_cwd_lldbinit_file_read) {
-        SBStringList strlist = lldb::SBDebugger::GetInternalVariableValue(
-            "target.load-cwd-lldbinit", m_debugger.GetInstanceName());
-        if (strlist.GetSize() == 1 &&
-            strcmp(strlist.GetStringAtIndex(0), "warn") == 0) {
-          FILE *output = m_debugger.GetOutputFileHandle();
-          ::fprintf(
-              output,
-              "There is a .lldbinit file in the current directory which is not "
-              "being read.\n"
-              "To silence this warning without sourcing in the local "
-              ".lldbinit,\n"
-              "add the following to the lldbinit file in your home directory:\n"
-              "    settings set target.load-cwd-lldbinit false\n"
-              "To allow lldb to source .lldbinit files in the current working "
-              "directory,\n"
-              "set the value of this variable to true.  Only do so if you "
-              "understand and\n"
-              "accept the security risk.\n");
-          return;
-        }
-        if (strlist.GetSize() == 1 &&
-            strcmp(strlist.GetStringAtIndex(0), "false") == 0) {
-          return;
-        }
-      }
       bool source_quietly =
           m_option_data.m_source_quietly || command_entry.source_quietly;
       strm.Printf("command source -s %i '%s'\n",
                   static_cast<int>(source_quietly), command);
     } else
       strm.Printf("%s\n", command);
   }
 }
 
 // Check the arguments that were passed to this program to make sure they are
 // valid and to get their argument values (if any).  Return a boolean value
 // indicating whether or not to start up the full debugger (i.e. the Command
 // Interpreter) or not.  Return FALSE if the arguments were invalid OR if the
 // user only wanted help or version information.
 SBError Driver::ProcessArgs(const opt::InputArgList &args, bool &exiting) {
   SBError error;
-  m_option_data.AddLocalLLDBInit();
 
   // This is kind of a pain, but since we make the debugger in the Driver's
   // constructor, we can't know at that point whether we should read in init
   // files yet.  So we don't read them in in the Driver constructor, then set
   // the flags back to "read them in" here, and then if we see the "-n" flag,
   // we'll turn it off again.  Finally we have to read them in by hand later in
   // the main loop.
   m_debugger.SkipLLDBInitFiles(false);
#endif
   // .lldbinit file in the user's home directory.
   SBCommandReturnObject result;
   sb_interpreter.SourceInitFileInHomeDirectory(result);
   if (m_option_data.m_debug_mode) {
     result.PutError(m_debugger.GetErrorFileHandle());
     result.PutOutput(m_debugger.GetOutputFileHandle());
   }
 
+  // Source the local .lldbinit file if it exists and we're allowed to source.
+  // Here we want to always print the return object because it contains the
+  // warning and instructions to load local lldbinit files.
+  sb_interpreter.SourceInitFileInCurrentWorkingDirectory(result);
+  result.PutError(m_debugger.GetErrorFileHandle());
+  result.PutOutput(m_debugger.GetOutputFileHandle());
+
   // We allow the user to specify an exit code when calling quit which we will
   // return when exiting.
   m_debugger.GetCommandInterpreter().AllowExitCodeOnQuit(true);
 
   // Now we handle options we got from the command line
   SBStream commands_stream;
 
   // First source in the commands specified to be run before the file arguments