1 //===-- Variable.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 "lldb/Symbol/Variable.h"
10 
11 #include "lldb/Core/Module.h"
12 #include "lldb/Core/ValueObject.h"
13 #include "lldb/Core/ValueObjectVariable.h"
14 #include "lldb/Symbol/Block.h"
15 #include "lldb/Symbol/CompileUnit.h"
16 #include "lldb/Symbol/CompilerDecl.h"
17 #include "lldb/Symbol/CompilerDeclContext.h"
18 #include "lldb/Symbol/Function.h"
19 #include "lldb/Symbol/SymbolContext.h"
20 #include "lldb/Symbol/SymbolFile.h"
21 #include "lldb/Symbol/Type.h"
22 #include "lldb/Symbol/TypeSystem.h"
23 #include "lldb/Symbol/VariableList.h"
24 #include "lldb/Target/ABI.h"
25 #include "lldb/Target/Process.h"
26 #include "lldb/Target/RegisterContext.h"
27 #include "lldb/Target/StackFrame.h"
28 #include "lldb/Target/Target.h"
29 #include "lldb/Target/Thread.h"
30 #include "lldb/Utility/RegularExpression.h"
31 #include "lldb/Utility/Stream.h"
32 
33 #include "llvm/ADT/Twine.h"
34 
35 using namespace lldb;
36 using namespace lldb_private;
37 
Variable(lldb::user_id_t uid,const char * name,const char * mangled,const lldb::SymbolFileTypeSP & symfile_type_sp,ValueType scope,SymbolContextScope * context,const RangeList & scope_range,Declaration * decl_ptr,const DWARFExpression & location,bool external,bool artificial,bool location_is_constant_data,bool static_member)38 Variable::Variable(lldb::user_id_t uid, const char *name, const char *mangled,
39                    const lldb::SymbolFileTypeSP &symfile_type_sp,
40                    ValueType scope, SymbolContextScope *context,
41                    const RangeList &scope_range, Declaration *decl_ptr,
42                    const DWARFExpression &location, bool external,
43                    bool artificial, bool location_is_constant_data,
44                    bool static_member)
45     : UserID(uid), m_name(name), m_mangled(ConstString(mangled)),
46       m_symfile_type_sp(symfile_type_sp), m_scope(scope),
47       m_owner_scope(context), m_scope_range(scope_range),
48       m_declaration(decl_ptr), m_location(location), m_external(external),
49       m_artificial(artificial), m_loc_is_const_data(location_is_constant_data),
50       m_static_member(static_member) {}
51 
~Variable()52 Variable::~Variable() {}
53 
GetLanguage() const54 lldb::LanguageType Variable::GetLanguage() const {
55   lldb::LanguageType lang = m_mangled.GuessLanguage();
56   if (lang != lldb::eLanguageTypeUnknown)
57     return lang;
58 
59   if (auto *func = m_owner_scope->CalculateSymbolContextFunction()) {
60     if ((lang = func->GetLanguage()) != lldb::eLanguageTypeUnknown)
61       return lang;
62   } else if (auto *comp_unit =
63                  m_owner_scope->CalculateSymbolContextCompileUnit()) {
64     if ((lang = comp_unit->GetLanguage()) != lldb::eLanguageTypeUnknown)
65       return lang;
66   }
67 
68   return lldb::eLanguageTypeUnknown;
69 }
70 
GetName() const71 ConstString Variable::GetName() const {
72   ConstString name = m_mangled.GetName();
73   if (name)
74     return name;
75   return m_name;
76 }
77 
GetUnqualifiedName() const78 ConstString Variable::GetUnqualifiedName() const { return m_name; }
79 
NameMatches(ConstString name) const80 bool Variable::NameMatches(ConstString name) const {
81   if (m_name == name)
82     return true;
83   SymbolContext variable_sc;
84   m_owner_scope->CalculateSymbolContext(&variable_sc);
85 
86   return m_mangled.NameMatches(name);
87 }
NameMatches(const RegularExpression & regex) const88 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);
93   return false;
94 }
95 
GetType()96 Type *Variable::GetType() {
97   if (m_symfile_type_sp)
98     return m_symfile_type_sp->GetType();
99   return nullptr;
100 }
101 
Dump(Stream * s,bool show_context) const102 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->Format(", type = {{{0:x-16}} {1} (", type->GetID(), 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->AsRawOstream() << "??? (" << 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     ABISP abi;
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());
164     }
165     m_location.GetDescription(s, lldb::eDescriptionLevelBrief,
166                               loclist_base_addr, abi.get());
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 
DumpDeclaration(Stream * s,bool show_fullpaths,bool show_module)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 
MemorySize() const202 size_t Variable::MemorySize() const { return sizeof(Variable); }
203 
GetDeclContext()204 CompilerDeclContext Variable::GetDeclContext() {
205   Type *type = GetType();
206   if (type)
207     return type->GetSymbolFile()->GetDeclContextContainingUID(GetID());
208   return CompilerDeclContext();
209 }
210 
GetDecl()211 CompilerDecl Variable::GetDecl() {
212   Type *type = GetType();
213   return type ? type->GetSymbolFile()->GetDeclForUID(GetID()) : CompilerDecl();
214 }
215 
CalculateSymbolContext(SymbolContext * sc)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 
LocationIsValidForFrame(StackFrame * frame)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 list
243       // contains the current address when converted to a load address
244       return m_location.LocationListContainsAddress(
245           loclist_base_load_addr,
246           frame->GetFrameCodeAddress().GetLoadAddress(target_sp.get()));
247     }
248   }
249   return false;
250 }
251 
LocationIsValidForAddress(const Address & address)252 bool Variable::LocationIsValidForAddress(const Address &address) {
253   // Be sure to resolve the address to section offset prior to calling this
254   // function.
255   if (address.IsSectionOffset()) {
256     SymbolContext sc;
257     CalculateSymbolContext(&sc);
258     if (sc.module_sp == address.GetModule()) {
259       // Is the variable is described by a single location?
260       if (!m_location.IsLocationList()) {
261         // Yes it is, the location is valid.
262         return true;
263       }
264 
265       if (sc.function) {
266         addr_t loclist_base_file_addr =
267             sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
268         if (loclist_base_file_addr == LLDB_INVALID_ADDRESS)
269           return false;
270         // It is a location list. We just need to tell if the location list
271         // contains the current address when converted to a load address
272         return m_location.LocationListContainsAddress(loclist_base_file_addr,
273                                                       address.GetFileAddress());
274       }
275     }
276   }
277   return false;
278 }
279 
IsInScope(StackFrame * frame)280 bool Variable::IsInScope(StackFrame *frame) {
281   switch (m_scope) {
282   case eValueTypeRegister:
283   case eValueTypeRegisterSet:
284     return frame != nullptr;
285 
286   case eValueTypeConstResult:
287   case eValueTypeVariableGlobal:
288   case eValueTypeVariableStatic:
289   case eValueTypeVariableThreadLocal:
290     return true;
291 
292   case eValueTypeVariableArgument:
293   case eValueTypeVariableLocal:
294     if (frame) {
295       // We don't have a location list, we just need to see if the block that
296       // this variable was defined in is currently
297       Block *deepest_frame_block =
298           frame->GetSymbolContext(eSymbolContextBlock).block;
299       if (deepest_frame_block) {
300         SymbolContext variable_sc;
301         CalculateSymbolContext(&variable_sc);
302 
303         // Check for static or global variable defined at the compile unit
304         // level that wasn't defined in a block
305         if (variable_sc.block == nullptr)
306           return true;
307 
308         // Check if the variable is valid in the current block
309         if (variable_sc.block != deepest_frame_block &&
310             !variable_sc.block->Contains(deepest_frame_block))
311           return false;
312 
313         // If no scope range is specified then it means that the scope is the
314         // same as the scope of the enclosing lexical block.
315         if (m_scope_range.IsEmpty())
316           return true;
317 
318         addr_t file_address = frame->GetFrameCodeAddress().GetFileAddress();
319         return m_scope_range.FindEntryThatContains(file_address) != nullptr;
320       }
321     }
322     break;
323 
324   default:
325     break;
326   }
327   return false;
328 }
329 
GetValuesForVariableExpressionPath(llvm::StringRef variable_expr_path,ExecutionContextScope * scope,GetVariableCallback callback,void * baton,VariableList & variable_list,ValueObjectList & valobj_list)330 Status Variable::GetValuesForVariableExpressionPath(
331     llvm::StringRef variable_expr_path, ExecutionContextScope *scope,
332     GetVariableCallback callback, void *baton, VariableList &variable_list,
333     ValueObjectList &valobj_list) {
334   Status error;
335   if (!callback || variable_expr_path.empty()) {
336     error.SetErrorString("unknown error");
337     return error;
338   }
339 
340   switch (variable_expr_path.front()) {
341   case '*':
342     error = Variable::GetValuesForVariableExpressionPath(
343         variable_expr_path.drop_front(), scope, callback, baton, variable_list,
344         valobj_list);
345     if (error.Fail()) {
346       error.SetErrorString("unknown error");
347       return error;
348     }
349     for (uint32_t i = 0; i < valobj_list.GetSize();) {
350       Status tmp_error;
351       ValueObjectSP valobj_sp(
352           valobj_list.GetValueObjectAtIndex(i)->Dereference(tmp_error));
353       if (tmp_error.Fail()) {
354         variable_list.RemoveVariableAtIndex(i);
355         valobj_list.RemoveValueObjectAtIndex(i);
356       } else {
357         valobj_list.SetValueObjectAtIndex(i, valobj_sp);
358         ++i;
359       }
360     }
361     return error;
362   case '&': {
363     error = Variable::GetValuesForVariableExpressionPath(
364         variable_expr_path.drop_front(), scope, callback, baton, variable_list,
365         valobj_list);
366     if (error.Success()) {
367       for (uint32_t i = 0; i < valobj_list.GetSize();) {
368         Status tmp_error;
369         ValueObjectSP valobj_sp(
370             valobj_list.GetValueObjectAtIndex(i)->AddressOf(tmp_error));
371         if (tmp_error.Fail()) {
372           variable_list.RemoveVariableAtIndex(i);
373           valobj_list.RemoveValueObjectAtIndex(i);
374         } else {
375           valobj_list.SetValueObjectAtIndex(i, valobj_sp);
376           ++i;
377         }
378       }
379     } else {
380       error.SetErrorString("unknown error");
381     }
382     return error;
383   } break;
384 
385   default: {
386     static RegularExpression g_regex(
387         llvm::StringRef("^([A-Za-z_:][A-Za-z_0-9:]*)(.*)"));
388     llvm::SmallVector<llvm::StringRef, 2> matches;
389     variable_list.Clear();
390     if (!g_regex.Execute(variable_expr_path, &matches)) {
391       error.SetErrorStringWithFormat(
392           "unable to extract a variable name from '%s'",
393           variable_expr_path.str().c_str());
394       return error;
395     }
396     std::string variable_name = matches[1].str();
397     if (!callback(baton, variable_name.c_str(), variable_list)) {
398       error.SetErrorString("unknown error");
399       return error;
400     }
401     uint32_t i = 0;
402     while (i < variable_list.GetSize()) {
403       VariableSP var_sp(variable_list.GetVariableAtIndex(i));
404       ValueObjectSP valobj_sp;
405       if (!var_sp) {
406         variable_list.RemoveVariableAtIndex(i);
407         continue;
408       }
409       ValueObjectSP variable_valobj_sp(
410           ValueObjectVariable::Create(scope, var_sp));
411       if (!variable_valobj_sp) {
412         variable_list.RemoveVariableAtIndex(i);
413         continue;
414       }
415 
416       llvm::StringRef variable_sub_expr_path =
417           variable_expr_path.drop_front(variable_name.size());
418       if (!variable_sub_expr_path.empty()) {
419         valobj_sp = variable_valobj_sp->GetValueForExpressionPath(
420             variable_sub_expr_path);
421         if (!valobj_sp) {
422           error.SetErrorStringWithFormat(
423               "invalid expression path '%s' for variable '%s'",
424               variable_sub_expr_path.str().c_str(),
425               var_sp->GetName().GetCString());
426           variable_list.RemoveVariableAtIndex(i);
427           continue;
428         }
429       } else {
430         // Just the name of a variable with no extras
431         valobj_sp = variable_valobj_sp;
432       }
433 
434       valobj_list.Append(valobj_sp);
435       ++i;
436     }
437 
438     if (variable_list.GetSize() > 0) {
439       error.Clear();
440       return error;
441     }
442   } break;
443   }
444   error.SetErrorString("unknown error");
445   return error;
446 }
447 
DumpLocationForAddress(Stream * s,const Address & address)448 bool Variable::DumpLocationForAddress(Stream *s, const Address &address) {
449   // Be sure to resolve the address to section offset prior to calling this
450   // function.
451   if (address.IsSectionOffset()) {
452     SymbolContext sc;
453     CalculateSymbolContext(&sc);
454     if (sc.module_sp == address.GetModule()) {
455       ABISP abi;
456       if (m_owner_scope) {
457         ModuleSP module_sp(m_owner_scope->CalculateSymbolContextModule());
458         if (module_sp)
459           abi = ABI::FindPlugin(ProcessSP(), module_sp->GetArchitecture());
460       }
461 
462       const addr_t file_addr = address.GetFileAddress();
463       if (sc.function) {
464         if (sc.function->GetAddressRange().ContainsFileAddress(address)) {
465           addr_t loclist_base_file_addr =
466               sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
467           if (loclist_base_file_addr == LLDB_INVALID_ADDRESS)
468             return false;
469           return m_location.DumpLocationForAddress(s, eDescriptionLevelBrief,
470                                                    loclist_base_file_addr,
471                                                    file_addr, abi.get());
472         }
473       }
474       return m_location.DumpLocationForAddress(s, eDescriptionLevelBrief,
475                                                LLDB_INVALID_ADDRESS, file_addr,
476                                                abi.get());
477     }
478   }
479   return false;
480 }
481 
482 static void PrivateAutoComplete(
483     StackFrame *frame, llvm::StringRef partial_path,
484     const llvm::Twine
485         &prefix_path, // Anything that has been resolved already will be in here
486     const CompilerType &compiler_type, CompletionRequest &request);
487 
PrivateAutoCompleteMembers(StackFrame * frame,const std::string & partial_member_name,llvm::StringRef partial_path,const llvm::Twine & prefix_path,const CompilerType & compiler_type,CompletionRequest & request)488 static void PrivateAutoCompleteMembers(
489     StackFrame *frame, const std::string &partial_member_name,
490     llvm::StringRef partial_path,
491     const llvm::Twine
492         &prefix_path, // Anything that has been resolved already will be in here
493     const CompilerType &compiler_type, CompletionRequest &request) {
494 
495   // We are in a type parsing child members
496   const uint32_t num_bases = compiler_type.GetNumDirectBaseClasses();
497 
498   if (num_bases > 0) {
499     for (uint32_t i = 0; i < num_bases; ++i) {
500       CompilerType base_class_type =
501           compiler_type.GetDirectBaseClassAtIndex(i, nullptr);
502 
503       PrivateAutoCompleteMembers(frame, partial_member_name, partial_path,
504                                  prefix_path,
505                                  base_class_type.GetCanonicalType(), request);
506     }
507   }
508 
509   const uint32_t num_vbases = compiler_type.GetNumVirtualBaseClasses();
510 
511   if (num_vbases > 0) {
512     for (uint32_t i = 0; i < num_vbases; ++i) {
513       CompilerType vbase_class_type =
514           compiler_type.GetVirtualBaseClassAtIndex(i, nullptr);
515 
516       PrivateAutoCompleteMembers(frame, partial_member_name, partial_path,
517                                  prefix_path,
518                                  vbase_class_type.GetCanonicalType(), request);
519     }
520   }
521 
522   // We are in a type parsing child members
523   const uint32_t num_fields = compiler_type.GetNumFields();
524 
525   if (num_fields > 0) {
526     for (uint32_t i = 0; i < num_fields; ++i) {
527       std::string member_name;
528 
529       CompilerType member_compiler_type = compiler_type.GetFieldAtIndex(
530           i, member_name, nullptr, nullptr, nullptr);
531 
532       if (partial_member_name.empty() ||
533           llvm::StringRef(member_name).startswith(partial_member_name)) {
534         if (member_name == partial_member_name) {
535           PrivateAutoComplete(
536               frame, partial_path,
537               prefix_path + member_name, // Anything that has been resolved
538                                          // already will be in here
539               member_compiler_type.GetCanonicalType(), request);
540         } else {
541           request.AddCompletion((prefix_path + member_name).str());
542         }
543       }
544     }
545   }
546 }
547 
PrivateAutoComplete(StackFrame * frame,llvm::StringRef partial_path,const llvm::Twine & prefix_path,const CompilerType & compiler_type,CompletionRequest & request)548 static void PrivateAutoComplete(
549     StackFrame *frame, llvm::StringRef partial_path,
550     const llvm::Twine
551         &prefix_path, // Anything that has been resolved already will be in here
552     const CompilerType &compiler_type, CompletionRequest &request) {
553   //    printf ("\nPrivateAutoComplete()\n\tprefix_path = '%s'\n\tpartial_path =
554   //    '%s'\n", prefix_path.c_str(), partial_path.c_str());
555   std::string remaining_partial_path;
556 
557   const lldb::TypeClass type_class = compiler_type.GetTypeClass();
558   if (partial_path.empty()) {
559     if (compiler_type.IsValid()) {
560       switch (type_class) {
561       default:
562       case eTypeClassArray:
563       case eTypeClassBlockPointer:
564       case eTypeClassBuiltin:
565       case eTypeClassComplexFloat:
566       case eTypeClassComplexInteger:
567       case eTypeClassEnumeration:
568       case eTypeClassFunction:
569       case eTypeClassMemberPointer:
570       case eTypeClassReference:
571       case eTypeClassTypedef:
572       case eTypeClassVector: {
573         request.AddCompletion(prefix_path.str());
574       } break;
575 
576       case eTypeClassClass:
577       case eTypeClassStruct:
578       case eTypeClassUnion:
579         if (prefix_path.str().back() != '.')
580           request.AddCompletion((prefix_path + ".").str());
581         break;
582 
583       case eTypeClassObjCObject:
584       case eTypeClassObjCInterface:
585         break;
586       case eTypeClassObjCObjectPointer:
587       case eTypeClassPointer: {
588         bool omit_empty_base_classes = true;
589         if (compiler_type.GetNumChildren(omit_empty_base_classes, nullptr) > 0)
590           request.AddCompletion((prefix_path + "->").str());
591         else {
592           request.AddCompletion(prefix_path.str());
593         }
594       } break;
595       }
596     } else {
597       if (frame) {
598         const bool get_file_globals = true;
599 
600         VariableList *variable_list = frame->GetVariableList(get_file_globals);
601 
602         if (variable_list) {
603           for (const VariableSP &var_sp : *variable_list)
604             request.AddCompletion(var_sp->GetName().AsCString());
605         }
606       }
607     }
608   } else {
609     const char ch = partial_path[0];
610     switch (ch) {
611     case '*':
612       if (prefix_path.str().empty()) {
613         PrivateAutoComplete(frame, partial_path.substr(1), "*", compiler_type,
614                             request);
615       }
616       break;
617 
618     case '&':
619       if (prefix_path.isTriviallyEmpty()) {
620         PrivateAutoComplete(frame, partial_path.substr(1), std::string("&"),
621                             compiler_type, request);
622       }
623       break;
624 
625     case '-':
626       if (partial_path.size() > 1 && partial_path[1] == '>' &&
627           !prefix_path.str().empty()) {
628         switch (type_class) {
629         case lldb::eTypeClassPointer: {
630           CompilerType pointee_type(compiler_type.GetPointeeType());
631           if (partial_path.size() > 2 && partial_path[2]) {
632             // If there is more after the "->", then search deeper
633             PrivateAutoComplete(frame, partial_path.substr(2),
634                                 prefix_path + "->",
635                                 pointee_type.GetCanonicalType(), request);
636           } else {
637             // Nothing after the "->", so list all members
638             PrivateAutoCompleteMembers(
639                 frame, std::string(), std::string(), prefix_path + "->",
640                 pointee_type.GetCanonicalType(), request);
641           }
642         } break;
643         default:
644           break;
645         }
646       }
647       break;
648 
649     case '.':
650       if (compiler_type.IsValid()) {
651         switch (type_class) {
652         case lldb::eTypeClassUnion:
653         case lldb::eTypeClassStruct:
654         case lldb::eTypeClassClass:
655           if (partial_path.size() > 1 && partial_path[1]) {
656             // If there is more after the ".", then search deeper
657             PrivateAutoComplete(frame, partial_path.substr(1),
658                                 prefix_path + ".", compiler_type, request);
659 
660           } else {
661             // Nothing after the ".", so list all members
662             PrivateAutoCompleteMembers(frame, std::string(), partial_path,
663                                        prefix_path + ".", compiler_type,
664                                        request);
665           }
666           break;
667         default:
668           break;
669         }
670       }
671       break;
672     default:
673       if (isalpha(ch) || ch == '_' || ch == '$') {
674         const size_t partial_path_len = partial_path.size();
675         size_t pos = 1;
676         while (pos < partial_path_len) {
677           const char curr_ch = partial_path[pos];
678           if (isalnum(curr_ch) || curr_ch == '_' || curr_ch == '$') {
679             ++pos;
680             continue;
681           }
682           break;
683         }
684 
685         std::string token(std::string(partial_path), 0, pos);
686         remaining_partial_path = std::string(partial_path.substr(pos));
687 
688         if (compiler_type.IsValid()) {
689           PrivateAutoCompleteMembers(frame, token, remaining_partial_path,
690                                      prefix_path, compiler_type, request);
691         } else if (frame) {
692           // We haven't found our variable yet
693           const bool get_file_globals = true;
694 
695           VariableList *variable_list =
696               frame->GetVariableList(get_file_globals);
697 
698           if (!variable_list)
699             break;
700 
701           for (VariableSP var_sp : *variable_list) {
702 
703             if (!var_sp)
704               continue;
705 
706             llvm::StringRef variable_name = var_sp->GetName().GetStringRef();
707             if (variable_name.startswith(token)) {
708               if (variable_name == token) {
709                 Type *variable_type = var_sp->GetType();
710                 if (variable_type) {
711                   CompilerType variable_compiler_type(
712                       variable_type->GetForwardCompilerType());
713                   PrivateAutoComplete(
714                       frame, remaining_partial_path,
715                       prefix_path + token, // Anything that has been resolved
716                                            // already will be in here
717                       variable_compiler_type.GetCanonicalType(), request);
718                 } else {
719                   request.AddCompletion((prefix_path + variable_name).str());
720                 }
721               } else if (remaining_partial_path.empty()) {
722                 request.AddCompletion((prefix_path + variable_name).str());
723               }
724             }
725           }
726         }
727       }
728       break;
729     }
730   }
731 }
732 
AutoComplete(const ExecutionContext & exe_ctx,CompletionRequest & request)733 void Variable::AutoComplete(const ExecutionContext &exe_ctx,
734                             CompletionRequest &request) {
735   CompilerType compiler_type;
736 
737   PrivateAutoComplete(exe_ctx.GetFramePtr(), request.GetCursorArgumentPrefix(),
738                       "", compiler_type, request);
739 }
740