LLDB  mainline
Variable.cpp
Go to the documentation of this file.
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"
14 #include "lldb/Symbol/Block.h"
18 #include "lldb/Symbol/Function.h"
20 #include "lldb/Symbol/SymbolFile.h"
21 #include "lldb/Symbol/Type.h"
22 #include "lldb/Symbol/TypeSystem.h"
24 #include "lldb/Target/ABI.h"
25 #include "lldb/Target/Process.h"
27 #include "lldb/Target/StackFrame.h"
28 #include "lldb/Target/Target.h"
29 #include "lldb/Target/Thread.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 
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 DWARFExpressionList &location_list, 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_list(location_list), m_external(external),
49  m_artificial(artificial), m_loc_is_const_data(location_is_constant_data),
50  m_static_member(static_member) {}
51 
52 Variable::~Variable() = default;
53 
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 =
64  if ((lang = comp_unit->GetLanguage()) != lldb::eLanguageTypeUnknown)
65  return lang;
66  }
67 
69 }
70 
72  ConstString name = m_mangled.GetName();
73  if (name)
74  return name;
75  return m_name;
76 }
77 
79 
81  if (m_name == name)
82  return true;
83  SymbolContext variable_sc;
85 
86  return m_mangled.NameMatches(name);
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);
93  return false;
94 }
95 
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->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) {
123  s->PutCString(m_external ? "global" : "static");
124  break;
126  s->PutCString("parameter");
127  break;
129  s->PutCString("local");
130  break;
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 = ( ");
142  s->PutCString(" )");
143  }
144 
145  bool show_fullpaths = false;
146  m_declaration.Dump(s, show_fullpaths);
147 
148  if (m_location_list.IsValid()) {
149  s->PutCString(", location = ");
150  ABISP abi;
151  if (m_owner_scope) {
152  ModuleSP module_sp(m_owner_scope->CalculateSymbolContextModule());
153  if (module_sp)
154  abi = ABI::FindPlugin(ProcessSP(), module_sp->GetArchitecture());
155  }
157  }
158 
159  if (m_external)
160  s->PutCString(", external");
161 
162  if (m_artificial)
163  s->PutCString(", artificial");
164 
165  s->EOL();
166 }
167 
168 bool Variable::DumpDeclaration(Stream *s, bool show_fullpaths,
169  bool show_module) {
170  bool dumped_declaration_info = false;
171  if (m_owner_scope) {
172  SymbolContext sc;
174  sc.block = nullptr;
175  sc.line_entry.Clear();
176  bool show_inlined_frames = false;
177  const bool show_function_arguments = true;
178  const bool show_function_name = true;
179 
180  dumped_declaration_info = sc.DumpStopContext(
181  s, nullptr, Address(), show_fullpaths, show_module, show_inlined_frames,
182  show_function_arguments, show_function_name);
183 
184  if (sc.function)
185  s->PutChar(':');
186  }
187  if (m_declaration.DumpStopContext(s, false))
188  dumped_declaration_info = true;
189  return dumped_declaration_info;
190 }
191 
192 size_t Variable::MemorySize() const { return sizeof(Variable); }
193 
195  Type *type = GetType();
196  if (type)
198  return CompilerDeclContext();
199 }
200 
202  Type *type = GetType();
203  return type ? type->GetSymbolFile()->GetDeclForUID(GetID()) : CompilerDecl();
204 }
205 
207  if (m_owner_scope) {
209  sc->variable = this;
210  } else
211  sc->Clear(false);
212 }
213 
215  if (frame) {
216  Function *function =
217  frame->GetSymbolContext(eSymbolContextFunction).function;
218  if (function) {
219  TargetSP target_sp(frame->CalculateTarget());
220 
221  addr_t loclist_base_load_addr =
222  function->GetAddressRange().GetBaseAddress().GetLoadAddress(
223  target_sp.get());
224  if (loclist_base_load_addr == LLDB_INVALID_ADDRESS)
225  return false;
226  // It is a location list. We just need to tell if the location list
227  // contains the current address when converted to a load address
229  loclist_base_load_addr,
230  frame->GetFrameCodeAddress().GetLoadAddress(target_sp.get()));
231  }
232  }
233  return false;
234 }
235 
237  // Be sure to resolve the address to section offset prior to calling this
238  // function.
239  if (address.IsSectionOffset()) {
240  // We need to check if the address is valid for both scope range and value
241  // range.
242  // Empty scope range means block range.
243  bool valid_in_scope_range =
245  address.GetFileAddress()) != nullptr;
246  if (!valid_in_scope_range)
247  return false;
248  SymbolContext sc;
250  if (sc.module_sp == address.GetModule()) {
251  // Is the variable is described by a single location?
253  // Yes it is, the location is valid.
254  return true;
255  }
256 
257  if (sc.function) {
258  addr_t loclist_base_file_addr =
260  if (loclist_base_file_addr == LLDB_INVALID_ADDRESS)
261  return false;
262  // It is a location list. We just need to tell if the location list
263  // contains the current address when converted to a load address
264  return m_location_list.ContainsAddress(loclist_base_file_addr,
265  address.GetFileAddress());
266  }
267  }
268  }
269  return false;
270 }
271 
273  switch (m_scope) {
274  case eValueTypeRegister:
276  return frame != nullptr;
277 
282  return true;
283 
286  if (frame) {
287  // We don't have a location list, we just need to see if the block that
288  // this variable was defined in is currently
289  Block *deepest_frame_block =
290  frame->GetSymbolContext(eSymbolContextBlock).block;
291  if (deepest_frame_block) {
292  SymbolContext variable_sc;
293  CalculateSymbolContext(&variable_sc);
294 
295  // Check for static or global variable defined at the compile unit
296  // level that wasn't defined in a block
297  if (variable_sc.block == nullptr)
298  return true;
299 
300  // Check if the variable is valid in the current block
301  if (variable_sc.block != deepest_frame_block &&
302  !variable_sc.block->Contains(deepest_frame_block))
303  return false;
304 
305  // If no scope range is specified then it means that the scope is the
306  // same as the scope of the enclosing lexical block.
307  if (m_scope_range.IsEmpty())
308  return true;
309 
310  addr_t file_address = frame->GetFrameCodeAddress().GetFileAddress();
311  return m_scope_range.FindEntryThatContains(file_address) != nullptr;
312  }
313  }
314  break;
315 
316  default:
317  break;
318  }
319  return false;
320 }
321 
323  llvm::StringRef variable_expr_path, ExecutionContextScope *scope,
324  GetVariableCallback callback, void *baton, VariableList &variable_list,
325  ValueObjectList &valobj_list) {
326  Status error;
327  if (!callback || variable_expr_path.empty()) {
328  error.SetErrorString("unknown error");
329  return error;
330  }
331 
332  switch (variable_expr_path.front()) {
333  case '*':
335  variable_expr_path.drop_front(), scope, callback, baton, variable_list,
336  valobj_list);
337  if (error.Fail()) {
338  error.SetErrorString("unknown error");
339  return error;
340  }
341  for (uint32_t i = 0; i < valobj_list.GetSize();) {
342  Status tmp_error;
343  ValueObjectSP valobj_sp(
344  valobj_list.GetValueObjectAtIndex(i)->Dereference(tmp_error));
345  if (tmp_error.Fail()) {
346  variable_list.RemoveVariableAtIndex(i);
347  valobj_list.RemoveValueObjectAtIndex(i);
348  } else {
349  valobj_list.SetValueObjectAtIndex(i, valobj_sp);
350  ++i;
351  }
352  }
353  return error;
354  case '&': {
356  variable_expr_path.drop_front(), scope, callback, baton, variable_list,
357  valobj_list);
358  if (error.Success()) {
359  for (uint32_t i = 0; i < valobj_list.GetSize();) {
360  Status tmp_error;
361  ValueObjectSP valobj_sp(
362  valobj_list.GetValueObjectAtIndex(i)->AddressOf(tmp_error));
363  if (tmp_error.Fail()) {
364  variable_list.RemoveVariableAtIndex(i);
365  valobj_list.RemoveValueObjectAtIndex(i);
366  } else {
367  valobj_list.SetValueObjectAtIndex(i, valobj_sp);
368  ++i;
369  }
370  }
371  } else {
372  error.SetErrorString("unknown error");
373  }
374  return error;
375  } break;
376 
377  default: {
378  static RegularExpression g_regex(
379  llvm::StringRef("^([A-Za-z_:][A-Za-z_0-9:]*)(.*)"));
380  llvm::SmallVector<llvm::StringRef, 2> matches;
381  variable_list.Clear();
382  if (!g_regex.Execute(variable_expr_path, &matches)) {
383  error.SetErrorStringWithFormat(
384  "unable to extract a variable name from '%s'",
385  variable_expr_path.str().c_str());
386  return error;
387  }
388  std::string variable_name = matches[1].str();
389  if (!callback(baton, variable_name.c_str(), variable_list)) {
390  error.SetErrorString("unknown error");
391  return error;
392  }
393  uint32_t i = 0;
394  while (i < variable_list.GetSize()) {
395  VariableSP var_sp(variable_list.GetVariableAtIndex(i));
396  ValueObjectSP valobj_sp;
397  if (!var_sp) {
398  variable_list.RemoveVariableAtIndex(i);
399  continue;
400  }
401  ValueObjectSP variable_valobj_sp(
402  ValueObjectVariable::Create(scope, var_sp));
403  if (!variable_valobj_sp) {
404  variable_list.RemoveVariableAtIndex(i);
405  continue;
406  }
407 
408  llvm::StringRef variable_sub_expr_path =
409  variable_expr_path.drop_front(variable_name.size());
410  if (!variable_sub_expr_path.empty()) {
411  valobj_sp = variable_valobj_sp->GetValueForExpressionPath(
412  variable_sub_expr_path);
413  if (!valobj_sp) {
414  error.SetErrorStringWithFormat(
415  "invalid expression path '%s' for variable '%s'",
416  variable_sub_expr_path.str().c_str(),
417  var_sp->GetName().GetCString());
418  variable_list.RemoveVariableAtIndex(i);
419  continue;
420  }
421  } else {
422  // Just the name of a variable with no extras
423  valobj_sp = variable_valobj_sp;
424  }
425 
426  valobj_list.Append(valobj_sp);
427  ++i;
428  }
429 
430  if (variable_list.GetSize() > 0) {
431  error.Clear();
432  return error;
433  }
434  } break;
435  }
436  error.SetErrorString("unknown error");
437  return error;
438 }
439 
440 bool Variable::DumpLocations(Stream *s, const Address &address) {
441  SymbolContext sc;
443  ABISP abi;
444  if (m_owner_scope) {
445  ModuleSP module_sp(m_owner_scope->CalculateSymbolContextModule());
446  if (module_sp)
447  abi = ABI::FindPlugin(ProcessSP(), module_sp->GetArchitecture());
448  }
449 
450  const addr_t file_addr = address.GetFileAddress();
451  if (sc.function) {
452  addr_t loclist_base_file_addr =
454  if (loclist_base_file_addr == LLDB_INVALID_ADDRESS)
455  return false;
457  loclist_base_file_addr, file_addr,
458  abi.get());
459  }
460  return false;
461 }
462 
463 static void PrivateAutoComplete(
464  StackFrame *frame, llvm::StringRef partial_path,
465  const llvm::Twine
466  &prefix_path, // Anything that has been resolved already will be in here
467  const CompilerType &compiler_type, CompletionRequest &request);
468 
470  StackFrame *frame, const std::string &partial_member_name,
471  llvm::StringRef partial_path,
472  const llvm::Twine
473  &prefix_path, // Anything that has been resolved already will be in here
474  const CompilerType &compiler_type, CompletionRequest &request) {
475 
476  // We are in a type parsing child members
477  const uint32_t num_bases = compiler_type.GetNumDirectBaseClasses();
478 
479  if (num_bases > 0) {
480  for (uint32_t i = 0; i < num_bases; ++i) {
481  CompilerType base_class_type =
482  compiler_type.GetDirectBaseClassAtIndex(i, nullptr);
483 
484  PrivateAutoCompleteMembers(frame, partial_member_name, partial_path,
485  prefix_path,
486  base_class_type.GetCanonicalType(), request);
487  }
488  }
489 
490  const uint32_t num_vbases = compiler_type.GetNumVirtualBaseClasses();
491 
492  if (num_vbases > 0) {
493  for (uint32_t i = 0; i < num_vbases; ++i) {
494  CompilerType vbase_class_type =
495  compiler_type.GetVirtualBaseClassAtIndex(i, nullptr);
496 
497  PrivateAutoCompleteMembers(frame, partial_member_name, partial_path,
498  prefix_path,
499  vbase_class_type.GetCanonicalType(), request);
500  }
501  }
502 
503  // We are in a type parsing child members
504  const uint32_t num_fields = compiler_type.GetNumFields();
505 
506  if (num_fields > 0) {
507  for (uint32_t i = 0; i < num_fields; ++i) {
508  std::string member_name;
509 
510  CompilerType member_compiler_type = compiler_type.GetFieldAtIndex(
511  i, member_name, nullptr, nullptr, nullptr);
512 
513  if (partial_member_name.empty() ||
514  llvm::StringRef(member_name).startswith(partial_member_name)) {
515  if (member_name == partial_member_name) {
517  frame, partial_path,
518  prefix_path + member_name, // Anything that has been resolved
519  // already will be in here
520  member_compiler_type.GetCanonicalType(), request);
521  } else {
522  request.AddCompletion((prefix_path + member_name).str());
523  }
524  }
525  }
526  }
527 }
528 
530  StackFrame *frame, llvm::StringRef partial_path,
531  const llvm::Twine
532  &prefix_path, // Anything that has been resolved already will be in here
533  const CompilerType &compiler_type, CompletionRequest &request) {
534  // printf ("\nPrivateAutoComplete()\n\tprefix_path = '%s'\n\tpartial_path =
535  // '%s'\n", prefix_path.c_str(), partial_path.c_str());
536  std::string remaining_partial_path;
537 
538  const lldb::TypeClass type_class = compiler_type.GetTypeClass();
539  if (partial_path.empty()) {
540  if (compiler_type.IsValid()) {
541  switch (type_class) {
542  default:
543  case eTypeClassArray:
544  case eTypeClassBlockPointer:
545  case eTypeClassBuiltin:
546  case eTypeClassComplexFloat:
547  case eTypeClassComplexInteger:
548  case eTypeClassEnumeration:
549  case eTypeClassFunction:
550  case eTypeClassMemberPointer:
551  case eTypeClassReference:
552  case eTypeClassTypedef:
553  case eTypeClassVector: {
554  request.AddCompletion(prefix_path.str());
555  } break;
556 
557  case eTypeClassClass:
558  case eTypeClassStruct:
559  case eTypeClassUnion:
560  if (prefix_path.str().back() != '.')
561  request.AddCompletion((prefix_path + ".").str());
562  break;
563 
564  case eTypeClassObjCObject:
565  case eTypeClassObjCInterface:
566  break;
567  case eTypeClassObjCObjectPointer:
568  case eTypeClassPointer: {
569  bool omit_empty_base_classes = true;
570  if (compiler_type.GetNumChildren(omit_empty_base_classes, nullptr) > 0)
571  request.AddCompletion((prefix_path + "->").str());
572  else {
573  request.AddCompletion(prefix_path.str());
574  }
575  } break;
576  }
577  } else {
578  if (frame) {
579  const bool get_file_globals = true;
580 
581  VariableList *variable_list = frame->GetVariableList(get_file_globals,
582  nullptr);
583 
584  if (variable_list) {
585  for (const VariableSP &var_sp : *variable_list)
586  request.AddCompletion(var_sp->GetName().AsCString());
587  }
588  }
589  }
590  } else {
591  const char ch = partial_path[0];
592  switch (ch) {
593  case '*':
594  if (prefix_path.str().empty()) {
595  PrivateAutoComplete(frame, partial_path.substr(1), "*", compiler_type,
596  request);
597  }
598  break;
599 
600  case '&':
601  if (prefix_path.isTriviallyEmpty()) {
602  PrivateAutoComplete(frame, partial_path.substr(1), std::string("&"),
603  compiler_type, request);
604  }
605  break;
606 
607  case '-':
608  if (partial_path.size() > 1 && partial_path[1] == '>' &&
609  !prefix_path.str().empty()) {
610  switch (type_class) {
611  case lldb::eTypeClassPointer: {
612  CompilerType pointee_type(compiler_type.GetPointeeType());
613  if (partial_path.size() > 2 && partial_path[2]) {
614  // If there is more after the "->", then search deeper
615  PrivateAutoComplete(frame, partial_path.substr(2),
616  prefix_path + "->",
617  pointee_type.GetCanonicalType(), request);
618  } else {
619  // Nothing after the "->", so list all members
621  frame, std::string(), std::string(), prefix_path + "->",
622  pointee_type.GetCanonicalType(), request);
623  }
624  } break;
625  default:
626  break;
627  }
628  }
629  break;
630 
631  case '.':
632  if (compiler_type.IsValid()) {
633  switch (type_class) {
634  case lldb::eTypeClassUnion:
635  case lldb::eTypeClassStruct:
636  case lldb::eTypeClassClass:
637  if (partial_path.size() > 1 && partial_path[1]) {
638  // If there is more after the ".", then search deeper
639  PrivateAutoComplete(frame, partial_path.substr(1),
640  prefix_path + ".", compiler_type, request);
641 
642  } else {
643  // Nothing after the ".", so list all members
644  PrivateAutoCompleteMembers(frame, std::string(), partial_path,
645  prefix_path + ".", compiler_type,
646  request);
647  }
648  break;
649  default:
650  break;
651  }
652  }
653  break;
654  default:
655  if (isalpha(ch) || ch == '_' || ch == '$') {
656  const size_t partial_path_len = partial_path.size();
657  size_t pos = 1;
658  while (pos < partial_path_len) {
659  const char curr_ch = partial_path[pos];
660  if (isalnum(curr_ch) || curr_ch == '_' || curr_ch == '$') {
661  ++pos;
662  continue;
663  }
664  break;
665  }
666 
667  std::string token(std::string(partial_path), 0, pos);
668  remaining_partial_path = std::string(partial_path.substr(pos));
669 
670  if (compiler_type.IsValid()) {
671  PrivateAutoCompleteMembers(frame, token, remaining_partial_path,
672  prefix_path, compiler_type, request);
673  } else if (frame) {
674  // We haven't found our variable yet
675  const bool get_file_globals = true;
676 
677  VariableList *variable_list =
678  frame->GetVariableList(get_file_globals, nullptr);
679 
680  if (!variable_list)
681  break;
682 
683  for (VariableSP var_sp : *variable_list) {
684 
685  if (!var_sp)
686  continue;
687 
688  llvm::StringRef variable_name = var_sp->GetName().GetStringRef();
689  if (variable_name.startswith(token)) {
690  if (variable_name == token) {
691  Type *variable_type = var_sp->GetType();
692  if (variable_type) {
693  CompilerType variable_compiler_type(
694  variable_type->GetForwardCompilerType());
696  frame, remaining_partial_path,
697  prefix_path + token, // Anything that has been resolved
698  // already will be in here
699  variable_compiler_type.GetCanonicalType(), request);
700  } else {
701  request.AddCompletion((prefix_path + variable_name).str());
702  }
703  } else if (remaining_partial_path.empty()) {
704  request.AddCompletion((prefix_path + variable_name).str());
705  }
706  }
707  }
708  }
709  }
710  break;
711  }
712  }
713 }
714 
716  CompletionRequest &request) {
717  CompilerType compiler_type;
718 
720  "", compiler_type, request);
721 }
lldb_private::StackFrame::CalculateTarget
lldb::TargetSP CalculateTarget() override
Definition: StackFrame.cpp:1761
lldb_private::Variable::DumpDeclaration
bool DumpDeclaration(Stream *s, bool show_fullpaths, bool show_module)
Definition: Variable.cpp:168
RegularExpression.h
lldb_private::Variable::m_owner_scope
SymbolContextScope * m_owner_scope
The symbol file scope that this variable was defined in.
Definition: Variable.h:125
lldb_private::AddressRange::GetBaseAddress
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:209
Block.h
lldb_private::Stream::Format
void Format(const char *format, Args &&... args)
Definition: Stream.h:309
lldb_private::ValueObjectList
A collection of ValueObject values that.
Definition: ValueObjectList.h:23
lldb_private::SymbolContext::block
Block * block
The Block for a given query.
Definition: SymbolContext.h:321
lldb_private::SymbolFile::GetDeclForUID
virtual CompilerDecl GetDeclForUID(lldb::user_id_t uid)
Definition: SymbolFile.h:213
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
lldb_private::StackFrame::GetVariableList
VariableList * GetVariableList(bool get_file_globals, Status *error_ptr)
Retrieve the list of variables that are in scope at this StackFrame's pc.
Definition: StackFrame.cpp:424
lldb::eValueTypeVariableGlobal
@ eValueTypeVariableGlobal
globals variable
Definition: lldb-enumerations.h:318
lldb_private::RegularExpression
Definition: RegularExpression.h:18
CompilerDecl.h
lldb_private::Variable::m_scope
lldb::ValueType m_scope
Definition: Variable.h:123
CompileUnit.h
lldb_private::Function::GetAddressRange
const AddressRange & GetAddressRange()
Definition: Function.h:457
lldb_private::SymbolContextScope::CalculateSymbolContextModule
virtual lldb::ModuleSP CalculateSymbolContextModule()
Definition: SymbolContextScope.h:78
lldb_private::VariableList::Clear
void Clear()
Definition: VariableList.cpp:45
lldb_private::ValueObjectList::GetValueObjectAtIndex
lldb::ValueObjectSP GetValueObjectAtIndex(size_t idx)
Definition: ValueObjectList.cpp:39
lldb_private::CompilerType::GetNumVirtualBaseClasses
uint32_t GetNumVirtualBaseClasses() const
Definition: CompilerType.cpp:629
lldb_private::SymbolContextScope::CalculateSymbolContextFunction
virtual Function * CalculateSymbolContextFunction()
Definition: SymbolContextScope.h:84
lldb_private::StackFrame::GetFrameCodeAddress
const Address & GetFrameCodeAddress()
Get an Address for the current pc value in this StackFrame.
Definition: StackFrame.cpp:190
lldb_private::UserID
Definition: UserID.h:31
lldb_private::Variable::m_symfile_type_sp
lldb::SymbolFileTypeSP m_symfile_type_sp
The type pointer of the variable (int, struct, class, etc) global, parameter, local.
Definition: Variable.h:122
lldb_private::Variable::MemorySize
size_t MemorySize() const
Definition: Variable.cpp:192
Module.h
lldb_private::ValueObjectList::RemoveValueObjectAtIndex
lldb::ValueObjectSP RemoveValueObjectAtIndex(size_t idx)
Definition: ValueObjectList.cpp:46
lldb_private::DWARFExpressionList::IsAlwaysValidSingleExpr
bool IsAlwaysValidSingleExpr() const
Definition: DWARFExpressionList.cpp:20
lldb_private::VariableList::GetSize
size_t GetSize() const
Definition: VariableList.cpp:165
lldb_private::CompilerDecl
Represents a generic declaration such as a function declaration.
Definition: CompilerDecl.h:28
lldb_private::ExecutionContext::GetFramePtr
StackFrame * GetFramePtr() const
Returns a pointer to the frame object.
Definition: ExecutionContext.h:408
lldb_private::ConstString::AsCString
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:192
lldb_private::Variable::Variable
Variable(lldb::user_id_t uid, const char *name, const char *mangled, const lldb::SymbolFileTypeSP &symfile_type_sp, lldb::ValueType scope, SymbolContextScope *owner_scope, const RangeList &scope_range, Declaration *decl, const DWARFExpressionList &location, bool external, bool artificial, bool location_is_constant_data, bool static_member=false)
Constructors and Destructors.
Definition: Variable.cpp:38
StackFrame.h
lldb::eValueTypeRegisterSet
@ eValueTypeRegisterSet
A collection of stack frame register values.
Definition: lldb-enumerations.h:323
lldb_private::Variable::DumpLocations
bool DumpLocations(Stream *s, const Address &address)
Definition: Variable.cpp:440
lldb_private::CompilerType::GetTypeClass
lldb::TypeClass GetTypeClass() const
Definition: CompilerType.cpp:345
lldb_private::Stream
Definition: Stream.h:28
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::CompilerType::GetVirtualBaseClassAtIndex
CompilerType GetVirtualBaseClassAtIndex(size_t idx, uint32_t *bit_offset_ptr) const
Definition: CompilerType.cpp:647
lldb_private::Variable::GetName
ConstString GetName() const
Definition: Variable.cpp:71
lldb_private::SymbolContext
Definition: SymbolContext.h:33
lldb_private::CompilerType::GetNumDirectBaseClasses
uint32_t GetNumDirectBaseClasses() const
Definition: CompilerType.cpp:622
ABI.h
lldb_private::VariableList
Definition: VariableList.h:18
Process.h
lldb_private::VariableList::GetVariableAtIndex
lldb::VariableSP GetVariableAtIndex(size_t idx) const
Definition: VariableList.cpp:47
lldb_private::Variable::m_name
ConstString m_name
The basename of the variable (no namespaces).
Definition: Variable.h:117
Target.h
lldb_private::CompilerType::GetPointeeType
CompilerType GetPointeeType() const
If this type is a pointer type, return the type that the pointer points to, else return an invalid ty...
Definition: CompilerType.cpp:458
lldb_private::Declaration::Dump
void Dump(Stream *s, bool show_fullpaths) const
Dump a description of this object to a Stream.
Definition: Declaration.cpp:14
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::Function
Definition: Function.h:409
lldb_private::Variable::IsInScope
bool IsInScope(StackFrame *frame)
Definition: Variable.cpp:272
lldb_private::SymbolContext::DumpStopContext
bool DumpStopContext(Stream *s, ExecutionContextScope *exe_scope, const Address &so_addr, bool show_fullpaths, bool show_module, bool show_inlined_frames, bool show_function_arguments, bool show_function_name) const
Dump the stop context in this object to a Stream.
Definition: SymbolContext.cpp:68
lldb_private::Stream::Indent
size_t Indent(llvm::StringRef s="")
Indent the current line in the stream.
Definition: Stream.cpp:130
PrivateAutoComplete
static void PrivateAutoComplete(StackFrame *frame, llvm::StringRef partial_path, const llvm::Twine &prefix_path, const CompilerType &compiler_type, CompletionRequest &request)
Definition: Variable.cpp:529
lldb_private::ExecutionContextScope
Definition: ExecutionContextScope.h:32
lldb_private::SymbolContextScope::CalculateSymbolContextCompileUnit
virtual CompileUnit * CalculateSymbolContextCompileUnit()
Definition: SymbolContextScope.h:82
lldb_private::ValueObjectList::GetSize
size_t GetSize() const
Definition: ValueObjectList.cpp:35
lldb_private::Declaration::DumpStopContext
bool DumpStopContext(Stream *s, bool show_fullpaths) const
Definition: Declaration.cpp:35
lldb_private::ValueObjectList::SetValueObjectAtIndex
void SetValueObjectAtIndex(size_t idx, const lldb::ValueObjectSP &valobj_sp)
Definition: ValueObjectList.cpp:55
lldb_private::Status::Fail
bool Fail() const
Test for error condition.
Definition: Status.cpp:181
lldb_private::SymbolContextScope::CalculateSymbolContext
virtual void CalculateSymbolContext(SymbolContext *sc)=0
Reconstruct the object's symbol context into sc.
lldb_private::SymbolContext::function
Function * function
The Function for a given query.
Definition: SymbolContext.h:320
lldb_private::Address::GetFileAddress
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:291
Type.h
lldb_private::Variable::GetLanguage
lldb::LanguageType GetLanguage() const
Definition: Variable.cpp:54
lldb_private::ConstString
Definition: ConstString.h:39
lldb_private::Type::DumpTypeName
void DumpTypeName(Stream *s)
Definition: Type.cpp:312
lldb_private::Variable::GetValuesForVariableExpressionPath
static Status GetValuesForVariableExpressionPath(llvm::StringRef variable_expr_path, ExecutionContextScope *scope, GetVariableCallback callback, void *baton, VariableList &variable_list, ValueObjectList &valobj_list)
Definition: Variable.cpp:322
lldb_private::Type::GetSymbolFile
SymbolFile * GetSymbolFile()
Definition: Type.h:133
lldb_private::Variable::m_external
unsigned m_external
Visible outside the containing compile unit?
Definition: Variable.h:135
lldb_private::SymbolContext::variable
Variable * variable
The global variable matching the given query.
Definition: SymbolContext.h:324
lldb_private::Variable::m_scope_range
RangeList m_scope_range
The list of ranges inside the owner's scope where this variable is valid.
Definition: Variable.h:128
lldb_private::CompletionRequest::GetCursorArgumentPrefix
llvm::StringRef GetCursorArgumentPrefix() const
Definition: CompletionRequest.h:217
lldb::eValueTypeVariableArgument
@ eValueTypeVariableArgument
function argument variables
Definition: lldb-enumerations.h:320
lldb_private::CompilerType::GetNumFields
uint32_t GetNumFields() const
Definition: CompilerType.cpp:604
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
lldb_private::RangeVector::IsEmpty
bool IsEmpty() const
Definition: RangeMap.h:293
Thread.h
TypeSystem.h
lldb_private::Stream::PutChar
size_t PutChar(char ch)
Definition: Stream.cpp:104
lldb_private::Variable::NameMatches
bool NameMatches(ConstString name) const
Since a variable can have a basename "i" and also a mangled named "_ZN12_GLOBAL__N_11iE" and a demang...
Definition: Variable.cpp:80
lldb_private::Variable::m_location_list
DWARFExpressionList m_location_list
The location of this variable that can be fed to DWARFExpression::Evaluate().
Definition: Variable.h:133
lldb_private::DWARFExpressionList::IsValid
bool IsValid() const
Return true if the location expression contains data.
Definition: DWARFExpressionList.h:40
lldb_private::RangeVector< lldb::addr_t, lldb::addr_t >
lldb_private::Variable::GetDeclContext
CompilerDeclContext GetDeclContext()
Definition: Variable.cpp:194
VariableList.h
lldb_private::CompilerType::IsValid
bool IsValid() const
Definition: CompilerType.h:123
lldb_private::CompilerDeclContext
Represents a generic declaration context in a program.
Definition: CompilerDeclContext.h:30
ValueObject.h
lldb_private::SymbolContextScope
Definition: SymbolContextScope.h:64
lldb_private::UserID::GetID
lldb::user_id_t GetID() const
Get accessor for the user ID.
Definition: UserID.h:47
lldb_private::Variable::AutoComplete
static void AutoComplete(const ExecutionContext &exe_ctx, CompletionRequest &request)
Definition: Variable.cpp:715
lldb_private::CompilerType::GetNumChildren
uint32_t GetNumChildren(bool omit_empty_base_classes, const ExecutionContext *exe_ctx) const
Definition: CompilerType.cpp:579
lldb_private::Variable::GetDecl
CompilerDecl GetDecl()
Definition: Variable.cpp:201
lldb_private::DWARFExpressionList::GetDescription
void GetDescription(Stream *s, lldb::DescriptionLevel level, ABI *abi) const
Dump all locaitons with each seperated by new line.
Definition: DWARFExpressionList.cpp:176
lldb_private::VariableList::RemoveVariableAtIndex
lldb::VariableSP RemoveVariableAtIndex(size_t idx)
Definition: VariableList.cpp:54
lldb::eValueTypeVariableLocal
@ eValueTypeVariableLocal
function local variables
Definition: lldb-enumerations.h:321
lldb_private::Status
Definition: Status.h:44
lldb::ValueType
ValueType
Definition: lldb-enumerations.h:316
lldb_private::Block
Definition: Block.h:41
PrivateAutoCompleteMembers
static void PrivateAutoCompleteMembers(StackFrame *frame, const std::string &partial_member_name, llvm::StringRef partial_path, const llvm::Twine &prefix_path, const CompilerType &compiler_type, CompletionRequest &request)
Definition: Variable.cpp:469
uint32_t
lldb_private::Variable::GetScopeRange
const RangeList & GetScopeRange() const
Definition: Variable.h:68
lldb_private::Block::Contains
bool Contains(lldb::addr_t range_offset) const
Check if an offset is in one of the block offset ranges.
Definition: Block.cpp:180
lldb_private::CompilerType::GetDirectBaseClassAtIndex
CompilerType GetDirectBaseClassAtIndex(size_t idx, uint32_t *bit_offset_ptr) const
Definition: CompilerType.cpp:637
lldb_private::SymbolFile::GetDeclContextContainingUID
virtual CompilerDeclContext GetDeclContextContainingUID(lldb::user_id_t uid)
Definition: SymbolFile.h:219
lldb_private::Address
Definition: Address.h:59
lldb_private::Stream::EOL
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:128
lldb_private::CompilerType::GetCanonicalType
CompilerType GetCanonicalType() const
Definition: CompilerType.cpp:390
lldb_private::Type
Definition: Type.h:66
lldb_private::Address::GetLoadAddress
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:311
lldb_private::Type::GetForwardCompilerType
CompilerType GetForwardCompilerType()
Definition: Type.cpp:661
lldb_private::Stream::AsRawOstream
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
Definition: Stream.h:357
lldb_private::Variable::LocationIsValidForAddress
bool LocationIsValidForAddress(const Address &address)
Definition: Variable.cpp:236
lldb_private::SymbolContext::module_sp
lldb::ModuleSP module_sp
The Module for a given query.
Definition: SymbolContext.h:318
lldb_private::Variable::~Variable
virtual ~Variable()
lldb_private::Variable::CalculateSymbolContext
void CalculateSymbolContext(SymbolContext *sc)
Definition: Variable.cpp:206
lldb_private::ABI::FindPlugin
static lldb::ABISP FindPlugin(lldb::ProcessSP process_sp, const ArchSpec &arch)
Definition: ABI.cpp:27
LLDB_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:74
lldb_private::ValueObjectList::Append
void Append(const lldb::ValueObjectSP &val_obj_sp)
lldb_private::CompilerType
Generic representation of a type in a programming language.
Definition: CompilerType.h:35
Function.h
lldb_private::Stream::Printf
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
lldb_private::Variable::m_mangled
Mangled m_mangled
The mangled name of the variable.
Definition: Variable.h:119
lldb::user_id_t
uint64_t user_id_t
Definition: lldb-types.h:84
SymbolContext.h
lldb_private::LineEntry::Clear
void Clear()
Clear the object's state.
Definition: LineEntry.cpp:33
lldb_private::SymbolContext::Clear
void Clear(bool clear_target)
Clear the object's state.
Definition: SymbolContext.cpp:56
lldb::eValueTypeVariableThreadLocal
@ eValueTypeVariableThreadLocal
thread local storage variable
Definition: lldb-enumerations.h:325
CompilerDeclContext.h
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::DWARFExpressionList::ContainsAddress
bool ContainsAddress(lldb::addr_t func_load_addr, lldb::addr_t addr) const
Search for a load address in the dwarf location list.
Definition: DWARFExpressionList.cpp:50
lldb::eValueTypeInvalid
@ eValueTypeInvalid
Definition: lldb-enumerations.h:317
lldb::eValueTypeConstResult
@ eValueTypeConstResult
constant result variables
Definition: lldb-enumerations.h:324
lldb_private::DWARFExpressionList::DumpLocations
bool DumpLocations(Stream *s, lldb::DescriptionLevel level, lldb::addr_t func_load_addr, lldb::addr_t file_addr, ABI *abi) const
Dump locations that contains file_addr if it's valid.
Definition: DWARFExpressionList.cpp:142
lldb_private::RegularExpression::Execute
bool Execute(llvm::StringRef string, llvm::SmallVectorImpl< llvm::StringRef > *matches=nullptr) const
Execute a regular expression match using the compiled regular expression that is already in this obje...
Definition: RegularExpression.cpp:23
lldb_private::CompletionRequest::AddCompletion
void AddCompletion(llvm::StringRef completion, llvm::StringRef description="", CompletionMode mode=CompletionMode::Normal)
Adds a possible completion string.
Definition: CompletionRequest.h:167
lldb_private::Address::IsSectionOffset
bool IsSectionOffset() const
Check if an address is section offset.
Definition: Address.h:332
lldb_private::SymbolContextScope::DumpSymbolContext
virtual void DumpSymbolContext(Stream *s)=0
Dump the object's symbol context to the stream s.
lldb_private::Variable::GetType
Type * GetType()
Definition: Variable.cpp:96
lldb_private::RangeVector::FindEntryThatContains
const Entry * FindEntryThatContains(B addr) const
Definition: RangeMap.h:338
ValueObjectVariable.h
lldb_private::DWARFExpressionList
Definition: DWARFExpressionList.h:24
lldb_private::Address::GetModule
lldb::ModuleSP GetModule() const
Get accessor for the module for this address.
Definition: Address.cpp:283
Stream.h
lldb::eValueTypeRegister
@ eValueTypeRegister
stack frame register value
Definition: lldb-enumerations.h:322
lldb_private::CompilerType::GetFieldAtIndex
CompilerType GetFieldAtIndex(size_t idx, std::string &name, uint64_t *bit_offset_ptr, uint32_t *bitfield_bit_size_ptr, bool *is_bitfield_ptr) const
Definition: CompilerType.cpp:611
lldb::eValueTypeVariableStatic
@ eValueTypeVariableStatic
static variable
Definition: lldb-enumerations.h:319
lldb_private::Variable::LocationIsValidForFrame
bool LocationIsValidForFrame(StackFrame *frame)
Definition: Variable.cpp:214
lldb_private::Stream::PutCString
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:63
lldb_private::ValueObjectVariable::Create
static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope, const lldb::VariableSP &var_sp)
Definition: ValueObjectVariable.cpp:51
lldb_private::SymbolContext::line_entry
LineEntry line_entry
The LineEntry for a given query.
Definition: SymbolContext.h:322
Variable.h
lldb_private::Declaration
Definition: Declaration.h:24
lldb::eLanguageTypeUnknown
@ eLanguageTypeUnknown
Unknown or invalid language value.
Definition: lldb-enumerations.h:438
lldb_private::StackFrame
Definition: StackFrame.h:40
lldb_private::Variable::GetUnqualifiedName
ConstString GetUnqualifiedName() const
Definition: Variable.cpp:78
lldb_private::Variable::m_artificial
unsigned m_artificial
Non-zero if the variable is not explicitly declared in source.
Definition: Variable.h:137
lldb
Definition: SBAddress.h:15
RegisterContext.h
lldb_private::Variable::m_declaration
Declaration m_declaration
Declaration location for this item.
Definition: Variable.h:130
lldb_private::StackFrame::GetSymbolContext
const SymbolContext & GetSymbolContext(lldb::SymbolContextItem resolve_scope)
Provide a SymbolContext for this StackFrame's current pc value.
Definition: StackFrame.cpp:300
SymbolFile.h
lldb::eDescriptionLevelBrief
@ eDescriptionLevelBrief
Definition: lldb-enumerations.h:209
lldb_private::CompletionRequest
Definition: CompletionRequest.h:100
lldb::LanguageType
LanguageType
Programming language type.
Definition: lldb-enumerations.h:437
lldb_private::Variable::Dump
void Dump(Stream *s, bool show_context) const
Definition: Variable.cpp:102