lldb/source/Commands/CommandCompletions.cpp

   1 //===-- CommandCompletions.cpp --------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/ADT/SmallString.h"
  10 #include "llvm/ADT/StringSet.h"
  11
  12 #include "lldb/Breakpoint/Watchpoint.h"
  13 #include "lldb/Core/Module.h"
  14 #include "lldb/Core/PluginManager.h"
  15 #include "lldb/DataFormatters/DataVisualization.h"
  16 #include "lldb/Host/FileSystem.h"
  17 #include "lldb/Interpreter/CommandCompletions.h"
  18 #include "lldb/Interpreter/CommandInterpreter.h"
  19 #include "lldb/Interpreter/CommandObject.h"
  20 #include "lldb/Interpreter/CommandObjectMultiword.h"
  21 #include "lldb/Interpreter/OptionValueProperties.h"
  22 #include "lldb/Symbol/CompileUnit.h"
  23 #include "lldb/Symbol/Variable.h"
  24 #include "lldb/Target/Language.h"
  25 #include "lldb/Target/Process.h"
  26 #include "lldb/Target/RegisterContext.h"
  27 #include "lldb/Target/Thread.h"
  28 #include "lldb/Utility/FileSpec.h"
  29 #include "lldb/Utility/FileSpecList.h"
  30 #include "lldb/Utility/StreamString.h"
  31 #include "lldb/Utility/TildeExpressionResolver.h"
  32
  33 #include "llvm/Support/FileSystem.h"
  34 #include "llvm/Support/Path.h"
  35
  36 using namespace lldb_private;
  37
  38 // This is the command completion callback that is used to complete the
  39 // argument of the option it is bound to (in the OptionDefinition table
  40 // below).
  41 typedef void (*CompletionCallback)(CommandInterpreter &interpreter,
  42                                    CompletionRequest &request,
  43                                    // A search filter to limit the search...
  44                                    lldb_private::SearchFilter *searcher);
  45
  46 struct CommonCompletionElement {
  47   uint32_t type;
  48   CompletionCallback callback;
  49 };
  50
  51 bool CommandCompletions::InvokeCommonCompletionCallbacks(
  52     CommandInterpreter &interpreter, uint32_t completion_mask,
  53     CompletionRequest &request, SearchFilter *searcher) {
  54   bool handled = false;
  55
  56   const CommonCompletionElement common_completions[] = {
  57       {lldb::eSourceFileCompletion, CommandCompletions::SourceFiles},
  58       {lldb::eDiskFileCompletion, CommandCompletions::DiskFiles},
  59       {lldb::eDiskDirectoryCompletion, CommandCompletions::DiskDirectories},
  60       {lldb::eSymbolCompletion, CommandCompletions::Symbols},
  61       {lldb::eModuleCompletion, CommandCompletions::Modules},
  62       {lldb::eModuleUUIDCompletion, CommandCompletions::ModuleUUIDs},
  63       {lldb::eSettingsNameCompletion, CommandCompletions::SettingsNames},
  64       {lldb::ePlatformPluginCompletion,
  65        CommandCompletions::PlatformPluginNames},
  66       {lldb::eArchitectureCompletion, CommandCompletions::ArchitectureNames},
  67       {lldb::eVariablePathCompletion, CommandCompletions::VariablePath},
  68       {lldb::eRegisterCompletion, CommandCompletions::Registers},
  69       {lldb::eBreakpointCompletion, CommandCompletions::Breakpoints},
  70       {lldb::eProcessPluginCompletion, CommandCompletions::ProcessPluginNames},
  71       {lldb::eDisassemblyFlavorCompletion,
  72        CommandCompletions::DisassemblyFlavors},
  73       {lldb::eTypeLanguageCompletion, CommandCompletions::TypeLanguages},
  74       {lldb::eFrameIndexCompletion, CommandCompletions::FrameIndexes},
  75       {lldb::eStopHookIDCompletion, CommandCompletions::StopHookIDs},
  76       {lldb::eThreadIndexCompletion, CommandCompletions::ThreadIndexes},
  77       {lldb::eWatchpointIDCompletion, CommandCompletions::WatchPointIDs},
  78       {lldb::eBreakpointNameCompletion, CommandCompletions::BreakpointNames},
  79       {lldb::eProcessIDCompletion, CommandCompletions::ProcessIDs},
  80       {lldb::eProcessNameCompletion, CommandCompletions::ProcessNames},
  81       {lldb::eRemoteDiskFileCompletion, CommandCompletions::RemoteDiskFiles},
  82       {lldb::eRemoteDiskDirectoryCompletion,
  83        CommandCompletions::RemoteDiskDirectories},
  84       {lldb::eTypeCategoryNameCompletion,
  85        CommandCompletions::TypeCategoryNames},
  86       {lldb::CompletionType::eNoCompletion,
  87        nullptr} // This one has to be last in the list.
  88   };
  89
  90   for (int i = 0;; i++) {
  91     if (common_completions[i].type == lldb::eNoCompletion)
  92       break;
  93     else if ((common_completions[i].type & completion_mask) ==
  94                  common_completions[i].type &&
  95              common_completions[i].callback != nullptr) {
  96       handled = true;
  97       common_completions[i].callback(interpreter, request, searcher);
  98     }
  99   }
 100   return handled;
 101 }
 102
 103 namespace {
 104 // The Completer class is a convenient base class for building searchers that
 105 // go along with the SearchFilter passed to the standard Completer functions.
 106 class Completer : public Searcher {
 107 public:
 108   Completer(CommandInterpreter &interpreter, CompletionRequest &request)
 109       : m_interpreter(interpreter), m_request(request) {}
 110
 111   ~Completer() override = default;
 112
 113   CallbackReturn SearchCallback(SearchFilter &filter, SymbolContext &context,
 114                                 Address *addr) override = 0;
 115
 116   lldb::SearchDepth GetDepth() override = 0;
 117
 118   virtual void DoCompletion(SearchFilter *filter) = 0;
 119
 120 protected:
 121   CommandInterpreter &m_interpreter;
 122   CompletionRequest &m_request;
 123
 124 private:
 125   Completer(const Completer &) = delete;
 126   const Completer &operator=(const Completer &) = delete;
 127 };
 128 } // namespace
 129
 130 // SourceFileCompleter implements the source file completer
 131 namespace {
 132 class SourceFileCompleter : public Completer {
 133 public:
 134   SourceFileCompleter(CommandInterpreter &interpreter,
 135                       CompletionRequest &request)
 136       : Completer(interpreter, request) {
 137     FileSpec partial_spec(m_request.GetCursorArgumentPrefix());
 138     m_file_name = partial_spec.GetFilename().GetCString();
 139     m_dir_name = partial_spec.GetDirectory().GetCString();
 140   }
 141
 142   lldb::SearchDepth GetDepth() override { return lldb::eSearchDepthCompUnit; }
 143
 144   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
 145                                           SymbolContext &context,
 146                                           Address *addr) override {
 147     if (context.comp_unit != nullptr) {
 148       const char *cur_file_name =
 149           context.comp_unit->GetPrimaryFile().GetFilename().GetCString();
 150       const char *cur_dir_name =
 151           context.comp_unit->GetPrimaryFile().GetDirectory().GetCString();
 152
 153       bool match = false;
 154       if (m_file_name && cur_file_name &&
 155           strstr(cur_file_name, m_file_name) == cur_file_name)
 156         match = true;
 157
 158       if (match && m_dir_name && cur_dir_name &&
 159           strstr(cur_dir_name, m_dir_name) != cur_dir_name)
 160         match = false;
 161
 162       if (match) {
 163         m_matching_files.AppendIfUnique(context.comp_unit->GetPrimaryFile());
 164       }
 165     }
 166     return Searcher::eCallbackReturnContinue;
 167   }
 168
 169   void DoCompletion(SearchFilter *filter) override {
 170     filter->Search(*this);
 171     // Now convert the filelist to completions:
 172     for (size_t i = 0; i < m_matching_files.GetSize(); i++) {
 173       m_request.AddCompletion(
 174           m_matching_files.GetFileSpecAtIndex(i).GetFilename().GetCString());
 175     }
 176   }
 177
 178 private:
 179   FileSpecList m_matching_files;
 180   const char *m_file_name;
 181   const char *m_dir_name;
 182
 183   SourceFileCompleter(const SourceFileCompleter &) = delete;
 184   const SourceFileCompleter &operator=(const SourceFileCompleter &) = delete;
 185 };
 186 } // namespace
 187
 188 static bool regex_chars(const char comp) {
 189   return llvm::StringRef("[](){}+.*|^$\\?").contains(comp);
 190 }
 191
 192 namespace {
 193 class SymbolCompleter : public Completer {
 194
 195 public:
 196   SymbolCompleter(CommandInterpreter &interpreter, CompletionRequest &request)
 197       : Completer(interpreter, request) {
 198     std::string regex_str;
 199     if (!m_request.GetCursorArgumentPrefix().empty()) {
 200       regex_str.append("^");
 201       regex_str.append(std::string(m_request.GetCursorArgumentPrefix()));
 202     } else {
 203       // Match anything since the completion string is empty
 204       regex_str.append(".");
 205     }
 206     std::string::iterator pos =
 207         find_if(regex_str.begin() + 1, regex_str.end(), regex_chars);
 208     while (pos < regex_str.end()) {
 209       pos = regex_str.insert(pos, '\\');
 210       pos = find_if(pos + 2, regex_str.end(), regex_chars);
 211     }
 212     m_regex = RegularExpression(regex_str);
 213   }
 214
 215   lldb::SearchDepth GetDepth() override { return lldb::eSearchDepthModule; }
 216
 217   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
 218                                           SymbolContext &context,
 219                                           Address *addr) override {
 220     if (context.module_sp) {
 221       SymbolContextList sc_list;
 222       ModuleFunctionSearchOptions function_options;
 223       function_options.include_symbols = true;
 224       function_options.include_inlines = true;
 225       context.module_sp->FindFunctions(m_regex, function_options, sc_list);
 226
 227       // Now add the functions & symbols to the list - only add if unique:
 228       for (const SymbolContext &sc : sc_list) {
 229         ConstString func_name = sc.GetFunctionName(Mangled::ePreferDemangled);
 230         // Ensure that the function name matches the regex. This is more than
 231         // a sanity check. It is possible that the demangled function name
 232         // does not start with the prefix, for example when it's in an
 233         // anonymous namespace.
 234         if (!func_name.IsEmpty() && m_regex.Execute(func_name.GetStringRef()))
 235           m_match_set.insert(func_name);
 236       }
 237     }
 238     return Searcher::eCallbackReturnContinue;
 239   }
 240
 241   void DoCompletion(SearchFilter *filter) override {
 242     filter->Search(*this);
 243     collection::iterator pos = m_match_set.begin(), end = m_match_set.end();
 244     for (pos = m_match_set.begin(); pos != end; pos++)
 245       m_request.AddCompletion((*pos).GetCString());
 246   }
 247
 248 private:
 249   RegularExpression m_regex;
 250   typedef std::set<ConstString> collection;
 251   collection m_match_set;
 252
 253   SymbolCompleter(const SymbolCompleter &) = delete;
 254   const SymbolCompleter &operator=(const SymbolCompleter &) = delete;
 255 };
 256 } // namespace
 257
 258 namespace {
 259 class ModuleCompleter : public Completer {
 260 public:
 261   ModuleCompleter(CommandInterpreter &interpreter, CompletionRequest &request)
 262       : Completer(interpreter, request) {
 263     FileSpec partial_spec(m_request.GetCursorArgumentPrefix());
 264     m_file_name = partial_spec.GetFilename().GetCString();
 265     m_dir_name = partial_spec.GetDirectory().GetCString();
 266   }
 267
 268   lldb::SearchDepth GetDepth() override { return lldb::eSearchDepthModule; }
 269
 270   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
 271                                           SymbolContext &context,
 272                                           Address *addr) override {
 273     if (context.module_sp) {
 274       const char *cur_file_name =
 275           context.module_sp->GetFileSpec().GetFilename().GetCString();
 276       const char *cur_dir_name =
 277           context.module_sp->GetFileSpec().GetDirectory().GetCString();
 278
 279       bool match = false;
 280       if (m_file_name && cur_file_name &&
 281           strstr(cur_file_name, m_file_name) == cur_file_name)
 282         match = true;
 283
 284       if (match && m_dir_name && cur_dir_name &&
 285           strstr(cur_dir_name, m_dir_name) != cur_dir_name)
 286         match = false;
 287
 288       if (match) {
 289         m_request.AddCompletion(cur_file_name);
 290       }
 291     }
 292     return Searcher::eCallbackReturnContinue;
 293   }
 294
 295   void DoCompletion(SearchFilter *filter) override { filter->Search(*this); }
 296
 297 private:
 298   const char *m_file_name;
 299   const char *m_dir_name;
 300
 301   ModuleCompleter(const ModuleCompleter &) = delete;
 302   const ModuleCompleter &operator=(const ModuleCompleter &) = delete;
 303 };
 304 } // namespace
 305
 306 void CommandCompletions::SourceFiles(CommandInterpreter &interpreter,
 307                                      CompletionRequest &request,
 308                                      SearchFilter *searcher) {
 309   SourceFileCompleter completer(interpreter, request);
 310
 311   if (searcher == nullptr) {
 312     lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget();
 313     SearchFilterForUnconstrainedSearches null_searcher(target_sp);
 314     completer.DoCompletion(&null_searcher);
 315   } else {
 316     completer.DoCompletion(searcher);
 317   }
 318 }
 319
 320 static void DiskFilesOrDirectories(const llvm::Twine &partial_name,
 321                                    bool only_directories,
 322                                    CompletionRequest &request,
 323                                    TildeExpressionResolver &Resolver) {
 324   llvm::SmallString<256> CompletionBuffer;
 325   llvm::SmallString<256> Storage;
 326   partial_name.toVector(CompletionBuffer);
 327
 328   if (CompletionBuffer.size() >= PATH_MAX)
 329     return;
 330
 331   namespace path = llvm::sys::path;
 332
 333   llvm::StringRef SearchDir;
 334   llvm::StringRef PartialItem;
 335
 336   if (CompletionBuffer.startswith("~")) {
 337     llvm::StringRef Buffer = CompletionBuffer;
 338     size_t FirstSep =
 339         Buffer.find_if([](char c) { return path::is_separator(c); });
 340
 341     llvm::StringRef Username = Buffer.take_front(FirstSep);
 342     llvm::StringRef Remainder;
 343     if (FirstSep != llvm::StringRef::npos)
 344       Remainder = Buffer.drop_front(FirstSep + 1);
 345
 346     llvm::SmallString<256> Resolved;
 347     if (!Resolver.ResolveExact(Username, Resolved)) {
 348       // We couldn't resolve it as a full username.  If there were no slashes
 349       // then this might be a partial username.   We try to resolve it as such
 350       // but after that, we're done regardless of any matches.
 351       if (FirstSep == llvm::StringRef::npos) {
 352         llvm::StringSet<> MatchSet;
 353         Resolver.ResolvePartial(Username, MatchSet);
 354         for (const auto &S : MatchSet) {
 355           Resolved = S.getKey();
 356           path::append(Resolved, path::get_separator());
 357           request.AddCompletion(Resolved, "", CompletionMode::Partial);
 358         }
 359       }
 360       return;
 361     }
 362
 363     // If there was no trailing slash, then we're done as soon as we resolve
 364     // the expression to the correct directory.  Otherwise we need to continue
 365     // looking for matches within that directory.
 366     if (FirstSep == llvm::StringRef::npos) {
 367       // Make sure it ends with a separator.
 368       path::append(CompletionBuffer, path::get_separator());
 369       request.AddCompletion(CompletionBuffer, "", CompletionMode::Partial);
 370       return;
 371     }
 372
 373     // We want to keep the form the user typed, so we special case this to
 374     // search in the fully resolved directory, but CompletionBuffer keeps the
 375     // unmodified form that the user typed.
 376     Storage = Resolved;
 377     llvm::StringRef RemainderDir = path::parent_path(Remainder);
 378     if (!RemainderDir.empty()) {
 379       // Append the remaining path to the resolved directory.
 380       Storage.append(path::get_separator());
 381       Storage.append(RemainderDir);
 382     }
 383     SearchDir = Storage;
 384   } else if (CompletionBuffer == path::root_directory(CompletionBuffer)) {
 385     SearchDir = CompletionBuffer;
 386   } else {
 387     SearchDir = path::parent_path(CompletionBuffer);
 388   }
 389
 390   size_t FullPrefixLen = CompletionBuffer.size();
 391
 392   PartialItem = path::filename(CompletionBuffer);
 393
 394   // path::filename() will return "." when the passed path ends with a
 395   // directory separator or the separator when passed the disk root directory.
 396   // We have to filter those out, but only when the "." doesn't come from the
 397   // completion request itself.
 398   if ((PartialItem == "." || PartialItem == path::get_separator()) &&
 399       path::is_separator(CompletionBuffer.back()))
 400     PartialItem = llvm::StringRef();
 401
 402   if (SearchDir.empty()) {
 403     llvm::sys::fs::current_path(Storage);
 404     SearchDir = Storage;
 405   }
 406   assert(!PartialItem.contains(path::get_separator()));
 407
 408   // SearchDir now contains the directory to search in, and Prefix contains the
 409   // text we want to match against items in that directory.
 410
 411   FileSystem &fs = FileSystem::Instance();
 412   std::error_code EC;
 413   llvm::vfs::directory_iterator Iter = fs.DirBegin(SearchDir, EC);
 414   llvm::vfs::directory_iterator End;
 415   for (; Iter != End && !EC; Iter.increment(EC)) {
 416     auto &Entry = *Iter;
 417     llvm::ErrorOr<llvm::vfs::Status> Status = fs.GetStatus(Entry.path());
 418
 419     if (!Status)
 420       continue;
 421
 422     auto Name = path::filename(Entry.path());
 423
 424     // Omit ".", ".."
 425     if (Name == "." || Name == ".." || !Name.startswith(PartialItem))
 426       continue;
 427
 428     bool is_dir = Status->isDirectory();
 429
 430     // If it's a symlink, then we treat it as a directory as long as the target
 431     // is a directory.
 432     if (Status->isSymlink()) {
 433       FileSpec symlink_filespec(Entry.path());
 434       FileSpec resolved_filespec;
 435       auto error = fs.ResolveSymbolicLink(symlink_filespec, resolved_filespec);
 436       if (error.Success())
 437         is_dir = fs.IsDirectory(symlink_filespec);
 438     }
 439
 440     if (only_directories && !is_dir)
 441       continue;
 442
 443     // Shrink it back down so that it just has the original prefix the user
 444     // typed and remove the part of the name which is common to the located
 445     // item and what the user typed.
 446     CompletionBuffer.resize(FullPrefixLen);
 447     Name = Name.drop_front(PartialItem.size());
 448     CompletionBuffer.append(Name);
 449
 450     if (is_dir) {
 451       path::append(CompletionBuffer, path::get_separator());
 452     }
 453
 454     CompletionMode mode =
 455         is_dir ? CompletionMode::Partial : CompletionMode::Normal;
 456     request.AddCompletion(CompletionBuffer, "", mode);
 457   }
 458 }
 459
 460 static void DiskFilesOrDirectories(const llvm::Twine &partial_name,
 461                                    bool only_directories, StringList &matches,
 462                                    TildeExpressionResolver &Resolver) {
 463   CompletionResult result;
 464   std::string partial_name_str = partial_name.str();
 465   CompletionRequest request(partial_name_str, partial_name_str.size(), result);
 466   DiskFilesOrDirectories(partial_name, only_directories, request, Resolver);
 467   result.GetMatches(matches);
 468 }
 469
 470 static void DiskFilesOrDirectories(CompletionRequest &request,
 471                                    bool only_directories) {
 472   StandardTildeExpressionResolver resolver;
 473   DiskFilesOrDirectories(request.GetCursorArgumentPrefix(), only_directories,
 474                          request, resolver);
 475 }
 476
 477 void CommandCompletions::DiskFiles(CommandInterpreter &interpreter,
 478                                    CompletionRequest &request,
 479                                    SearchFilter *searcher) {
 480   DiskFilesOrDirectories(request, /*only_dirs*/ false);
 481 }
 482
 483 void CommandCompletions::DiskFiles(const llvm::Twine &partial_file_name,
 484                                    StringList &matches,
 485                                    TildeExpressionResolver &Resolver) {
 486   DiskFilesOrDirectories(partial_file_name, false, matches, Resolver);
 487 }
 488
 489 void CommandCompletions::DiskDirectories(CommandInterpreter &interpreter,
 490                                          CompletionRequest &request,
 491                                          SearchFilter *searcher) {
 492   DiskFilesOrDirectories(request, /*only_dirs*/ true);
 493 }
 494
 495 void CommandCompletions::DiskDirectories(const llvm::Twine &partial_file_name,
 496                                          StringList &matches,
 497                                          TildeExpressionResolver &Resolver) {
 498   DiskFilesOrDirectories(partial_file_name, true, matches, Resolver);
 499 }
 500
 501 void CommandCompletions::RemoteDiskFiles(CommandInterpreter &interpreter,
 502                                          CompletionRequest &request,
 503                                          SearchFilter *searcher) {
 504   lldb::PlatformSP platform_sp =
 505       interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform();
 506   if (platform_sp)
 507     platform_sp->AutoCompleteDiskFileOrDirectory(request, false);
 508 }
 509
 510 void CommandCompletions::RemoteDiskDirectories(CommandInterpreter &interpreter,
 511                                                CompletionRequest &request,
 512                                                SearchFilter *searcher) {
 513   lldb::PlatformSP platform_sp =
 514       interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform();
 515   if (platform_sp)
 516     platform_sp->AutoCompleteDiskFileOrDirectory(request, true);
 517 }
 518
 519 void CommandCompletions::Modules(CommandInterpreter &interpreter,
 520                                  CompletionRequest &request,
 521                                  SearchFilter *searcher) {
 522   ModuleCompleter completer(interpreter, request);
 523
 524   if (searcher == nullptr) {
 525     lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget();
 526     SearchFilterForUnconstrainedSearches null_searcher(target_sp);
 527     completer.DoCompletion(&null_searcher);
 528   } else {
 529     completer.DoCompletion(searcher);
 530   }
 531 }
 532
 533 void CommandCompletions::ModuleUUIDs(CommandInterpreter &interpreter,
 534                                      CompletionRequest &request,
 535                                      SearchFilter *searcher) {
 536   const ExecutionContext &exe_ctx = interpreter.GetExecutionContext();
 537   if (!exe_ctx.HasTargetScope())
 538     return;
 539
 540   exe_ctx.GetTargetPtr()->GetImages().ForEach(
 541       [&request](const lldb::ModuleSP &module) {
 542         StreamString strm;
 543         module->GetDescription(strm.AsRawOstream(),
 544                                lldb::eDescriptionLevelInitial);
 545         request.TryCompleteCurrentArg(module->GetUUID().GetAsString(),
 546                                       strm.GetString());
 547         return true;
 548       });
 549 }
 550
 551 void CommandCompletions::Symbols(CommandInterpreter &interpreter,
 552                                  CompletionRequest &request,
 553                                  SearchFilter *searcher) {
 554   SymbolCompleter completer(interpreter, request);
 555
 556   if (searcher == nullptr) {
 557     lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget();
 558     SearchFilterForUnconstrainedSearches null_searcher(target_sp);
 559     completer.DoCompletion(&null_searcher);
 560   } else {
 561     completer.DoCompletion(searcher);
 562   }
 563 }
 564
 565 void CommandCompletions::SettingsNames(CommandInterpreter &interpreter,
 566                                        CompletionRequest &request,
 567                                        SearchFilter *searcher) {
 568   // Cache the full setting name list
 569   static StringList g_property_names;
 570   if (g_property_names.GetSize() == 0) {
 571     // Generate the full setting name list on demand
 572     lldb::OptionValuePropertiesSP properties_sp(
 573         interpreter.GetDebugger().GetValueProperties());
 574     if (properties_sp) {
 575       StreamString strm;
 576       properties_sp->DumpValue(nullptr, strm, OptionValue::eDumpOptionName);
 577       const std::string &str = std::string(strm.GetString());
 578       g_property_names.SplitIntoLines(str.c_str(), str.size());
 579     }
 580   }
 581
 582   for (const std::string &s : g_property_names)
 583     request.TryCompleteCurrentArg(s);
 584 }
 585
 586 void CommandCompletions::PlatformPluginNames(CommandInterpreter &interpreter,
 587                                              CompletionRequest &request,
 588                                              SearchFilter *searcher) {
 589   PluginManager::AutoCompletePlatformName(request.GetCursorArgumentPrefix(),
 590                                           request);
 591 }
 592
 593 void CommandCompletions::ArchitectureNames(CommandInterpreter &interpreter,
 594                                            CompletionRequest &request,
 595                                            SearchFilter *searcher) {
 596   ArchSpec::AutoComplete(request);
 597 }
 598
 599 void CommandCompletions::VariablePath(CommandInterpreter &interpreter,
 600                                       CompletionRequest &request,
 601                                       SearchFilter *searcher) {
 602   Variable::AutoComplete(interpreter.GetExecutionContext(), request);
 603 }
 604
 605 void CommandCompletions::Registers(CommandInterpreter &interpreter,
 606                                    CompletionRequest &request,
 607                                    SearchFilter *searcher) {
 608   std::string reg_prefix;
 609   if (request.GetCursorArgumentPrefix().startswith("$"))
 610     reg_prefix = "$";
 611
 612   RegisterContext *reg_ctx =
 613       interpreter.GetExecutionContext().GetRegisterContext();
 614   if (!reg_ctx)
 615     return;
 616
 617   const size_t reg_num = reg_ctx->GetRegisterCount();
 618   for (size_t reg_idx = 0; reg_idx < reg_num; ++reg_idx) {
 619     const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg_idx);
 620     request.TryCompleteCurrentArg(reg_prefix + reg_info->name,
 621                                   reg_info->alt_name);
 622   }
 623 }
 624
 625 void CommandCompletions::Breakpoints(CommandInterpreter &interpreter,
 626                                      CompletionRequest &request,
 627                                      SearchFilter *searcher) {
 628   lldb::TargetSP target = interpreter.GetDebugger().GetSelectedTarget();
 629   if (!target)
 630     return;
 631
 632   const BreakpointList &breakpoints = target->GetBreakpointList();
 633
 634   std::unique_lock<std::recursive_mutex> lock;
 635   target->GetBreakpointList().GetListMutex(lock);
 636
 637   size_t num_breakpoints = breakpoints.GetSize();
 638   if (num_breakpoints == 0)
 639     return;
 640
 641   for (size_t i = 0; i < num_breakpoints; ++i) {
 642     lldb::BreakpointSP bp = breakpoints.GetBreakpointAtIndex(i);
 643
 644     StreamString s;
 645     bp->GetDescription(&s, lldb::eDescriptionLevelBrief);
 646     llvm::StringRef bp_info = s.GetString();
 647
 648     const size_t colon_pos = bp_info.find_first_of(':');
 649     if (colon_pos != llvm::StringRef::npos)
 650       bp_info = bp_info.drop_front(colon_pos + 2);
 651
 652     request.TryCompleteCurrentArg(std::to_string(bp->GetID()), bp_info);
 653   }
 654 }
 655
 656 void CommandCompletions::BreakpointNames(CommandInterpreter &interpreter,
 657                                          CompletionRequest &request,
 658                                          SearchFilter *searcher) {
 659   lldb::TargetSP target = interpreter.GetDebugger().GetSelectedTarget();
 660   if (!target)
 661     return;
 662
 663   std::vector<std::string> name_list;
 664   target->GetBreakpointNames(name_list);
 665
 666   for (const std::string &name : name_list)
 667     request.TryCompleteCurrentArg(name);
 668 }
 669
 670 void CommandCompletions::ProcessPluginNames(CommandInterpreter &interpreter,
 671                                             CompletionRequest &request,
 672                                             SearchFilter *searcher) {
 673   PluginManager::AutoCompleteProcessName(request.GetCursorArgumentPrefix(),
 674                                          request);
 675 }
 676 void CommandCompletions::DisassemblyFlavors(CommandInterpreter &interpreter,
 677                                             CompletionRequest &request,
 678                                             SearchFilter *searcher) {
 679   // Currently the only valid options for disassemble -F are default, and for
 680   // Intel architectures, att and intel.
 681   static const char *flavors[] = {"default", "att", "intel"};
 682   for (const char *flavor : flavors) {
 683     request.TryCompleteCurrentArg(flavor);
 684   }
 685 }
 686
 687 void CommandCompletions::ProcessIDs(CommandInterpreter &interpreter,
 688                                     CompletionRequest &request,
 689                                     SearchFilter *searcher) {
 690   lldb::PlatformSP platform_sp(interpreter.GetPlatform(true));
 691   if (!platform_sp)
 692     return;
 693   ProcessInstanceInfoList process_infos;
 694   ProcessInstanceInfoMatch match_info;
 695   platform_sp->FindProcesses(match_info, process_infos);
 696   for (const ProcessInstanceInfo &info : process_infos)
 697     request.TryCompleteCurrentArg(std::to_string(info.GetProcessID()),
 698                                   info.GetNameAsStringRef());
 699 }
 700
 701 void CommandCompletions::ProcessNames(CommandInterpreter &interpreter,
 702                                       CompletionRequest &request,
 703                                       SearchFilter *searcher) {
 704   lldb::PlatformSP platform_sp(interpreter.GetPlatform(true));
 705   if (!platform_sp)
 706     return;
 707   ProcessInstanceInfoList process_infos;
 708   ProcessInstanceInfoMatch match_info;
 709   platform_sp->FindProcesses(match_info, process_infos);
 710   for (const ProcessInstanceInfo &info : process_infos)
 711     request.TryCompleteCurrentArg(info.GetNameAsStringRef());
 712 }
 713
 714 void CommandCompletions::TypeLanguages(CommandInterpreter &interpreter,
 715                                        CompletionRequest &request,
 716                                        SearchFilter *searcher) {
 717   for (int bit :
 718        Language::GetLanguagesSupportingTypeSystems().bitvector.set_bits()) {
 719     request.TryCompleteCurrentArg(
 720         Language::GetNameForLanguageType(static_cast<lldb::LanguageType>(bit)));
 721   }
 722 }
 723
 724 void CommandCompletions::FrameIndexes(CommandInterpreter &interpreter,
 725                                       CompletionRequest &request,
 726                                       SearchFilter *searcher) {
 727   const ExecutionContext &exe_ctx = interpreter.GetExecutionContext();
 728   if (!exe_ctx.HasProcessScope())
 729     return;
 730
 731   lldb::ThreadSP thread_sp = exe_ctx.GetThreadSP();
 732   Debugger &dbg = interpreter.GetDebugger();
 733   const uint32_t frame_num = thread_sp->GetStackFrameCount();
 734   for (uint32_t i = 0; i < frame_num; ++i) {
 735     lldb::StackFrameSP frame_sp = thread_sp->GetStackFrameAtIndex(i);
 736     StreamString strm;
 737     // Dumping frames can be slow, allow interruption.
 738     if (INTERRUPT_REQUESTED(dbg, "Interrupted in frame completion"))
 739       break;
 740     frame_sp->Dump(&strm, false, true);
 741     request.TryCompleteCurrentArg(std::to_string(i), strm.GetString());
 742   }
 743 }
 744
 745 void CommandCompletions::StopHookIDs(CommandInterpreter &interpreter,
 746                                      CompletionRequest &request,
 747                                      SearchFilter *searcher) {
 748   const lldb::TargetSP target_sp =
 749       interpreter.GetExecutionContext().GetTargetSP();
 750   if (!target_sp)
 751     return;
 752
 753   const size_t num = target_sp->GetNumStopHooks();
 754   for (size_t idx = 0; idx < num; ++idx) {
 755     StreamString strm;
 756     // The value 11 is an offset to make the completion description looks
 757     // neater.
 758     strm.SetIndentLevel(11);
 759     const Target::StopHookSP stophook_sp = target_sp->GetStopHookAtIndex(idx);
 760     stophook_sp->GetDescription(strm, lldb::eDescriptionLevelInitial);
 761     request.TryCompleteCurrentArg(std::to_string(stophook_sp->GetID()),
 762                                   strm.GetString());
 763   }
 764 }
 765
 766 void CommandCompletions::ThreadIndexes(CommandInterpreter &interpreter,
 767                                        CompletionRequest &request,
 768                                        SearchFilter *searcher) {
 769   const ExecutionContext &exe_ctx = interpreter.GetExecutionContext();
 770   if (!exe_ctx.HasProcessScope())
 771     return;
 772
 773   ThreadList &threads = exe_ctx.GetProcessPtr()->GetThreadList();
 774   lldb::ThreadSP thread_sp;
 775   for (uint32_t idx = 0; (thread_sp = threads.GetThreadAtIndex(idx)); ++idx) {
 776     StreamString strm;
 777     thread_sp->GetStatus(strm, 0, 1, 1, true);
 778     request.TryCompleteCurrentArg(std::to_string(thread_sp->GetIndexID()),
 779                                   strm.GetString());
 780   }
 781 }
 782
 783 void CommandCompletions::WatchPointIDs(CommandInterpreter &interpreter,
 784                                        CompletionRequest &request,
 785                                        SearchFilter *searcher) {
 786   const ExecutionContext &exe_ctx = interpreter.GetExecutionContext();
 787   if (!exe_ctx.HasTargetScope())
 788     return;
 789
 790   const WatchpointList &wp_list = exe_ctx.GetTargetPtr()->GetWatchpointList();
 791   for (lldb::WatchpointSP wp_sp : wp_list.Watchpoints()) {
 792     StreamString strm;
 793     wp_sp->Dump(&strm);
 794     request.TryCompleteCurrentArg(std::to_string(wp_sp->GetID()),
 795                                   strm.GetString());
 796   }
 797 }
 798
 799 void CommandCompletions::TypeCategoryNames(CommandInterpreter &interpreter,
 800                                            CompletionRequest &request,
 801                                            SearchFilter *searcher) {
 802   DataVisualization::Categories::ForEach(
 803       [&request](const lldb::TypeCategoryImplSP &category_sp) {
 804         request.TryCompleteCurrentArg(category_sp->GetName(),
 805                                       category_sp->GetDescription());
 806         return true;
 807       });
 808 }
 809
 810 void CommandCompletions::CompleteModifiableCmdPathArgs(
 811     CommandInterpreter &interpreter, CompletionRequest &request,
 812     OptionElementVector &opt_element_vector) {
 813   // The only arguments constitute a command path, however, there might be
 814   // options interspersed among the arguments, and we need to skip those.  Do that
 815   // by copying the args vector, and just dropping all the option bits:
 816   Args args = request.GetParsedLine();
 817   std::vector<size_t> to_delete;
 818   for (auto &elem : opt_element_vector) {
 819     to_delete.push_back(elem.opt_pos);
 820     if (elem.opt_arg_pos != 0)
 821       to_delete.push_back(elem.opt_arg_pos);
 822   }
 823   sort(to_delete.begin(), to_delete.end(), std::greater<size_t>());
 824   for (size_t idx : to_delete)
 825     args.DeleteArgumentAtIndex(idx);
 826
 827   // At this point, we should only have args, so now lookup the command up to
 828   // the cursor element.
 829
 830   // There's nothing here but options.  It doesn't seem very useful here to
 831   // dump all the commands, so just return.
 832   size_t num_args = args.GetArgumentCount();
 833   if (num_args == 0)
 834     return;
 835
 836   // There's just one argument, so we should complete its name:
 837   StringList matches;
 838   if (num_args == 1) {
 839     interpreter.GetUserCommandObject(args.GetArgumentAtIndex(0), &matches,
 840                                      nullptr);
 841     request.AddCompletions(matches);
 842     return;
 843   }
 844
 845   // There was more than one path element, lets find the containing command:
 846   Status error;
 847   CommandObjectMultiword *mwc =
 848       interpreter.VerifyUserMultiwordCmdPath(args, true, error);
 849
 850   // Something was wrong somewhere along the path, but I don't think there's
 851   // a good way to go back and fill in the missing elements:
 852   if (error.Fail())
 853     return;
 854
 855   // This should never happen.  We already handled the case of one argument
 856   // above, and we can only get Success & nullptr back if there's a one-word
 857   // leaf.
 858   assert(mwc != nullptr);
 859
 860   mwc->GetSubcommandObject(args.GetArgumentAtIndex(num_args - 1), &matches);
 861   if (matches.GetSize() == 0)
 862     return;
 863
 864   request.AddCompletions(matches);
 865 }