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