contrib/llvm/tools/lldb/source/Symbol/Variable.cpp

   1 //===-- Variable.cpp --------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Symbol/Variable.h"
  11
  12 #include "lldb/Core/Module.h"
  13 #include "lldb/Core/ValueObject.h"
  14 #include "lldb/Core/ValueObjectVariable.h"
  15 #include "lldb/Symbol/Block.h"
  16 #include "lldb/Symbol/CompileUnit.h"
  17 #include "lldb/Symbol/CompilerDecl.h"
  18 #include "lldb/Symbol/CompilerDeclContext.h"
  19 #include "lldb/Symbol/Function.h"
  20 #include "lldb/Symbol/SymbolContext.h"
  21 #include "lldb/Symbol/SymbolFile.h"
  22 #include "lldb/Symbol/Type.h"
  23 #include "lldb/Symbol/TypeSystem.h"
  24 #include "lldb/Symbol/VariableList.h"
  25 #include "lldb/Target/ABI.h"
  26 #include "lldb/Target/Process.h"
  27 #include "lldb/Target/RegisterContext.h"
  28 #include "lldb/Target/StackFrame.h"
  29 #include "lldb/Target/Target.h"
  30 #include "lldb/Target/Thread.h"
  31 #include "lldb/Utility/RegularExpression.h"
  32 #include "lldb/Utility/Stream.h"
  33
  34 #include "llvm/ADT/Twine.h"
  35
  36 using namespace lldb;
  37 using namespace lldb_private;
  38
  39 //----------------------------------------------------------------------
  40 // Variable constructor
  41 //----------------------------------------------------------------------
  42 Variable::Variable(
  43     lldb::user_id_t uid, const char *name,
  44     const char *mangled, // The mangled or fully qualified name of the variable.
  45     const lldb::SymbolFileTypeSP &symfile_type_sp, ValueType scope,
  46     SymbolContextScope *context, const RangeList &scope_range,
  47     Declaration *decl_ptr, const DWARFExpression &location, bool external,
  48     bool artificial, bool static_member)
  49     : UserID(uid), m_name(name), m_mangled(ConstString(mangled)),
  50       m_symfile_type_sp(symfile_type_sp), m_scope(scope),
  51       m_owner_scope(context), m_scope_range(scope_range),
  52       m_declaration(decl_ptr), m_location(location), m_external(external),
  53       m_artificial(artificial), m_static_member(static_member) {}
  54
  55 //----------------------------------------------------------------------
  56 // Destructor
  57 //----------------------------------------------------------------------
  58 Variable::~Variable() {}
  59
  60 lldb::LanguageType Variable::GetLanguage() const {
  61   SymbolContext variable_sc;
  62   m_owner_scope->CalculateSymbolContext(&variable_sc);
  63   if (variable_sc.comp_unit)
  64     return variable_sc.comp_unit->GetLanguage();
  65   return lldb::eLanguageTypeUnknown;
  66 }
  67
  68 ConstString Variable::GetName() const {
  69   ConstString name = m_mangled.GetName(GetLanguage());
  70   if (name)
  71     return name;
  72   return m_name;
  73 }
  74
  75 ConstString Variable::GetUnqualifiedName() const { return m_name; }
  76
  77 bool Variable::NameMatches(const ConstString &name) const {
  78   if (m_name == name)
  79     return true;
  80   SymbolContext variable_sc;
  81   m_owner_scope->CalculateSymbolContext(&variable_sc);
  82
  83   LanguageType language = eLanguageTypeUnknown;
  84   if (variable_sc.comp_unit)
  85     language = variable_sc.comp_unit->GetLanguage();
  86   return m_mangled.NameMatches(name, language);
  87 }
  88 bool Variable::NameMatches(const RegularExpression &regex) const {
  89   if (regex.Execute(m_name.AsCString()))
  90     return true;
  91   if (m_mangled)
  92     return m_mangled.NameMatches(regex, GetLanguage());
  93   return false;
  94 }
  95
  96 Type *Variable::GetType() {
  97   if (m_symfile_type_sp)
  98     return m_symfile_type_sp->GetType();
  99   return nullptr;
 100 }
 101
 102 void Variable::Dump(Stream *s, bool show_context) const {
 103   s->Printf("%p: ", static_cast<const void *>(this));
 104   s->Indent();
 105   *s << "Variable" << (const UserID &)*this;
 106
 107   if (m_name)
 108     *s << ", name = \"" << m_name << "\"";
 109
 110   if (m_symfile_type_sp) {
 111     Type *type = m_symfile_type_sp->GetType();
 112     if (type) {
 113       *s << ", type = {" << type->GetID() << "} " << (void *)type << " (";
 114       type->DumpTypeName(s);
 115       s->PutChar(')');
 116     }
 117   }
 118
 119   if (m_scope != eValueTypeInvalid) {
 120     s->PutCString(", scope = ");
 121     switch (m_scope) {
 122     case eValueTypeVariableGlobal:
 123       s->PutCString(m_external ? "global" : "static");
 124       break;
 125     case eValueTypeVariableArgument:
 126       s->PutCString("parameter");
 127       break;
 128     case eValueTypeVariableLocal:
 129       s->PutCString("local");
 130       break;
 131     case eValueTypeVariableThreadLocal:
 132       s->PutCString("thread local");
 133       break;
 134     default:
 135       *s << "??? (" << m_scope << ')';
 136     }
 137   }
 138
 139   if (show_context && m_owner_scope != nullptr) {
 140     s->PutCString(", context = ( ");
 141     m_owner_scope->DumpSymbolContext(s);
 142     s->PutCString(" )");
 143   }
 144
 145   bool show_fullpaths = false;
 146   m_declaration.Dump(s, show_fullpaths);
 147
 148   if (m_location.IsValid()) {
 149     s->PutCString(", location = ");
 150     lldb::addr_t loclist_base_addr = LLDB_INVALID_ADDRESS;
 151     if (m_location.IsLocationList()) {
 152       SymbolContext variable_sc;
 153       m_owner_scope->CalculateSymbolContext(&variable_sc);
 154       if (variable_sc.function)
 155         loclist_base_addr = variable_sc.function->GetAddressRange()
 156                                 .GetBaseAddress()
 157                                 .GetFileAddress();
 158     }
 159     ABI *abi = nullptr;
 160     if (m_owner_scope) {
 161       ModuleSP module_sp(m_owner_scope->CalculateSymbolContextModule());
 162       if (module_sp)
 163         abi = ABI::FindPlugin(ProcessSP(), module_sp->GetArchitecture()).get();
 164     }
 165     m_location.GetDescription(s, lldb::eDescriptionLevelBrief,
 166                               loclist_base_addr, abi);
 167   }
 168
 169   if (m_external)
 170     s->PutCString(", external");
 171
 172   if (m_artificial)
 173     s->PutCString(", artificial");
 174
 175   s->EOL();
 176 }
 177
 178 bool Variable::DumpDeclaration(Stream *s, bool show_fullpaths,
 179                                bool show_module) {
 180   bool dumped_declaration_info = false;
 181   if (m_owner_scope) {
 182     SymbolContext sc;
 183     m_owner_scope->CalculateSymbolContext(&sc);
 184     sc.block = nullptr;
 185     sc.line_entry.Clear();
 186     bool show_inlined_frames = false;
 187     const bool show_function_arguments = true;
 188     const bool show_function_name = true;
 189
 190     dumped_declaration_info = sc.DumpStopContext(
 191         s, nullptr, Address(), show_fullpaths, show_module, show_inlined_frames,
 192         show_function_arguments, show_function_name);
 193
 194     if (sc.function)
 195       s->PutChar(':');
 196   }
 197   if (m_declaration.DumpStopContext(s, false))
 198     dumped_declaration_info = true;
 199   return dumped_declaration_info;
 200 }
 201
 202 size_t Variable::MemorySize() const { return sizeof(Variable); }
 203
 204 CompilerDeclContext Variable::GetDeclContext() {
 205   Type *type = GetType();
 206   if (type)
 207     return type->GetSymbolFile()->GetDeclContextContainingUID(GetID());
 208   return CompilerDeclContext();
 209 }
 210
 211 CompilerDecl Variable::GetDecl() {
 212   Type *type = GetType();
 213   return type ? type->GetSymbolFile()->GetDeclForUID(GetID()) : CompilerDecl();
 214 }
 215
 216 void Variable::CalculateSymbolContext(SymbolContext *sc) {
 217   if (m_owner_scope) {
 218     m_owner_scope->CalculateSymbolContext(sc);
 219     sc->variable = this;
 220   } else
 221     sc->Clear(false);
 222 }
 223
 224 bool Variable::LocationIsValidForFrame(StackFrame *frame) {
 225   // Is the variable is described by a single location?
 226   if (!m_location.IsLocationList()) {
 227     // Yes it is, the location is valid.
 228     return true;
 229   }
 230
 231   if (frame) {
 232     Function *function =
 233         frame->GetSymbolContext(eSymbolContextFunction).function;
 234     if (function) {
 235       TargetSP target_sp(frame->CalculateTarget());
 236
 237       addr_t loclist_base_load_addr =
 238           function->GetAddressRange().GetBaseAddress().GetLoadAddress(
 239               target_sp.get());
 240       if (loclist_base_load_addr == LLDB_INVALID_ADDRESS)
 241         return false;
 242       // It is a location list. We just need to tell if the location
 243       // list contains the current address when converted to a load
 244       // address
 245       return m_location.LocationListContainsAddress(
 246           loclist_base_load_addr,
 247           frame->GetFrameCodeAddress().GetLoadAddress(target_sp.get()));
 248     }
 249   }
 250   return false;
 251 }
 252
 253 bool Variable::LocationIsValidForAddress(const Address &address) {
 254   // Be sure to resolve the address to section offset prior to
 255   // calling this function.
 256   if (address.IsSectionOffset()) {
 257     SymbolContext sc;
 258     CalculateSymbolContext(&sc);
 259     if (sc.module_sp == address.GetModule()) {
 260       // Is the variable is described by a single location?
 261       if (!m_location.IsLocationList()) {
 262         // Yes it is, the location is valid.
 263         return true;
 264       }
 265
 266       if (sc.function) {
 267         addr_t loclist_base_file_addr =
 268             sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
 269         if (loclist_base_file_addr == LLDB_INVALID_ADDRESS)
 270           return false;
 271         // It is a location list. We just need to tell if the location
 272         // list contains the current address when converted to a load
 273         // address
 274         return m_location.LocationListContainsAddress(loclist_base_file_addr,
 275                                                       address.GetFileAddress());
 276       }
 277     }
 278   }
 279   return false;
 280 }
 281
 282 bool Variable::IsInScope(StackFrame *frame) {
 283   switch (m_scope) {
 284   case eValueTypeRegister:
 285   case eValueTypeRegisterSet:
 286     return frame != nullptr;
 287
 288   case eValueTypeConstResult:
 289   case eValueTypeVariableGlobal:
 290   case eValueTypeVariableStatic:
 291   case eValueTypeVariableThreadLocal:
 292     return true;
 293
 294   case eValueTypeVariableArgument:
 295   case eValueTypeVariableLocal:
 296     if (frame) {
 297       // We don't have a location list, we just need to see if the block
 298       // that this variable was defined in is currently
 299       Block *deepest_frame_block =
 300           frame->GetSymbolContext(eSymbolContextBlock).block;
 301       if (deepest_frame_block) {
 302         SymbolContext variable_sc;
 303         CalculateSymbolContext(&variable_sc);
 304
 305         // Check for static or global variable defined at the compile unit
 306         // level that wasn't defined in a block
 307         if (variable_sc.block == nullptr)
 308           return true;
 309
 310         // Check if the variable is valid in the current block
 311         if (variable_sc.block != deepest_frame_block &&
 312             !variable_sc.block->Contains(deepest_frame_block))
 313           return false;
 314
 315         // If no scope range is specified then it means that the scope is the
 316         // same as the
 317         // scope of the enclosing lexical block.
 318         if (m_scope_range.IsEmpty())
 319           return true;
 320
 321         addr_t file_address = frame->GetFrameCodeAddress().GetFileAddress();
 322         return m_scope_range.FindEntryThatContains(file_address) != nullptr;
 323       }
 324     }
 325     break;
 326
 327   default:
 328     break;
 329   }
 330   return false;
 331 }
 332
 333 Status Variable::GetValuesForVariableExpressionPath(
 334     llvm::StringRef variable_expr_path, ExecutionContextScope *scope,
 335     GetVariableCallback callback, void *baton, VariableList &variable_list,
 336     ValueObjectList &valobj_list) {
 337   Status error;
 338   if (!callback || variable_expr_path.empty()) {
 339     error.SetErrorString("unknown error");
 340     return error;
 341   }
 342
 343   switch (variable_expr_path.front()) {
 344   case '*':
 345     error = Variable::GetValuesForVariableExpressionPath(
 346         variable_expr_path.drop_front(), scope, callback, baton, variable_list,
 347         valobj_list);
 348     if (error.Fail()) {
 349       error.SetErrorString("unknown error");
 350       return error;
 351     }
 352     for (uint32_t i = 0; i < valobj_list.GetSize();) {
 353       Status tmp_error;
 354       ValueObjectSP valobj_sp(
 355           valobj_list.GetValueObjectAtIndex(i)->Dereference(tmp_error));
 356       if (tmp_error.Fail()) {
 357         variable_list.RemoveVariableAtIndex(i);
 358         valobj_list.RemoveValueObjectAtIndex(i);
 359       } else {
 360         valobj_list.SetValueObjectAtIndex(i, valobj_sp);
 361         ++i;
 362       }
 363     }
 364     return error;
 365   case '&': {
 366     error = Variable::GetValuesForVariableExpressionPath(
 367         variable_expr_path.drop_front(), scope, callback, baton, variable_list,
 368         valobj_list);
 369     if (error.Success()) {
 370       for (uint32_t i = 0; i < valobj_list.GetSize();) {
 371         Status tmp_error;
 372         ValueObjectSP valobj_sp(
 373             valobj_list.GetValueObjectAtIndex(i)->AddressOf(tmp_error));
 374         if (tmp_error.Fail()) {
 375           variable_list.RemoveVariableAtIndex(i);
 376           valobj_list.RemoveValueObjectAtIndex(i);
 377         } else {
 378           valobj_list.SetValueObjectAtIndex(i, valobj_sp);
 379           ++i;
 380         }
 381       }
 382     } else {
 383       error.SetErrorString("unknown error");
 384     }
 385     return error;
 386   } break;
 387
 388   default: {
 389     static RegularExpression g_regex(
 390         llvm::StringRef("^([A-Za-z_:][A-Za-z_0-9:]*)(.*)"));
 391     RegularExpression::Match regex_match(1);
 392     std::string variable_name;
 393     variable_list.Clear();
 394     if (!g_regex.Execute(variable_expr_path, &regex_match)) {
 395       error.SetErrorStringWithFormat(
 396           "unable to extract a variable name from '%s'",
 397           variable_expr_path.str().c_str());
 398       return error;
 399     }
 400     if (!regex_match.GetMatchAtIndex(variable_expr_path, 1, variable_name)) {
 401       error.SetErrorStringWithFormat(
 402           "unable to extract a variable name from '%s'",
 403           variable_expr_path.str().c_str());
 404       return error;
 405     }
 406     if (!callback(baton, variable_name.c_str(), variable_list)) {
 407       error.SetErrorString("unknown error");
 408       return error;
 409     }
 410     uint32_t i = 0;
 411     while (i < variable_list.GetSize()) {
 412       VariableSP var_sp(variable_list.GetVariableAtIndex(i));
 413       ValueObjectSP valobj_sp;
 414       if (!var_sp) {
 415         variable_list.RemoveVariableAtIndex(i);
 416         continue;
 417       }
 418       ValueObjectSP variable_valobj_sp(
 419           ValueObjectVariable::Create(scope, var_sp));
 420       if (!variable_valobj_sp) {
 421         variable_list.RemoveVariableAtIndex(i);
 422         continue;
 423       }
 424
 425       llvm::StringRef variable_sub_expr_path =
 426           variable_expr_path.drop_front(variable_name.size());
 427       if (!variable_sub_expr_path.empty()) {
 428         ValueObject::ExpressionPathScanEndReason reason_to_stop;
 429         ValueObject::ExpressionPathEndResultType final_value_type;
 430         ValueObject::GetValueForExpressionPathOptions options;
 431         ValueObject::ExpressionPathAftermath final_task_on_target;
 432
 433         valobj_sp = variable_valobj_sp->GetValueForExpressionPath(
 434             variable_sub_expr_path, &reason_to_stop, &final_value_type, options,
 435             &final_task_on_target);
 436         if (!valobj_sp) {
 437           error.SetErrorStringWithFormat(
 438               "invalid expression path '%s' for variable '%s'",
 439               variable_sub_expr_path.str().c_str(),
 440               var_sp->GetName().GetCString());
 441           variable_list.RemoveVariableAtIndex(i);
 442           continue;
 443         }
 444       } else {
 445         // Just the name of a variable with no extras
 446         valobj_sp = variable_valobj_sp;
 447       }
 448
 449       valobj_list.Append(valobj_sp);
 450       ++i;
 451     }
 452
 453     if (variable_list.GetSize() > 0) {
 454       error.Clear();
 455       return error;
 456     }
 457   } break;
 458   }
 459   error.SetErrorString("unknown error");
 460   return error;
 461 }
 462
 463 bool Variable::DumpLocationForAddress(Stream *s, const Address &address) {
 464   // Be sure to resolve the address to section offset prior to
 465   // calling this function.
 466   if (address.IsSectionOffset()) {
 467     SymbolContext sc;
 468     CalculateSymbolContext(&sc);
 469     if (sc.module_sp == address.GetModule()) {
 470       ABI *abi = nullptr;
 471       if (m_owner_scope) {
 472         ModuleSP module_sp(m_owner_scope->CalculateSymbolContextModule());
 473         if (module_sp)
 474           abi = ABI::FindPlugin(ProcessSP(), module_sp->GetArchitecture()).get();
 475       }
 476
 477       const addr_t file_addr = address.GetFileAddress();
 478       if (sc.function) {
 479         if (sc.function->GetAddressRange().ContainsFileAddress(address)) {
 480           addr_t loclist_base_file_addr =
 481               sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
 482           if (loclist_base_file_addr == LLDB_INVALID_ADDRESS)
 483             return false;
 484           return m_location.DumpLocationForAddress(s, eDescriptionLevelBrief,
 485                                                    loclist_base_file_addr,
 486                                                    file_addr, abi);
 487         }
 488       }
 489       return m_location.DumpLocationForAddress(
 490           s, eDescriptionLevelBrief, LLDB_INVALID_ADDRESS, file_addr, abi);
 491     }
 492   }
 493   return false;
 494 }
 495
 496 static void PrivateAutoComplete(
 497     StackFrame *frame, llvm::StringRef partial_path,
 498     const llvm::Twine
 499         &prefix_path, // Anything that has been resolved already will be in here
 500     const CompilerType &compiler_type,
 501     StringList &matches, bool &word_complete);
 502
 503 static void PrivateAutoCompleteMembers(
 504     StackFrame *frame, const std::string &partial_member_name,
 505     llvm::StringRef partial_path,
 506     const llvm::Twine
 507         &prefix_path, // Anything that has been resolved already will be in here
 508     const CompilerType &compiler_type,
 509     StringList &matches, bool &word_complete);
 510
 511 static void PrivateAutoCompleteMembers(
 512     StackFrame *frame, const std::string &partial_member_name,
 513     llvm::StringRef partial_path,
 514     const llvm::Twine
 515         &prefix_path, // Anything that has been resolved already will be in here
 516     const CompilerType &compiler_type,
 517     StringList &matches, bool &word_complete) {
 518
 519   // We are in a type parsing child members
 520   const uint32_t num_bases = compiler_type.GetNumDirectBaseClasses();
 521
 522   if (num_bases > 0) {
 523     for (uint32_t i = 0; i < num_bases; ++i) {
 524       CompilerType base_class_type =
 525           compiler_type.GetDirectBaseClassAtIndex(i, nullptr);
 526
 527       PrivateAutoCompleteMembers(
 528           frame, partial_member_name, partial_path, prefix_path,
 529           base_class_type.GetCanonicalType(), matches, word_complete);
 530     }
 531   }
 532
 533   const uint32_t num_vbases = compiler_type.GetNumVirtualBaseClasses();
 534
 535   if (num_vbases > 0) {
 536     for (uint32_t i = 0; i < num_vbases; ++i) {
 537       CompilerType vbase_class_type =
 538           compiler_type.GetVirtualBaseClassAtIndex(i, nullptr);
 539
 540       PrivateAutoCompleteMembers(
 541           frame, partial_member_name, partial_path, prefix_path,
 542           vbase_class_type.GetCanonicalType(), matches, word_complete);
 543     }
 544   }
 545
 546   // We are in a type parsing child members
 547   const uint32_t num_fields = compiler_type.GetNumFields();
 548
 549   if (num_fields > 0) {
 550     for (uint32_t i = 0; i < num_fields; ++i) {
 551       std::string member_name;
 552
 553       CompilerType member_compiler_type = compiler_type.GetFieldAtIndex(
 554           i, member_name, nullptr, nullptr, nullptr);
 555
 556       if (partial_member_name.empty() ||
 557           member_name.find(partial_member_name) == 0) {
 558         if (member_name == partial_member_name) {
 559           PrivateAutoComplete(
 560               frame, partial_path,
 561               prefix_path + member_name, // Anything that has been resolved
 562                                          // already will be in here
 563               member_compiler_type.GetCanonicalType(), matches, word_complete);
 564         } else {
 565           matches.AppendString((prefix_path + member_name).str());
 566         }
 567       }
 568     }
 569   }
 570 }
 571
 572 static void PrivateAutoComplete(
 573     StackFrame *frame, llvm::StringRef partial_path,
 574     const llvm::Twine
 575         &prefix_path, // Anything that has been resolved already will be in here
 576     const CompilerType &compiler_type,
 577     StringList &matches, bool &word_complete) {
 578   //    printf ("\nPrivateAutoComplete()\n\tprefix_path = '%s'\n\tpartial_path =
 579   //    '%s'\n", prefix_path.c_str(), partial_path.c_str());
 580   std::string remaining_partial_path;
 581
 582   const lldb::TypeClass type_class = compiler_type.GetTypeClass();
 583   if (partial_path.empty()) {
 584     if (compiler_type.IsValid()) {
 585       switch (type_class) {
 586       default:
 587       case eTypeClassArray:
 588       case eTypeClassBlockPointer:
 589       case eTypeClassBuiltin:
 590       case eTypeClassComplexFloat:
 591       case eTypeClassComplexInteger:
 592       case eTypeClassEnumeration:
 593       case eTypeClassFunction:
 594       case eTypeClassMemberPointer:
 595       case eTypeClassReference:
 596       case eTypeClassTypedef:
 597       case eTypeClassVector: {
 598         matches.AppendString(prefix_path.str());
 599         word_complete = matches.GetSize() == 1;
 600       } break;
 601
 602       case eTypeClassClass:
 603       case eTypeClassStruct:
 604       case eTypeClassUnion:
 605         if (prefix_path.str().back() != '.')
 606           matches.AppendString((prefix_path + ".").str());
 607         break;
 608
 609       case eTypeClassObjCObject:
 610       case eTypeClassObjCInterface:
 611         break;
 612       case eTypeClassObjCObjectPointer:
 613       case eTypeClassPointer: {
 614         bool omit_empty_base_classes = true;
 615         if (compiler_type.GetNumChildren(omit_empty_base_classes) > 0)
 616           matches.AppendString((prefix_path + "->").str());
 617         else {
 618           matches.AppendString(prefix_path.str());
 619           word_complete = true;
 620         }
 621       } break;
 622       }
 623     } else {
 624       if (frame) {
 625         const bool get_file_globals = true;
 626
 627         VariableList *variable_list = frame->GetVariableList(get_file_globals);
 628
 629         if (variable_list) {
 630           const size_t num_variables = variable_list->GetSize();
 631           for (size_t i = 0; i < num_variables; ++i) {
 632             Variable *variable = variable_list->GetVariableAtIndex(i).get();
 633             matches.AppendString(variable->GetName().AsCString());
 634           }
 635         }
 636       }
 637     }
 638   } else {
 639     const char ch = partial_path[0];
 640     switch (ch) {
 641     case '*':
 642       if (prefix_path.str().empty()) {
 643         PrivateAutoComplete(frame, partial_path.substr(1), "*", compiler_type,
 644                             matches, word_complete);
 645       }
 646       break;
 647
 648     case '&':
 649       if (prefix_path.isTriviallyEmpty()) {
 650         PrivateAutoComplete(frame, partial_path.substr(1), std::string("&"),
 651                             compiler_type, matches, word_complete);
 652       }
 653       break;
 654
 655     case '-':
 656       if (partial_path[1] == '>' && !prefix_path.str().empty()) {
 657         switch (type_class) {
 658         case lldb::eTypeClassPointer: {
 659           CompilerType pointee_type(compiler_type.GetPointeeType());
 660           if (partial_path[2]) {
 661             // If there is more after the "->", then search deeper
 662             PrivateAutoComplete(
 663                 frame, partial_path.substr(2), prefix_path + "->",
 664                 pointee_type.GetCanonicalType(), matches, word_complete);
 665           } else {
 666             // Nothing after the "->", so list all members
 667             PrivateAutoCompleteMembers(
 668                 frame, std::string(), std::string(), prefix_path + "->",
 669                 pointee_type.GetCanonicalType(), matches, word_complete);
 670           }
 671         } break;
 672         default:
 673           break;
 674         }
 675       }
 676       break;
 677
 678     case '.':
 679       if (compiler_type.IsValid()) {
 680         switch (type_class) {
 681         case lldb::eTypeClassUnion:
 682         case lldb::eTypeClassStruct:
 683         case lldb::eTypeClassClass:
 684           if (partial_path[1]) {
 685             // If there is more after the ".", then search deeper
 686             PrivateAutoComplete(frame, partial_path.substr(1),
 687                                 prefix_path + ".", compiler_type, matches,
 688                                 word_complete);
 689
 690           } else {
 691             // Nothing after the ".", so list all members
 692             PrivateAutoCompleteMembers(frame, std::string(), partial_path,
 693                                        prefix_path + ".", compiler_type,
 694                                        matches, word_complete);
 695           }
 696           break;
 697         default:
 698           break;
 699         }
 700       }
 701       break;
 702     default:
 703       if (isalpha(ch) || ch == '_' || ch == '$') {
 704         const size_t partial_path_len = partial_path.size();
 705         size_t pos = 1;
 706         while (pos < partial_path_len) {
 707           const char curr_ch = partial_path[pos];
 708           if (isalnum(curr_ch) || curr_ch == '_' || curr_ch == '$') {
 709             ++pos;
 710             continue;
 711           }
 712           break;
 713         }
 714
 715         std::string token(partial_path, 0, pos);
 716         remaining_partial_path = partial_path.substr(pos);
 717
 718         if (compiler_type.IsValid()) {
 719           PrivateAutoCompleteMembers(frame, token, remaining_partial_path,
 720                                      prefix_path, compiler_type, matches,
 721                                      word_complete);
 722         } else if (frame) {
 723           // We haven't found our variable yet
 724           const bool get_file_globals = true;
 725
 726           VariableList *variable_list =
 727               frame->GetVariableList(get_file_globals);
 728
 729           if (!variable_list)
 730             break;
 731
 732           const size_t num_variables = variable_list->GetSize();
 733           for (size_t i = 0; i < num_variables; ++i) {
 734             Variable *variable = variable_list->GetVariableAtIndex(i).get();
 735
 736             if (!variable)
 737               continue;
 738
 739             const char *variable_name = variable->GetName().AsCString();
 740             if (strstr(variable_name, token.c_str()) == variable_name) {
 741               if (strcmp(variable_name, token.c_str()) == 0) {
 742                 Type *variable_type = variable->GetType();
 743                 if (variable_type) {
 744                   CompilerType variable_compiler_type(
 745                       variable_type->GetForwardCompilerType());
 746                   PrivateAutoComplete(
 747                       frame, remaining_partial_path,
 748                       prefix_path + token, // Anything that has been resolved
 749                                            // already will be in here
 750                       variable_compiler_type.GetCanonicalType(), matches,
 751                       word_complete);
 752                 } else {
 753                   matches.AppendString((prefix_path + variable_name).str());
 754                 }
 755               } else if (remaining_partial_path.empty()) {
 756                 matches.AppendString((prefix_path + variable_name).str());
 757               }
 758             }
 759           }
 760         }
 761       }
 762       break;
 763     }
 764   }
 765 }
 766
 767 size_t Variable::AutoComplete(const ExecutionContext &exe_ctx,
 768                               llvm::StringRef partial_path, StringList &matches,
 769                               bool &word_complete) {
 770   word_complete = false;
 771   CompilerType compiler_type;
 772
 773   PrivateAutoComplete(exe_ctx.GetFramePtr(), partial_path, "", compiler_type,
 774                       matches, word_complete);
 775
 776   return matches.GetSize();
 777 }