LLDB  mainline
StackFrame.cpp
Go to the documentation of this file.
1 //===-- StackFrame.cpp ------------------------------------------*- C++ -*-===//
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 
10 #include "lldb/Core/Debugger.h"
11 #include "lldb/Core/Disassembler.h"
12 #include "lldb/Core/FormatEntity.h"
13 #include "lldb/Core/Mangled.h"
14 #include "lldb/Core/Module.h"
15 #include "lldb/Core/Value.h"
20 #include "lldb/Symbol/Function.h"
21 #include "lldb/Symbol/Symbol.h"
23 #include "lldb/Symbol/Type.h"
25 #include "lldb/Target/ABI.h"
27 #include "lldb/Target/Process.h"
30 #include "lldb/Target/Target.h"
31 #include "lldb/Target/Thread.h"
33 
34 #include "lldb/lldb-enumerations.h"
35 
36 #include <memory>
37 
38 using namespace lldb;
39 using namespace lldb_private;
40 
41 // The first bits in the flags are reserved for the SymbolContext::Scope bits
42 // so we know if we have tried to look up information in our internal symbol
43 // context (m_sc) already.
44 #define RESOLVED_FRAME_CODE_ADDR (uint32_t(eSymbolContextEverything + 1))
45 #define RESOLVED_FRAME_ID_SYMBOL_SCOPE (RESOLVED_FRAME_CODE_ADDR << 1)
46 #define GOT_FRAME_BASE (RESOLVED_FRAME_ID_SYMBOL_SCOPE << 1)
47 #define RESOLVED_VARIABLES (GOT_FRAME_BASE << 1)
48 #define RESOLVED_GLOBAL_VARIABLES (RESOLVED_VARIABLES << 1)
49 
50 StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
51  user_id_t unwind_frame_index, addr_t cfa,
52  bool cfa_is_valid, addr_t pc, StackFrame::Kind kind,
53  const SymbolContext *sc_ptr)
54  : m_thread_wp(thread_sp), m_frame_index(frame_idx),
55  m_concrete_frame_index(unwind_frame_index), m_reg_context_sp(),
56  m_id(pc, cfa, nullptr), m_frame_code_addr(pc), m_sc(), m_flags(),
57  m_frame_base(), m_frame_base_error(), m_cfa_is_valid(cfa_is_valid),
58  m_stack_frame_kind(kind), m_variable_list_sp(),
59  m_variable_list_value_objects(), m_recognized_frame_sp(), m_disassembly(),
60  m_mutex() {
61  // If we don't have a CFA value, use the frame index for our StackID so that
62  // recursive functions properly aren't confused with one another on a history
63  // stack.
64  if (IsHistorical() && !m_cfa_is_valid) {
65  m_id.SetCFA(m_frame_index);
66  }
67 
68  if (sc_ptr != nullptr) {
69  m_sc = *sc_ptr;
70  m_flags.Set(m_sc.GetResolvedMask());
71  }
72 }
73 
74 StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
75  user_id_t unwind_frame_index,
76  const RegisterContextSP &reg_context_sp, addr_t cfa,
77  addr_t pc, const SymbolContext *sc_ptr)
78  : m_thread_wp(thread_sp), m_frame_index(frame_idx),
79  m_concrete_frame_index(unwind_frame_index),
80  m_reg_context_sp(reg_context_sp), m_id(pc, cfa, nullptr),
81  m_frame_code_addr(pc), m_sc(), m_flags(), m_frame_base(),
82  m_frame_base_error(), m_cfa_is_valid(true),
83  m_stack_frame_kind(StackFrame::Kind::Regular), m_variable_list_sp(),
84  m_variable_list_value_objects(), m_recognized_frame_sp(), m_disassembly(),
85  m_mutex() {
86  if (sc_ptr != nullptr) {
87  m_sc = *sc_ptr;
88  m_flags.Set(m_sc.GetResolvedMask());
89  }
90 
91  if (reg_context_sp && !m_sc.target_sp) {
92  m_sc.target_sp = reg_context_sp->CalculateTarget();
93  if (m_sc.target_sp)
94  m_flags.Set(eSymbolContextTarget);
95  }
96 }
97 
98 StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx,
99  user_id_t unwind_frame_index,
100  const RegisterContextSP &reg_context_sp, addr_t cfa,
101  const Address &pc_addr, const SymbolContext *sc_ptr)
102  : m_thread_wp(thread_sp), m_frame_index(frame_idx),
103  m_concrete_frame_index(unwind_frame_index),
104  m_reg_context_sp(reg_context_sp),
105  m_id(pc_addr.GetLoadAddress(thread_sp->CalculateTarget().get()), cfa,
106  nullptr),
107  m_frame_code_addr(pc_addr), m_sc(), m_flags(), m_frame_base(),
108  m_frame_base_error(), m_cfa_is_valid(true),
109  m_stack_frame_kind(StackFrame::Kind::Regular), m_variable_list_sp(),
110  m_variable_list_value_objects(), m_recognized_frame_sp(), m_disassembly(),
111  m_mutex() {
112  if (sc_ptr != nullptr) {
113  m_sc = *sc_ptr;
114  m_flags.Set(m_sc.GetResolvedMask());
115  }
116 
117  if (!m_sc.target_sp && reg_context_sp) {
118  m_sc.target_sp = reg_context_sp->CalculateTarget();
119  if (m_sc.target_sp)
120  m_flags.Set(eSymbolContextTarget);
121  }
122 
123  ModuleSP pc_module_sp(pc_addr.GetModule());
124  if (!m_sc.module_sp || m_sc.module_sp != pc_module_sp) {
125  if (pc_module_sp) {
126  m_sc.module_sp = pc_module_sp;
127  m_flags.Set(eSymbolContextModule);
128  } else {
129  m_sc.module_sp.reset();
130  }
131  }
132 }
133 
134 StackFrame::~StackFrame() = default;
135 
136 StackID &StackFrame::GetStackID() {
137  std::lock_guard<std::recursive_mutex> guard(m_mutex);
138  // Make sure we have resolved the StackID object's symbol context scope if we
139  // already haven't looked it up.
140 
142  if (m_id.GetSymbolContextScope()) {
143  // We already have a symbol context scope, we just don't have our flag
144  // bit set.
146  } else {
147  // Calculate the frame block and use this for the stack ID symbol context
148  // scope if we have one.
150  if (scope == nullptr) {
151  // We don't have a block, so use the symbol
152  if (m_flags.IsClear(eSymbolContextSymbol))
153  GetSymbolContext(eSymbolContextSymbol);
154 
155  // It is ok if m_sc.symbol is nullptr here
156  scope = m_sc.symbol;
157  }
158  // Set the symbol context scope (the accessor will set the
159  // RESOLVED_FRAME_ID_SYMBOL_SCOPE bit in m_flags).
160  SetSymbolContextScope(scope);
161  }
162  }
163  return m_id;
164 }
165 
167  ThreadSP thread_sp = GetThread();
168  if (thread_sp)
169  return thread_sp->GetStackFrameList()->GetVisibleStackFrameIndex(
170  m_frame_index);
171  else
172  return m_frame_index;
173 }
174 
176  std::lock_guard<std::recursive_mutex> guard(m_mutex);
178  m_id.SetSymbolContextScope(symbol_scope);
179 }
180 
182  std::lock_guard<std::recursive_mutex> guard(m_mutex);
183  if (m_flags.IsClear(RESOLVED_FRAME_CODE_ADDR) &&
184  !m_frame_code_addr.IsSectionOffset()) {
185  m_flags.Set(RESOLVED_FRAME_CODE_ADDR);
186 
187  // Resolve the PC into a temporary address because if ResolveLoadAddress
188  // fails to resolve the address, it will clear the address object...
189  ThreadSP thread_sp(GetThread());
190  if (thread_sp) {
191  TargetSP target_sp(thread_sp->CalculateTarget());
192  if (target_sp) {
193  const bool allow_section_end = true;
194  if (m_frame_code_addr.SetOpcodeLoadAddress(
195  m_frame_code_addr.GetOffset(), target_sp.get(),
196  AddressClass::eCode, allow_section_end)) {
197  ModuleSP module_sp(m_frame_code_addr.GetModule());
198  if (module_sp) {
199  m_sc.module_sp = module_sp;
200  m_flags.Set(eSymbolContextModule);
201  }
202  }
203  }
204  }
205  }
206  return m_frame_code_addr;
207 }
208 
210  std::lock_guard<std::recursive_mutex> guard(m_mutex);
211  // We can't change the pc value of a history stack frame - it is immutable.
212  if (IsHistorical())
213  return false;
214  m_frame_code_addr.SetRawAddress(pc);
215  m_sc.Clear(false);
216  m_flags.Reset(0);
217  ThreadSP thread_sp(GetThread());
218  if (thread_sp)
219  thread_sp->ClearStackFrames();
220  return true;
221 }
222 
223 const char *StackFrame::Disassemble() {
224  std::lock_guard<std::recursive_mutex> guard(m_mutex);
225  if (m_disassembly.Empty()) {
226  ExecutionContext exe_ctx(shared_from_this());
227  Target *target = exe_ctx.GetTargetPtr();
228  if (target) {
229  const char *plugin_name = nullptr;
230  const char *flavor = nullptr;
232  target->GetArchitecture(), plugin_name, flavor,
233  exe_ctx, 0, false, 0, 0, m_disassembly);
234  }
235  if (m_disassembly.Empty())
236  return nullptr;
237  }
238 
239  return m_disassembly.GetData();
240 }
241 
243  if (m_sc.block == nullptr && m_flags.IsClear(eSymbolContextBlock))
244  GetSymbolContext(eSymbolContextBlock);
245 
246  if (m_sc.block) {
247  Block *inline_block = m_sc.block->GetContainingInlinedBlock();
248  if (inline_block) {
249  // Use the block with the inlined function info as the frame block we
250  // want this frame to have only the variables for the inlined function
251  // and its non-inlined block child blocks.
252  return inline_block;
253  } else {
254  // This block is not contained within any inlined function blocks with so
255  // we want to use the top most function block.
256  return &m_sc.function->GetBlock(false);
257  }
258  }
259  return nullptr;
260 }
261 
262 // Get the symbol context if we already haven't done so by resolving the
263 // PC address as much as possible. This way when we pass around a
264 // StackFrame object, everyone will have as much information as possible and no
265 // one will ever have to look things up manually.
266 const SymbolContext &
267 StackFrame::GetSymbolContext(SymbolContextItem resolve_scope) {
268  std::lock_guard<std::recursive_mutex> guard(m_mutex);
269  // Copy our internal symbol context into "sc".
270  if ((m_flags.Get() & resolve_scope) != resolve_scope) {
271  uint32_t resolved = 0;
272 
273  // If the target was requested add that:
274  if (!m_sc.target_sp) {
275  m_sc.target_sp = CalculateTarget();
276  if (m_sc.target_sp)
277  resolved |= eSymbolContextTarget;
278  }
279 
280  // Resolve our PC to section offset if we haven't already done so and if we
281  // don't have a module. The resolved address section will contain the
282  // module to which it belongs
283  if (!m_sc.module_sp && m_flags.IsClear(RESOLVED_FRAME_CODE_ADDR))
285 
286  // If this is not frame zero, then we need to subtract 1 from the PC value
287  // when doing address lookups since the PC will be on the instruction
288  // following the function call instruction...
289 
290  Address lookup_addr(GetFrameCodeAddress());
291  if (m_frame_index > 0 && lookup_addr.IsValid()) {
292  addr_t offset = lookup_addr.GetOffset();
293  if (offset > 0) {
294  lookup_addr.SetOffset(offset - 1);
295 
296  } else {
297  // lookup_addr is the start of a section. We need do the math on the
298  // actual load address and re-compute the section. We're working with
299  // a 'noreturn' function at the end of a section.
300  ThreadSP thread_sp(GetThread());
301  if (thread_sp) {
302  TargetSP target_sp(thread_sp->CalculateTarget());
303  if (target_sp) {
304  addr_t addr_minus_one =
305  lookup_addr.GetLoadAddress(target_sp.get()) - 1;
306  lookup_addr.SetLoadAddress(addr_minus_one, target_sp.get());
307  } else {
308  lookup_addr.SetOffset(offset - 1);
309  }
310  }
311  }
312  }
313 
314  if (m_sc.module_sp) {
315  // We have something in our stack frame symbol context, lets check if we
316  // haven't already tried to lookup one of those things. If we haven't
317  // then we will do the query.
318 
319  SymbolContextItem actual_resolve_scope = SymbolContextItem(0);
320 
321  if (resolve_scope & eSymbolContextCompUnit) {
322  if (m_flags.IsClear(eSymbolContextCompUnit)) {
323  if (m_sc.comp_unit)
324  resolved |= eSymbolContextCompUnit;
325  else
326  actual_resolve_scope |= eSymbolContextCompUnit;
327  }
328  }
329 
330  if (resolve_scope & eSymbolContextFunction) {
331  if (m_flags.IsClear(eSymbolContextFunction)) {
332  if (m_sc.function)
333  resolved |= eSymbolContextFunction;
334  else
335  actual_resolve_scope |= eSymbolContextFunction;
336  }
337  }
338 
339  if (resolve_scope & eSymbolContextBlock) {
340  if (m_flags.IsClear(eSymbolContextBlock)) {
341  if (m_sc.block)
342  resolved |= eSymbolContextBlock;
343  else
344  actual_resolve_scope |= eSymbolContextBlock;
345  }
346  }
347 
348  if (resolve_scope & eSymbolContextSymbol) {
349  if (m_flags.IsClear(eSymbolContextSymbol)) {
350  if (m_sc.symbol)
351  resolved |= eSymbolContextSymbol;
352  else
353  actual_resolve_scope |= eSymbolContextSymbol;
354  }
355  }
356 
357  if (resolve_scope & eSymbolContextLineEntry) {
358  if (m_flags.IsClear(eSymbolContextLineEntry)) {
359  if (m_sc.line_entry.IsValid())
360  resolved |= eSymbolContextLineEntry;
361  else
362  actual_resolve_scope |= eSymbolContextLineEntry;
363  }
364  }
365 
366  if (actual_resolve_scope) {
367  // We might be resolving less information than what is already in our
368  // current symbol context so resolve into a temporary symbol context
369  // "sc" so we don't clear out data we have already found in "m_sc"
370  SymbolContext sc;
371  // Set flags that indicate what we have tried to resolve
372  resolved |= m_sc.module_sp->ResolveSymbolContextForAddress(
373  lookup_addr, actual_resolve_scope, sc);
374  // Only replace what we didn't already have as we may have information
375  // for an inlined function scope that won't match what a standard
376  // lookup by address would match
377  if ((resolved & eSymbolContextCompUnit) && m_sc.comp_unit == nullptr)
378  m_sc.comp_unit = sc.comp_unit;
379  if ((resolved & eSymbolContextFunction) && m_sc.function == nullptr)
380  m_sc.function = sc.function;
381  if ((resolved & eSymbolContextBlock) && m_sc.block == nullptr)
382  m_sc.block = sc.block;
383  if ((resolved & eSymbolContextSymbol) && m_sc.symbol == nullptr)
384  m_sc.symbol = sc.symbol;
385  if ((resolved & eSymbolContextLineEntry) &&
386  !m_sc.line_entry.IsValid()) {
387  m_sc.line_entry = sc.line_entry;
389  }
390  }
391  } else {
392  // If we don't have a module, then we can't have the compile unit,
393  // function, block, line entry or symbol, so we can safely call
394  // ResolveSymbolContextForAddress with our symbol context member m_sc.
395  if (m_sc.target_sp) {
396  resolved |= m_sc.target_sp->GetImages().ResolveSymbolContextForAddress(
397  lookup_addr, resolve_scope, m_sc);
398  }
399  }
400 
401  // Update our internal flags so we remember what we have tried to locate so
402  // we don't have to keep trying when more calls to this function are made.
403  // We might have dug up more information that was requested (for example if
404  // we were asked to only get the block, we will have gotten the compile
405  // unit, and function) so set any additional bits that we resolved
406  m_flags.Set(resolve_scope | resolved);
407  }
408 
409  // Return the symbol context with everything that was possible to resolve
410  // resolved.
411  return m_sc;
412 }
413 
414 VariableList *StackFrame::GetVariableList(bool get_file_globals) {
415  std::lock_guard<std::recursive_mutex> guard(m_mutex);
416  if (m_flags.IsClear(RESOLVED_VARIABLES)) {
417  m_flags.Set(RESOLVED_VARIABLES);
418 
419  Block *frame_block = GetFrameBlock();
420 
421  if (frame_block) {
422  const bool get_child_variables = true;
423  const bool can_create = true;
424  const bool stop_if_child_block_is_inlined_function = true;
425  m_variable_list_sp = std::make_shared<VariableList>();
426  frame_block->AppendBlockVariables(can_create, get_child_variables,
427  stop_if_child_block_is_inlined_function,
428  [](Variable *v) { return true; },
429  m_variable_list_sp.get());
430  }
431  }
432 
433  if (m_flags.IsClear(RESOLVED_GLOBAL_VARIABLES) && get_file_globals) {
435 
436  if (m_flags.IsClear(eSymbolContextCompUnit))
437  GetSymbolContext(eSymbolContextCompUnit);
438 
439  if (m_sc.comp_unit) {
440  VariableListSP global_variable_list_sp(
441  m_sc.comp_unit->GetVariableList(true));
442  if (m_variable_list_sp)
443  m_variable_list_sp->AddVariables(global_variable_list_sp.get());
444  else
445  m_variable_list_sp = global_variable_list_sp;
446  }
447  }
448 
449  return m_variable_list_sp.get();
450 }
451 
452 VariableListSP
454  bool must_have_valid_location) {
455  std::lock_guard<std::recursive_mutex> guard(m_mutex);
456  // We can't fetch variable information for a history stack frame.
457  if (IsHistorical())
458  return VariableListSP();
459 
460  VariableListSP var_list_sp(new VariableList);
461  GetSymbolContext(eSymbolContextCompUnit | eSymbolContextBlock);
462 
463  if (m_sc.block) {
464  const bool can_create = true;
465  const bool get_parent_variables = true;
466  const bool stop_if_block_is_inlined_function = true;
467  m_sc.block->AppendVariables(
468  can_create, get_parent_variables, stop_if_block_is_inlined_function,
469  [this, must_have_valid_location](Variable *v) {
470  return v->IsInScope(this) && (!must_have_valid_location ||
471  v->LocationIsValidForFrame(this));
472  },
473  var_list_sp.get());
474  }
475 
476  if (m_sc.comp_unit && get_file_globals) {
477  VariableListSP global_variable_list_sp(
478  m_sc.comp_unit->GetVariableList(true));
479  if (global_variable_list_sp)
480  var_list_sp->AddVariables(global_variable_list_sp.get());
481  }
482 
483  return var_list_sp;
484 }
485 
487  llvm::StringRef var_expr, DynamicValueType use_dynamic, uint32_t options,
488  VariableSP &var_sp, Status &error) {
489  llvm::StringRef original_var_expr = var_expr;
490  // We can't fetch variable information for a history stack frame.
491  if (IsHistorical())
492  return ValueObjectSP();
493 
494  if (var_expr.empty()) {
495  error.SetErrorStringWithFormat("invalid variable path '%s'",
496  var_expr.str().c_str());
497  return ValueObjectSP();
498  }
499 
500  const bool check_ptr_vs_member =
501  (options & eExpressionPathOptionCheckPtrVsMember) != 0;
502  const bool no_fragile_ivar =
504  const bool no_synth_child =
506  // const bool no_synth_array = (options &
507  // eExpressionPathOptionsNoSyntheticArrayRange) != 0;
508  error.Clear();
509  bool deref = false;
510  bool address_of = false;
511  ValueObjectSP valobj_sp;
512  const bool get_file_globals = true;
513  // When looking up a variable for an expression, we need only consider the
514  // variables that are in scope.
515  VariableListSP var_list_sp(GetInScopeVariableList(get_file_globals));
516  VariableList *variable_list = var_list_sp.get();
517 
518  if (!variable_list)
519  return ValueObjectSP();
520 
521  // If first character is a '*', then show pointer contents
522  std::string var_expr_storage;
523  if (var_expr[0] == '*') {
524  deref = true;
525  var_expr = var_expr.drop_front(); // Skip the '*'
526  } else if (var_expr[0] == '&') {
527  address_of = true;
528  var_expr = var_expr.drop_front(); // Skip the '&'
529  }
530 
531  size_t separator_idx = var_expr.find_first_of(".-[=+~|&^%#@!/?,<>{}");
532  StreamString var_expr_path_strm;
533 
534  ConstString name_const_string(var_expr.substr(0, separator_idx));
535 
536  var_sp = variable_list->FindVariable(name_const_string, false);
537 
538  bool synthetically_added_instance_object = false;
539 
540  if (var_sp) {
541  var_expr = var_expr.drop_front(name_const_string.GetLength());
542  }
543 
544  if (!var_sp && (options & eExpressionPathOptionsAllowDirectIVarAccess)) {
545  // Check for direct ivars access which helps us with implicit access to
546  // ivars with the "this->" or "self->"
547  GetSymbolContext(eSymbolContextFunction | eSymbolContextBlock);
548  lldb::LanguageType method_language = eLanguageTypeUnknown;
549  bool is_instance_method = false;
550  ConstString method_object_name;
551  if (m_sc.GetFunctionMethodInfo(method_language, is_instance_method,
552  method_object_name)) {
553  if (is_instance_method && method_object_name) {
554  var_sp = variable_list->FindVariable(method_object_name);
555  if (var_sp) {
556  separator_idx = 0;
557  var_expr_storage = "->";
558  var_expr_storage += var_expr;
559  var_expr = var_expr_storage;
560  synthetically_added_instance_object = true;
561  }
562  }
563  }
564  }
565 
566  if (!var_sp && (options & eExpressionPathOptionsInspectAnonymousUnions)) {
567  // Check if any anonymous unions are there which contain a variable with
568  // the name we need
569  for (size_t i = 0; i < variable_list->GetSize(); i++) {
570  VariableSP variable_sp = variable_list->GetVariableAtIndex(i);
571  if (!variable_sp)
572  continue;
573  if (!variable_sp->GetName().IsEmpty())
574  continue;
575 
576  Type *var_type = variable_sp->GetType();
577  if (!var_type)
578  continue;
579 
580  if (!var_type->GetForwardCompilerType().IsAnonymousType())
581  continue;
582  valobj_sp = GetValueObjectForFrameVariable(variable_sp, use_dynamic);
583  if (!valobj_sp)
584  return valobj_sp;
585  valobj_sp = valobj_sp->GetChildMemberWithName(name_const_string, true);
586  if (valobj_sp)
587  break;
588  }
589  }
590 
591  if (var_sp && !valobj_sp) {
592  valobj_sp = GetValueObjectForFrameVariable(var_sp, use_dynamic);
593  if (!valobj_sp)
594  return valobj_sp;
595  }
596  if (!valobj_sp) {
597  error.SetErrorStringWithFormat("no variable named '%s' found in this frame",
598  name_const_string.GetCString());
599  return ValueObjectSP();
600  }
601 
602  // We are dumping at least one child
603  while (separator_idx != std::string::npos) {
604  // Calculate the next separator index ahead of time
605  ValueObjectSP child_valobj_sp;
606  const char separator_type = var_expr[0];
607  bool expr_is_ptr = false;
608  switch (separator_type) {
609  case '-':
610  expr_is_ptr = true;
611  if (var_expr.size() >= 2 && var_expr[1] != '>')
612  return ValueObjectSP();
613 
614  if (no_fragile_ivar) {
615  // Make sure we aren't trying to deref an objective
616  // C ivar if this is not allowed
617  const uint32_t pointer_type_flags =
618  valobj_sp->GetCompilerType().GetTypeInfo(nullptr);
619  if ((pointer_type_flags & eTypeIsObjC) &&
620  (pointer_type_flags & eTypeIsPointer)) {
621  // This was an objective C object pointer and it was requested we
622  // skip any fragile ivars so return nothing here
623  return ValueObjectSP();
624  }
625  }
626 
627  // If we have a non pointer type with a sythetic value then lets check if
628  // we have an sythetic dereference specified.
629  if (!valobj_sp->IsPointerType() && valobj_sp->HasSyntheticValue()) {
630  Status deref_error;
631  if (valobj_sp->GetCompilerType().IsReferenceType()) {
632  valobj_sp = valobj_sp->GetSyntheticValue()->Dereference(deref_error);
633  if (error.Fail()) {
635  "Failed to dereference reference type: %s", deref_error);
636  return ValueObjectSP();
637  }
638  }
639 
640  valobj_sp = valobj_sp->Dereference(deref_error);
641  if (error.Fail()) {
643  "Failed to dereference sythetic value: {0}", deref_error);
644  return ValueObjectSP();
645  }
646  // Some synthetic plug-ins fail to set the error in Dereference
647  if (!valobj_sp) {
648  error.SetErrorString("Failed to dereference sythetic value");
649  return ValueObjectSP();
650  }
651  expr_is_ptr = false;
652  }
653 
654  var_expr = var_expr.drop_front(); // Remove the '-'
655  LLVM_FALLTHROUGH;
656  case '.': {
657  var_expr = var_expr.drop_front(); // Remove the '.' or '>'
658  separator_idx = var_expr.find_first_of(".-[");
659  ConstString child_name(var_expr.substr(0, var_expr.find_first_of(".-[")));
660 
661  if (check_ptr_vs_member) {
662  // We either have a pointer type and need to verify valobj_sp is a
663  // pointer, or we have a member of a class/union/struct being accessed
664  // with the . syntax and need to verify we don't have a pointer.
665  const bool actual_is_ptr = valobj_sp->IsPointerType();
666 
667  if (actual_is_ptr != expr_is_ptr) {
668  // Incorrect use of "." with a pointer, or "->" with a
669  // class/union/struct instance or reference.
670  valobj_sp->GetExpressionPath(var_expr_path_strm, false);
671  if (actual_is_ptr)
673  "\"%s\" is a pointer and . was used to attempt to access "
674  "\"%s\". Did you mean \"%s->%s\"?",
675  var_expr_path_strm.GetData(), child_name.GetCString(),
676  var_expr_path_strm.GetData(), var_expr.str().c_str());
677  else
679  "\"%s\" is not a pointer and -> was used to attempt to "
680  "access \"%s\". Did you mean \"%s.%s\"?",
681  var_expr_path_strm.GetData(), child_name.GetCString(),
682  var_expr_path_strm.GetData(), var_expr.str().c_str());
683  return ValueObjectSP();
684  }
685  }
686  child_valobj_sp = valobj_sp->GetChildMemberWithName(child_name, true);
687  if (!child_valobj_sp) {
688  if (!no_synth_child) {
689  child_valobj_sp = valobj_sp->GetSyntheticValue();
690  if (child_valobj_sp)
691  child_valobj_sp =
692  child_valobj_sp->GetChildMemberWithName(child_name, true);
693  }
694 
695  if (no_synth_child || !child_valobj_sp) {
696  // No child member with name "child_name"
697  if (synthetically_added_instance_object) {
698  // We added a "this->" or "self->" to the beginning of the
699  // expression and this is the first pointer ivar access, so just
700  // return the normal error
702  "no variable or instance variable named '%s' found in "
703  "this frame",
704  name_const_string.GetCString());
705  } else {
706  valobj_sp->GetExpressionPath(var_expr_path_strm, false);
707  if (child_name) {
709  "\"%s\" is not a member of \"(%s) %s\"",
710  child_name.GetCString(),
711  valobj_sp->GetTypeName().AsCString("<invalid type>"),
712  var_expr_path_strm.GetData());
713  } else {
715  "incomplete expression path after \"%s\" in \"%s\"",
716  var_expr_path_strm.GetData(),
717  original_var_expr.str().c_str());
718  }
719  }
720  return ValueObjectSP();
721  }
722  }
723  synthetically_added_instance_object = false;
724  // Remove the child name from the path
725  var_expr = var_expr.drop_front(child_name.GetLength());
726  if (use_dynamic != eNoDynamicValues) {
727  ValueObjectSP dynamic_value_sp(
728  child_valobj_sp->GetDynamicValue(use_dynamic));
729  if (dynamic_value_sp)
730  child_valobj_sp = dynamic_value_sp;
731  }
732  } break;
733 
734  case '[': {
735  // Array member access, or treating pointer as an array Need at least two
736  // brackets and a number
737  if (var_expr.size() <= 2) {
739  "invalid square bracket encountered after \"%s\" in \"%s\"",
740  var_expr_path_strm.GetData(), var_expr.str().c_str());
741  return ValueObjectSP();
742  }
743 
744  // Drop the open brace.
745  var_expr = var_expr.drop_front();
746  long child_index = 0;
747 
748  // If there's no closing brace, this is an invalid expression.
749  size_t end_pos = var_expr.find_first_of(']');
750  if (end_pos == llvm::StringRef::npos) {
752  "missing closing square bracket in expression \"%s\"",
753  var_expr_path_strm.GetData());
754  return ValueObjectSP();
755  }
756  llvm::StringRef index_expr = var_expr.take_front(end_pos);
757  llvm::StringRef original_index_expr = index_expr;
758  // Drop all of "[index_expr]"
759  var_expr = var_expr.drop_front(end_pos + 1);
760 
761  if (index_expr.consumeInteger(0, child_index)) {
762  // If there was no integer anywhere in the index expression, this is
763  // erroneous expression.
764  error.SetErrorStringWithFormat("invalid index expression \"%s\"",
765  index_expr.str().c_str());
766  return ValueObjectSP();
767  }
768 
769  if (index_expr.empty()) {
770  // The entire index expression was a single integer.
771 
772  if (valobj_sp->GetCompilerType().IsPointerToScalarType() && deref) {
773  // what we have is *ptr[low]. the most similar C++ syntax is to deref
774  // ptr and extract bit low out of it. reading array item low would be
775  // done by saying ptr[low], without a deref * sign
776  Status error;
777  ValueObjectSP temp(valobj_sp->Dereference(error));
778  if (error.Fail()) {
779  valobj_sp->GetExpressionPath(var_expr_path_strm, false);
781  "could not dereference \"(%s) %s\"",
782  valobj_sp->GetTypeName().AsCString("<invalid type>"),
783  var_expr_path_strm.GetData());
784  return ValueObjectSP();
785  }
786  valobj_sp = temp;
787  deref = false;
788  } else if (valobj_sp->GetCompilerType().IsArrayOfScalarType() &&
789  deref) {
790  // what we have is *arr[low]. the most similar C++ syntax is to get
791  // arr[0] (an operation that is equivalent to deref-ing arr) and
792  // extract bit low out of it. reading array item low would be done by
793  // saying arr[low], without a deref * sign
794  Status error;
795  ValueObjectSP temp(valobj_sp->GetChildAtIndex(0, true));
796  if (error.Fail()) {
797  valobj_sp->GetExpressionPath(var_expr_path_strm, false);
799  "could not get item 0 for \"(%s) %s\"",
800  valobj_sp->GetTypeName().AsCString("<invalid type>"),
801  var_expr_path_strm.GetData());
802  return ValueObjectSP();
803  }
804  valobj_sp = temp;
805  deref = false;
806  }
807 
808  bool is_incomplete_array = false;
809  if (valobj_sp->IsPointerType()) {
810  bool is_objc_pointer = true;
811 
812  if (valobj_sp->GetCompilerType().GetMinimumLanguage() !=
814  is_objc_pointer = false;
815  else if (!valobj_sp->GetCompilerType().IsPointerType())
816  is_objc_pointer = false;
817 
818  if (no_synth_child && is_objc_pointer) {
820  "\"(%s) %s\" is an Objective-C pointer, and cannot be "
821  "subscripted",
822  valobj_sp->GetTypeName().AsCString("<invalid type>"),
823  var_expr_path_strm.GetData());
824 
825  return ValueObjectSP();
826  } else if (is_objc_pointer) {
827  // dereferencing ObjC variables is not valid.. so let's try and
828  // recur to synthetic children
829  ValueObjectSP synthetic = valobj_sp->GetSyntheticValue();
830  if (!synthetic /* no synthetic */
831  || synthetic == valobj_sp) /* synthetic is the same as
832  the original object */
833  {
834  valobj_sp->GetExpressionPath(var_expr_path_strm, false);
836  "\"(%s) %s\" is not an array type",
837  valobj_sp->GetTypeName().AsCString("<invalid type>"),
838  var_expr_path_strm.GetData());
839  } else if (
840  static_cast<uint32_t>(child_index) >=
841  synthetic
842  ->GetNumChildren() /* synthetic does not have that many values */) {
843  valobj_sp->GetExpressionPath(var_expr_path_strm, false);
845  "array index %ld is not valid for \"(%s) %s\"", child_index,
846  valobj_sp->GetTypeName().AsCString("<invalid type>"),
847  var_expr_path_strm.GetData());
848  } else {
849  child_valobj_sp = synthetic->GetChildAtIndex(child_index, true);
850  if (!child_valobj_sp) {
851  valobj_sp->GetExpressionPath(var_expr_path_strm, false);
853  "array index %ld is not valid for \"(%s) %s\"", child_index,
854  valobj_sp->GetTypeName().AsCString("<invalid type>"),
855  var_expr_path_strm.GetData());
856  }
857  }
858  } else {
859  child_valobj_sp =
860  valobj_sp->GetSyntheticArrayMember(child_index, true);
861  if (!child_valobj_sp) {
862  valobj_sp->GetExpressionPath(var_expr_path_strm, false);
864  "failed to use pointer as array for index %ld for "
865  "\"(%s) %s\"",
866  child_index,
867  valobj_sp->GetTypeName().AsCString("<invalid type>"),
868  var_expr_path_strm.GetData());
869  }
870  }
871  } else if (valobj_sp->GetCompilerType().IsArrayType(
872  nullptr, nullptr, &is_incomplete_array)) {
873  // Pass false to dynamic_value here so we can tell the difference
874  // between no dynamic value and no member of this type...
875  child_valobj_sp = valobj_sp->GetChildAtIndex(child_index, true);
876  if (!child_valobj_sp && (is_incomplete_array || !no_synth_child))
877  child_valobj_sp =
878  valobj_sp->GetSyntheticArrayMember(child_index, true);
879 
880  if (!child_valobj_sp) {
881  valobj_sp->GetExpressionPath(var_expr_path_strm, false);
883  "array index %ld is not valid for \"(%s) %s\"", child_index,
884  valobj_sp->GetTypeName().AsCString("<invalid type>"),
885  var_expr_path_strm.GetData());
886  }
887  } else if (valobj_sp->GetCompilerType().IsScalarType()) {
888  // this is a bitfield asking to display just one bit
889  child_valobj_sp = valobj_sp->GetSyntheticBitFieldChild(
890  child_index, child_index, true);
891  if (!child_valobj_sp) {
892  valobj_sp->GetExpressionPath(var_expr_path_strm, false);
894  "bitfield range %ld-%ld is not valid for \"(%s) %s\"",
895  child_index, child_index,
896  valobj_sp->GetTypeName().AsCString("<invalid type>"),
897  var_expr_path_strm.GetData());
898  }
899  } else {
900  ValueObjectSP synthetic = valobj_sp->GetSyntheticValue();
901  if (no_synth_child /* synthetic is forbidden */ ||
902  !synthetic /* no synthetic */
903  || synthetic == valobj_sp) /* synthetic is the same as the
904  original object */
905  {
906  valobj_sp->GetExpressionPath(var_expr_path_strm, false);
908  "\"(%s) %s\" is not an array type",
909  valobj_sp->GetTypeName().AsCString("<invalid type>"),
910  var_expr_path_strm.GetData());
911  } else if (
912  static_cast<uint32_t>(child_index) >=
913  synthetic
914  ->GetNumChildren() /* synthetic does not have that many values */) {
915  valobj_sp->GetExpressionPath(var_expr_path_strm, false);
917  "array index %ld is not valid for \"(%s) %s\"", child_index,
918  valobj_sp->GetTypeName().AsCString("<invalid type>"),
919  var_expr_path_strm.GetData());
920  } else {
921  child_valobj_sp = synthetic->GetChildAtIndex(child_index, true);
922  if (!child_valobj_sp) {
923  valobj_sp->GetExpressionPath(var_expr_path_strm, false);
925  "array index %ld is not valid for \"(%s) %s\"", child_index,
926  valobj_sp->GetTypeName().AsCString("<invalid type>"),
927  var_expr_path_strm.GetData());
928  }
929  }
930  }
931 
932  if (!child_valobj_sp) {
933  // Invalid array index...
934  return ValueObjectSP();
935  }
936 
937  separator_idx = var_expr.find_first_of(".-[");
938  if (use_dynamic != eNoDynamicValues) {
939  ValueObjectSP dynamic_value_sp(
940  child_valobj_sp->GetDynamicValue(use_dynamic));
941  if (dynamic_value_sp)
942  child_valobj_sp = dynamic_value_sp;
943  }
944  // Break out early from the switch since we were able to find the child
945  // member
946  break;
947  }
948 
949  // this is most probably a BitField, let's take a look
950  if (index_expr.front() != '-') {
951  error.SetErrorStringWithFormat("invalid range expression \"'%s'\"",
952  original_index_expr.str().c_str());
953  return ValueObjectSP();
954  }
955 
956  index_expr = index_expr.drop_front();
957  long final_index = 0;
958  if (index_expr.getAsInteger(0, final_index)) {
959  error.SetErrorStringWithFormat("invalid range expression \"'%s'\"",
960  original_index_expr.str().c_str());
961  return ValueObjectSP();
962  }
963 
964  // if the format given is [high-low], swap range
965  if (child_index > final_index) {
966  long temp = child_index;
967  child_index = final_index;
968  final_index = temp;
969  }
970 
971  if (valobj_sp->GetCompilerType().IsPointerToScalarType() && deref) {
972  // what we have is *ptr[low-high]. the most similar C++ syntax is to
973  // deref ptr and extract bits low thru high out of it. reading array
974  // items low thru high would be done by saying ptr[low-high], without a
975  // deref * sign
976  Status error;
977  ValueObjectSP temp(valobj_sp->Dereference(error));
978  if (error.Fail()) {
979  valobj_sp->GetExpressionPath(var_expr_path_strm, false);
981  "could not dereference \"(%s) %s\"",
982  valobj_sp->GetTypeName().AsCString("<invalid type>"),
983  var_expr_path_strm.GetData());
984  return ValueObjectSP();
985  }
986  valobj_sp = temp;
987  deref = false;
988  } else if (valobj_sp->GetCompilerType().IsArrayOfScalarType() && deref) {
989  // what we have is *arr[low-high]. the most similar C++ syntax is to
990  // get arr[0] (an operation that is equivalent to deref-ing arr) and
991  // extract bits low thru high out of it. reading array items low thru
992  // high would be done by saying arr[low-high], without a deref * sign
993  Status error;
994  ValueObjectSP temp(valobj_sp->GetChildAtIndex(0, true));
995  if (error.Fail()) {
996  valobj_sp->GetExpressionPath(var_expr_path_strm, false);
998  "could not get item 0 for \"(%s) %s\"",
999  valobj_sp->GetTypeName().AsCString("<invalid type>"),
1000  var_expr_path_strm.GetData());
1001  return ValueObjectSP();
1002  }
1003  valobj_sp = temp;
1004  deref = false;
1005  }
1006 
1007  child_valobj_sp =
1008  valobj_sp->GetSyntheticBitFieldChild(child_index, final_index, true);
1009  if (!child_valobj_sp) {
1010  valobj_sp->GetExpressionPath(var_expr_path_strm, false);
1012  "bitfield range %ld-%ld is not valid for \"(%s) %s\"", child_index,
1013  final_index, valobj_sp->GetTypeName().AsCString("<invalid type>"),
1014  var_expr_path_strm.GetData());
1015  }
1016 
1017  if (!child_valobj_sp) {
1018  // Invalid bitfield range...
1019  return ValueObjectSP();
1020  }
1021 
1022  separator_idx = var_expr.find_first_of(".-[");
1023  if (use_dynamic != eNoDynamicValues) {
1024  ValueObjectSP dynamic_value_sp(
1025  child_valobj_sp->GetDynamicValue(use_dynamic));
1026  if (dynamic_value_sp)
1027  child_valobj_sp = dynamic_value_sp;
1028  }
1029  // Break out early from the switch since we were able to find the child
1030  // member
1031  break;
1032  }
1033  default:
1034  // Failure...
1035  {
1036  valobj_sp->GetExpressionPath(var_expr_path_strm, false);
1038  "unexpected char '%c' encountered after \"%s\" in \"%s\"",
1039  separator_type, var_expr_path_strm.GetData(),
1040  var_expr.str().c_str());
1041 
1042  return ValueObjectSP();
1043  }
1044  }
1045 
1046  if (child_valobj_sp)
1047  valobj_sp = child_valobj_sp;
1048 
1049  if (var_expr.empty())
1050  break;
1051  }
1052  if (valobj_sp) {
1053  if (deref) {
1054  ValueObjectSP deref_valobj_sp(valobj_sp->Dereference(error));
1055  valobj_sp = deref_valobj_sp;
1056  } else if (address_of) {
1057  ValueObjectSP address_of_valobj_sp(valobj_sp->AddressOf(error));
1058  valobj_sp = address_of_valobj_sp;
1059  }
1060  }
1061  return valobj_sp;
1062 }
1063 
1064 bool StackFrame::GetFrameBaseValue(Scalar &frame_base, Status *error_ptr) {
1065  std::lock_guard<std::recursive_mutex> guard(m_mutex);
1066  if (!m_cfa_is_valid) {
1067  m_frame_base_error.SetErrorString(
1068  "No frame base available for this historical stack frame.");
1069  return false;
1070  }
1071 
1072  if (m_flags.IsClear(GOT_FRAME_BASE)) {
1073  if (m_sc.function) {
1074  m_frame_base.Clear();
1075  m_frame_base_error.Clear();
1076 
1077  m_flags.Set(GOT_FRAME_BASE);
1078  ExecutionContext exe_ctx(shared_from_this());
1079  Value expr_value;
1080  addr_t loclist_base_addr = LLDB_INVALID_ADDRESS;
1082  loclist_base_addr =
1084  exe_ctx.GetTargetPtr());
1085 
1087  &exe_ctx, nullptr, loclist_base_addr, nullptr, nullptr,
1088  expr_value, &m_frame_base_error)) {
1089  // We should really have an error if evaluate returns, but in case we
1090  // don't, lets set the error to something at least.
1091  if (m_frame_base_error.Success())
1092  m_frame_base_error.SetErrorString(
1093  "Evaluation of the frame base expression failed.");
1094  } else {
1095  m_frame_base = expr_value.ResolveValue(&exe_ctx);
1096  }
1097  } else {
1098  m_frame_base_error.SetErrorString("No function in symbol context.");
1099  }
1100  }
1101 
1102  if (m_frame_base_error.Success())
1103  frame_base = m_frame_base;
1104 
1105  if (error_ptr)
1106  *error_ptr = m_frame_base_error;
1107  return m_frame_base_error.Success();
1108 }
1109 
1111  if (!m_sc.function) {
1112  if (error_ptr) {
1113  error_ptr->SetErrorString("No function in symbol context.");
1114  }
1115  return nullptr;
1116  }
1117 
1118  return &m_sc.function->GetFrameBaseExpression();
1119 }
1120 
1121 RegisterContextSP StackFrame::GetRegisterContext() {
1122  std::lock_guard<std::recursive_mutex> guard(m_mutex);
1123  if (!m_reg_context_sp) {
1124  ThreadSP thread_sp(GetThread());
1125  if (thread_sp)
1126  m_reg_context_sp = thread_sp->CreateRegisterContextForFrame(this);
1127  }
1128  return m_reg_context_sp;
1129 }
1130 
1132  GetSymbolContext(eSymbolContextLineEntry);
1133  return m_sc.line_entry.IsValid();
1134 }
1135 
1136 ValueObjectSP
1137 StackFrame::GetValueObjectForFrameVariable(const VariableSP &variable_sp,
1138  DynamicValueType use_dynamic) {
1139  std::lock_guard<std::recursive_mutex> guard(m_mutex);
1140  ValueObjectSP valobj_sp;
1141  if (IsHistorical()) {
1142  return valobj_sp;
1143  }
1144  VariableList *var_list = GetVariableList(true);
1145  if (var_list) {
1146  // Make sure the variable is a frame variable
1147  const uint32_t var_idx = var_list->FindIndexForVariable(variable_sp.get());
1148  const uint32_t num_variables = var_list->GetSize();
1149  if (var_idx < num_variables) {
1150  valobj_sp = m_variable_list_value_objects.GetValueObjectAtIndex(var_idx);
1151  if (!valobj_sp) {
1152  if (m_variable_list_value_objects.GetSize() < num_variables)
1153  m_variable_list_value_objects.Resize(num_variables);
1154  valobj_sp = ValueObjectVariable::Create(this, variable_sp);
1155  m_variable_list_value_objects.SetValueObjectAtIndex(var_idx, valobj_sp);
1156  }
1157  }
1158  }
1159  if (use_dynamic != eNoDynamicValues && valobj_sp) {
1160  ValueObjectSP dynamic_sp = valobj_sp->GetDynamicValue(use_dynamic);
1161  if (dynamic_sp)
1162  return dynamic_sp;
1163  }
1164  return valobj_sp;
1165 }
1166 
1167 ValueObjectSP StackFrame::TrackGlobalVariable(const VariableSP &variable_sp,
1168  DynamicValueType use_dynamic) {
1169  std::lock_guard<std::recursive_mutex> guard(m_mutex);
1170  if (IsHistorical())
1171  return ValueObjectSP();
1172 
1173  // Check to make sure we aren't already tracking this variable?
1174  ValueObjectSP valobj_sp(
1175  GetValueObjectForFrameVariable(variable_sp, use_dynamic));
1176  if (!valobj_sp) {
1177  // We aren't already tracking this global
1178  VariableList *var_list = GetVariableList(true);
1179  // If this frame has no variables, create a new list
1180  if (var_list == nullptr)
1181  m_variable_list_sp = std::make_shared<VariableList>();
1182 
1183  // Add the global/static variable to this frame
1184  m_variable_list_sp->AddVariable(variable_sp);
1185 
1186  // Now make a value object for it so we can track its changes
1187  valobj_sp = GetValueObjectForFrameVariable(variable_sp, use_dynamic);
1188  }
1189  return valobj_sp;
1190 }
1191 
1193  if (m_sc.block == nullptr)
1194  GetSymbolContext(eSymbolContextBlock);
1195  if (m_sc.block)
1196  return m_sc.block->GetContainingInlinedBlock() != nullptr;
1197  return false;
1198 }
1199 
1201  return m_stack_frame_kind == StackFrame::Kind::History;
1202 }
1203 
1205  return m_stack_frame_kind == StackFrame::Kind::Artificial;
1206 }
1207 
1209  CompileUnit *cu = GetSymbolContext(eSymbolContextCompUnit).comp_unit;
1210  if (cu)
1211  return cu->GetLanguage();
1213 }
1214 
1216  LanguageType lang_type = GetLanguage();
1217 
1218  if (lang_type == eLanguageTypeUnknown) {
1219  SymbolContext sc = GetSymbolContext(eSymbolContextFunction
1220  | eSymbolContextSymbol);
1221  if (sc.function) {
1222  lang_type = sc.function->GetMangled().GuessLanguage();
1223  }
1224  else if (sc.symbol)
1225  {
1226  lang_type = sc.symbol->GetMangled().GuessLanguage();
1227  }
1228  }
1229 
1230  return lang_type;
1231 }
1232 
1233 namespace {
1234 std::pair<const Instruction::Operand *, int64_t>
1235 GetBaseExplainingValue(const Instruction::Operand &operand,
1236  RegisterContext &register_context, lldb::addr_t value) {
1237  switch (operand.m_type) {
1242  // These are not currently interesting
1243  return std::make_pair(nullptr, 0);
1245  const Instruction::Operand *immediate_child = nullptr;
1246  const Instruction::Operand *variable_child = nullptr;
1247  if (operand.m_children[0].m_type == Instruction::Operand::Type::Immediate) {
1248  immediate_child = &operand.m_children[0];
1249  variable_child = &operand.m_children[1];
1250  } else if (operand.m_children[1].m_type ==
1252  immediate_child = &operand.m_children[1];
1253  variable_child = &operand.m_children[0];
1254  }
1255  if (!immediate_child) {
1256  return std::make_pair(nullptr, 0);
1257  }
1258  lldb::addr_t adjusted_value = value;
1259  if (immediate_child->m_negative) {
1260  adjusted_value += immediate_child->m_immediate;
1261  } else {
1262  adjusted_value -= immediate_child->m_immediate;
1263  }
1264  std::pair<const Instruction::Operand *, int64_t> base_and_offset =
1265  GetBaseExplainingValue(*variable_child, register_context,
1266  adjusted_value);
1267  if (!base_and_offset.first) {
1268  return std::make_pair(nullptr, 0);
1269  }
1270  if (immediate_child->m_negative) {
1271  base_and_offset.second -= immediate_child->m_immediate;
1272  } else {
1273  base_and_offset.second += immediate_child->m_immediate;
1274  }
1275  return base_and_offset;
1276  }
1278  const RegisterInfo *info =
1279  register_context.GetRegisterInfoByName(operand.m_register.AsCString());
1280  if (!info) {
1281  return std::make_pair(nullptr, 0);
1282  }
1283  RegisterValue reg_value;
1284  if (!register_context.ReadRegister(info, reg_value)) {
1285  return std::make_pair(nullptr, 0);
1286  }
1287  if (reg_value.GetAsUInt64() == value) {
1288  return std::make_pair(&operand, 0);
1289  } else {
1290  return std::make_pair(nullptr, 0);
1291  }
1292  }
1293  }
1294  return std::make_pair(nullptr, 0);
1295 }
1296 
1297 std::pair<const Instruction::Operand *, int64_t>
1298 GetBaseExplainingDereference(const Instruction::Operand &operand,
1299  RegisterContext &register_context,
1300  lldb::addr_t addr) {
1302  return GetBaseExplainingValue(operand.m_children[0], register_context,
1303  addr);
1304  }
1305  return std::make_pair(nullptr, 0);
1306 }
1307 }
1308 
1310  TargetSP target_sp = CalculateTarget();
1311 
1312  const ArchSpec &target_arch = target_sp->GetArchitecture();
1313 
1314  AddressRange pc_range;
1315  pc_range.GetBaseAddress() = GetFrameCodeAddress();
1316  pc_range.SetByteSize(target_arch.GetMaximumOpcodeByteSize());
1317 
1318  ExecutionContext exe_ctx(shared_from_this());
1319 
1320  const char *plugin_name = nullptr;
1321  const char *flavor = nullptr;
1322  const bool prefer_file_cache = false;
1323 
1324  DisassemblerSP disassembler_sp = Disassembler::DisassembleRange(
1325  target_arch, plugin_name, flavor, exe_ctx, pc_range, prefer_file_cache);
1326 
1327  if (!disassembler_sp || !disassembler_sp->GetInstructionList().GetSize()) {
1328  return ValueObjectSP();
1329  }
1330 
1331  InstructionSP instruction_sp =
1332  disassembler_sp->GetInstructionList().GetInstructionAtIndex(0);
1333 
1334  llvm::SmallVector<Instruction::Operand, 3> operands;
1335 
1336  if (!instruction_sp->ParseOperands(operands)) {
1337  return ValueObjectSP();
1338  }
1339 
1340  RegisterContextSP register_context_sp = GetRegisterContext();
1341 
1342  if (!register_context_sp) {
1343  return ValueObjectSP();
1344  }
1345 
1346  for (const Instruction::Operand &operand : operands) {
1347  std::pair<const Instruction::Operand *, int64_t> base_and_offset =
1348  GetBaseExplainingDereference(operand, *register_context_sp, addr);
1349 
1350  if (!base_and_offset.first) {
1351  continue;
1352  }
1353 
1354  switch (base_and_offset.first->m_type) {
1356  lldb_private::Address addr;
1357  if (target_sp->ResolveLoadAddress(base_and_offset.first->m_immediate +
1358  base_and_offset.second,
1359  addr)) {
1360  TypeSystem *c_type_system =
1361  target_sp->GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC);
1362  if (!c_type_system) {
1363  return ValueObjectSP();
1364  } else {
1365  CompilerType void_ptr_type =
1366  c_type_system
1368  .GetPointerType();
1369  return ValueObjectMemory::Create(this, "", addr, void_ptr_type);
1370  }
1371  } else {
1372  return ValueObjectSP();
1373  }
1374  break;
1375  }
1377  return GuessValueForRegisterAndOffset(base_and_offset.first->m_register,
1378  base_and_offset.second);
1379  }
1380  default:
1381  return ValueObjectSP();
1382  }
1383  }
1384 
1385  return ValueObjectSP();
1386 }
1387 
1388 namespace {
1389 ValueObjectSP GetValueForOffset(StackFrame &frame, ValueObjectSP &parent,
1390  int64_t offset) {
1391  if (offset < 0 || uint64_t(offset) >= parent->GetByteSize()) {
1392  return ValueObjectSP();
1393  }
1394 
1395  if (parent->IsPointerOrReferenceType()) {
1396  return parent;
1397  }
1398 
1399  for (int ci = 0, ce = parent->GetNumChildren(); ci != ce; ++ci) {
1400  const bool can_create = true;
1401  ValueObjectSP child_sp = parent->GetChildAtIndex(ci, can_create);
1402 
1403  if (!child_sp) {
1404  return ValueObjectSP();
1405  }
1406 
1407  int64_t child_offset = child_sp->GetByteOffset();
1408  int64_t child_size = child_sp->GetByteSize();
1409 
1410  if (offset >= child_offset && offset < (child_offset + child_size)) {
1411  return GetValueForOffset(frame, child_sp, offset - child_offset);
1412  }
1413  }
1414 
1415  if (offset == 0) {
1416  return parent;
1417  } else {
1418  return ValueObjectSP();
1419  }
1420 }
1421 
1422 ValueObjectSP GetValueForDereferincingOffset(StackFrame &frame,
1423  ValueObjectSP &base,
1424  int64_t offset) {
1425  // base is a pointer to something
1426  // offset is the thing to add to the pointer We return the most sensible
1427  // ValueObject for the result of *(base+offset)
1428 
1429  if (!base->IsPointerOrReferenceType()) {
1430  return ValueObjectSP();
1431  }
1432 
1433  Status error;
1434  ValueObjectSP pointee = base->Dereference(error);
1435 
1436  if (!pointee) {
1437  return ValueObjectSP();
1438  }
1439 
1440  if (offset >= 0 && uint64_t(offset) >= pointee->GetByteSize()) {
1441  int64_t index = offset / pointee->GetByteSize();
1442  offset = offset % pointee->GetByteSize();
1443  const bool can_create = true;
1444  pointee = base->GetSyntheticArrayMember(index, can_create);
1445  }
1446 
1447  if (!pointee || error.Fail()) {
1448  return ValueObjectSP();
1449  }
1450 
1451  return GetValueForOffset(frame, pointee, offset);
1452 }
1453 
1454 /// Attempt to reconstruct the ValueObject for the address contained in a
1455 /// given register plus an offset.
1456 ///
1457 /// \params [in] frame
1458 /// The current stack frame.
1459 ///
1460 /// \params [in] reg
1461 /// The register.
1462 ///
1463 /// \params [in] offset
1464 /// The offset from the register.
1465 ///
1466 /// \param [in] disassembler
1467 /// A disassembler containing instructions valid up to the current PC.
1468 ///
1469 /// \param [in] variables
1470 /// The variable list from the current frame,
1471 ///
1472 /// \param [in] pc
1473 /// The program counter for the instruction considered the 'user'.
1474 ///
1475 /// \return
1476 /// A string describing the base for the ExpressionPath. This could be a
1477 /// variable, a register value, an argument, or a function return value.
1478 /// The ValueObject if found. If valid, it has a valid ExpressionPath.
1479 lldb::ValueObjectSP DoGuessValueAt(StackFrame &frame, ConstString reg,
1480  int64_t offset, Disassembler &disassembler,
1481  VariableList &variables, const Address &pc) {
1482  // Example of operation for Intel:
1483  //
1484  // +14: movq -0x8(%rbp), %rdi
1485  // +18: movq 0x8(%rdi), %rdi
1486  // +22: addl 0x4(%rdi), %eax
1487  //
1488  // f, a pointer to a struct, is known to be at -0x8(%rbp).
1489  //
1490  // DoGuessValueAt(frame, rdi, 4, dis, vars, 0x22) finds the instruction at
1491  // +18 that assigns to rdi, and calls itself recursively for that dereference
1492  // DoGuessValueAt(frame, rdi, 8, dis, vars, 0x18) finds the instruction at
1493  // +14 that assigns to rdi, and calls itself recursively for that
1494  // derefernece
1495  // DoGuessValueAt(frame, rbp, -8, dis, vars, 0x14) finds "f" in the
1496  // variable list.
1497  // Returns a ValueObject for f. (That's what was stored at rbp-8 at +14)
1498  // Returns a ValueObject for *(f+8) or f->b (That's what was stored at rdi+8
1499  // at +18)
1500  // Returns a ValueObject for *(f->b+4) or f->b->a (That's what was stored at
1501  // rdi+4 at +22)
1502 
1503  // First, check the variable list to see if anything is at the specified
1504  // location.
1505 
1506  using namespace OperandMatchers;
1507 
1508  const RegisterInfo *reg_info =
1509  frame.GetRegisterContext()->GetRegisterInfoByName(reg.AsCString());
1510  if (!reg_info) {
1511  return ValueObjectSP();
1512  }
1513 
1521 
1522  for (size_t vi = 0, ve = variables.GetSize(); vi != ve; ++vi) {
1523  VariableSP var_sp = variables.GetVariableAtIndex(vi);
1524  if (var_sp->LocationExpression().MatchesOperand(frame, op)) {
1525  return frame.GetValueObjectForFrameVariable(var_sp, eNoDynamicValues);
1526  }
1527  }
1528 
1529  const uint32_t current_inst =
1531  if (current_inst == UINT32_MAX) {
1532  return ValueObjectSP();
1533  }
1534 
1535  for (uint32_t ii = current_inst - 1; ii != (uint32_t)-1; --ii) {
1536  // This is not an exact algorithm, and it sacrifices accuracy for
1537  // generality. Recognizing "mov" and "ld" instructions –– and which
1538  // are their source and destination operands -- is something the
1539  // disassembler should do for us.
1540  InstructionSP instruction_sp =
1541  disassembler.GetInstructionList().GetInstructionAtIndex(ii);
1542 
1543  if (instruction_sp->IsCall()) {
1544  ABISP abi_sp = frame.CalculateProcess()->GetABI();
1545  if (!abi_sp) {
1546  continue;
1547  }
1548 
1549  const char *return_register_name;
1550  if (!abi_sp->GetPointerReturnRegister(return_register_name)) {
1551  continue;
1552  }
1553 
1554  const RegisterInfo *return_register_info =
1555  frame.GetRegisterContext()->GetRegisterInfoByName(
1556  return_register_name);
1557  if (!return_register_info) {
1558  continue;
1559  }
1560 
1561  int64_t offset = 0;
1562 
1564  MatchRegOp(*return_register_info))(op) &&
1565  !MatchUnaryOp(
1568  MatchRegOp(*return_register_info),
1569  FetchImmOp(offset)))(op)) {
1570  continue;
1571  }
1572 
1573  llvm::SmallVector<Instruction::Operand, 1> operands;
1574  if (!instruction_sp->ParseOperands(operands) || operands.size() != 1) {
1575  continue;
1576  }
1577 
1578  switch (operands[0].m_type) {
1579  default:
1580  break;
1582  SymbolContext sc;
1583  Address load_address;
1584  if (!frame.CalculateTarget()->ResolveLoadAddress(
1585  operands[0].m_immediate, load_address)) {
1586  break;
1587  }
1588  frame.CalculateTarget()->GetImages().ResolveSymbolContextForAddress(
1589  load_address, eSymbolContextFunction, sc);
1590  if (!sc.function) {
1591  break;
1592  }
1593  CompilerType function_type = sc.function->GetCompilerType();
1594  if (!function_type.IsFunctionType()) {
1595  break;
1596  }
1597  CompilerType return_type = function_type.GetFunctionReturnType();
1598  RegisterValue return_value;
1599  if (!frame.GetRegisterContext()->ReadRegister(return_register_info,
1600  return_value)) {
1601  break;
1602  }
1603  std::string name_str(
1604  sc.function->GetName().AsCString("<unknown function>"));
1605  name_str.append("()");
1606  Address return_value_address(return_value.GetAsUInt64());
1607  ValueObjectSP return_value_sp = ValueObjectMemory::Create(
1608  &frame, name_str, return_value_address, return_type);
1609  return GetValueForDereferincingOffset(frame, return_value_sp, offset);
1610  }
1611  }
1612 
1613  continue;
1614  }
1615 
1616  llvm::SmallVector<Instruction::Operand, 2> operands;
1617  if (!instruction_sp->ParseOperands(operands) || operands.size() != 2) {
1618  continue;
1619  }
1620 
1621  Instruction::Operand *origin_operand = nullptr;
1622  auto clobbered_reg_matcher = [reg_info](const Instruction::Operand &op) {
1623  return MatchRegOp(*reg_info)(op) && op.m_clobbered;
1624  };
1625 
1626  if (clobbered_reg_matcher(operands[0])) {
1627  origin_operand = &operands[1];
1628  }
1629  else if (clobbered_reg_matcher(operands[1])) {
1630  origin_operand = &operands[0];
1631  }
1632  else {
1633  continue;
1634  }
1635 
1636  // We have an origin operand. Can we track its value down?
1637  ValueObjectSP source_path;
1638  ConstString origin_register;
1639  int64_t origin_offset = 0;
1640 
1641  if (FetchRegOp(origin_register)(*origin_operand)) {
1642  source_path = DoGuessValueAt(frame, origin_register, 0, disassembler,
1643  variables, instruction_sp->GetAddress());
1644  } else if (MatchUnaryOp(
1646  FetchRegOp(origin_register))(*origin_operand) ||
1647  MatchUnaryOp(
1650  FetchRegOp(origin_register),
1651  FetchImmOp(origin_offset)))(*origin_operand)) {
1652  source_path =
1653  DoGuessValueAt(frame, origin_register, origin_offset, disassembler,
1654  variables, instruction_sp->GetAddress());
1655  if (!source_path) {
1656  continue;
1657  }
1658  source_path =
1659  GetValueForDereferincingOffset(frame, source_path, offset);
1660  }
1661 
1662  if (source_path) {
1663  return source_path;
1664  }
1665  }
1666 
1667  return ValueObjectSP();
1668 }
1669 }
1670 
1672  int64_t offset) {
1673  TargetSP target_sp = CalculateTarget();
1674 
1675  const ArchSpec &target_arch = target_sp->GetArchitecture();
1676 
1677  Block *frame_block = GetFrameBlock();
1678 
1679  if (!frame_block) {
1680  return ValueObjectSP();
1681  }
1682 
1683  Function *function = frame_block->CalculateSymbolContextFunction();
1684  if (!function) {
1685  return ValueObjectSP();
1686  }
1687 
1688  AddressRange pc_range = function->GetAddressRange();
1689 
1690  if (GetFrameCodeAddress().GetFileAddress() <
1691  pc_range.GetBaseAddress().GetFileAddress() ||
1693  pc_range.GetBaseAddress().GetFileAddress() >=
1694  pc_range.GetByteSize()) {
1695  return ValueObjectSP();
1696  }
1697 
1698  ExecutionContext exe_ctx(shared_from_this());
1699 
1700  const char *plugin_name = nullptr;
1701  const char *flavor = nullptr;
1702  const bool prefer_file_cache = false;
1703  DisassemblerSP disassembler_sp = Disassembler::DisassembleRange(
1704  target_arch, plugin_name, flavor, exe_ctx, pc_range, prefer_file_cache);
1705 
1706  if (!disassembler_sp || !disassembler_sp->GetInstructionList().GetSize()) {
1707  return ValueObjectSP();
1708  }
1709 
1710  const bool get_file_globals = false;
1711  VariableList *variables = GetVariableList(get_file_globals);
1712 
1713  if (!variables) {
1714  return ValueObjectSP();
1715  }
1716 
1717  return DoGuessValueAt(*this, reg, offset, *disassembler_sp, *variables,
1719 }
1720 
1721 lldb::ValueObjectSP StackFrame::FindVariable(ConstString name) {
1722  ValueObjectSP value_sp;
1723 
1724  if (!name)
1725  return value_sp;
1726 
1727  TargetSP target_sp = CalculateTarget();
1728  ProcessSP process_sp = CalculateProcess();
1729 
1730  if (!target_sp && !process_sp)
1731  return value_sp;
1732 
1733  VariableList variable_list;
1734  VariableSP var_sp;
1735  SymbolContext sc(GetSymbolContext(eSymbolContextBlock));
1736 
1737  if (sc.block) {
1738  const bool can_create = true;
1739  const bool get_parent_variables = true;
1740  const bool stop_if_block_is_inlined_function = true;
1741 
1742  if (sc.block->AppendVariables(
1743  can_create, get_parent_variables, stop_if_block_is_inlined_function,
1744  [this](Variable *v) { return v->IsInScope(this); },
1745  &variable_list)) {
1746  var_sp = variable_list.FindVariable(name);
1747  }
1748 
1749  if (var_sp)
1751  }
1752 
1753  return value_sp;
1754 }
1755 
1757  TargetSP target_sp;
1758  ThreadSP thread_sp(GetThread());
1759  if (thread_sp) {
1760  ProcessSP process_sp(thread_sp->CalculateProcess());
1761  if (process_sp)
1762  target_sp = process_sp->CalculateTarget();
1763  }
1764  return target_sp;
1765 }
1766 
1768  ProcessSP process_sp;
1769  ThreadSP thread_sp(GetThread());
1770  if (thread_sp)
1771  process_sp = thread_sp->CalculateProcess();
1772  return process_sp;
1773 }
1774 
1775 ThreadSP StackFrame::CalculateThread() { return GetThread(); }
1776 
1777 StackFrameSP StackFrame::CalculateStackFrame() { return shared_from_this(); }
1778 
1780  exe_ctx.SetContext(shared_from_this());
1781 }
1782 
1783 void StackFrame::DumpUsingSettingsFormat(Stream *strm, bool show_unique,
1784  const char *frame_marker) {
1785  if (strm == nullptr)
1786  return;
1787 
1788  GetSymbolContext(eSymbolContextEverything);
1789  ExecutionContext exe_ctx(shared_from_this());
1790  StreamString s;
1791 
1792  if (frame_marker)
1793  s.PutCString(frame_marker);
1794 
1795  const FormatEntity::Entry *frame_format = nullptr;
1796  Target *target = exe_ctx.GetTargetPtr();
1797  if (target) {
1798  if (show_unique) {
1799  frame_format = target->GetDebugger().GetFrameFormatUnique();
1800  } else {
1801  frame_format = target->GetDebugger().GetFrameFormat();
1802  }
1803  }
1804  if (frame_format && FormatEntity::Format(*frame_format, s, &m_sc, &exe_ctx,
1805  nullptr, nullptr, false, false)) {
1806  strm->PutCString(s.GetString());
1807  } else {
1808  Dump(strm, true, false);
1809  strm->EOL();
1810  }
1811 }
1812 
1813 void StackFrame::Dump(Stream *strm, bool show_frame_index,
1814  bool show_fullpaths) {
1815  if (strm == nullptr)
1816  return;
1817 
1818  if (show_frame_index)
1819  strm->Printf("frame #%u: ", m_frame_index);
1820  ExecutionContext exe_ctx(shared_from_this());
1821  Target *target = exe_ctx.GetTargetPtr();
1822  strm->Printf("0x%0*" PRIx64 " ",
1823  target ? (target->GetArchitecture().GetAddressByteSize() * 2)
1824  : 16,
1826  GetSymbolContext(eSymbolContextEverything);
1827  const bool show_module = true;
1828  const bool show_inline = true;
1829  const bool show_function_arguments = true;
1830  const bool show_function_name = true;
1831  m_sc.DumpStopContext(strm, exe_ctx.GetBestExecutionContextScope(),
1832  GetFrameCodeAddress(), show_fullpaths, show_module,
1833  show_inline, show_function_arguments,
1834  show_function_name);
1835 }
1836 
1838  std::lock_guard<std::recursive_mutex> guard(m_mutex);
1839  assert(GetStackID() ==
1840  prev_frame.GetStackID()); // TODO: remove this after some testing
1841  m_variable_list_sp = prev_frame.m_variable_list_sp;
1842  m_variable_list_value_objects.Swap(prev_frame.m_variable_list_value_objects);
1843  if (!m_disassembly.GetString().empty()) {
1844  m_disassembly.Clear();
1845  m_disassembly.PutCString(prev_frame.m_disassembly.GetString());
1846  }
1847 }
1848 
1850  std::lock_guard<std::recursive_mutex> guard(m_mutex);
1851  assert(GetStackID() ==
1852  curr_frame.GetStackID()); // TODO: remove this after some testing
1853  m_id.SetPC(curr_frame.m_id.GetPC()); // Update the Stack ID PC value
1854  assert(GetThread() == curr_frame.GetThread());
1855  m_frame_index = curr_frame.m_frame_index;
1856  m_concrete_frame_index = curr_frame.m_concrete_frame_index;
1857  m_reg_context_sp = curr_frame.m_reg_context_sp;
1858  m_frame_code_addr = curr_frame.m_frame_code_addr;
1859  assert(!m_sc.target_sp || !curr_frame.m_sc.target_sp ||
1860  m_sc.target_sp.get() == curr_frame.m_sc.target_sp.get());
1861  assert(!m_sc.module_sp || !curr_frame.m_sc.module_sp ||
1862  m_sc.module_sp.get() == curr_frame.m_sc.module_sp.get());
1863  assert(m_sc.comp_unit == nullptr || curr_frame.m_sc.comp_unit == nullptr ||
1864  m_sc.comp_unit == curr_frame.m_sc.comp_unit);
1865  assert(m_sc.function == nullptr || curr_frame.m_sc.function == nullptr ||
1866  m_sc.function == curr_frame.m_sc.function);
1867  m_sc = curr_frame.m_sc;
1868  m_flags.Clear(GOT_FRAME_BASE | eSymbolContextEverything);
1869  m_flags.Set(m_sc.GetResolvedMask());
1870  m_frame_base.Clear();
1871  m_frame_base_error.Clear();
1872 }
1873 
1875  if (m_variable_list_sp)
1876  return true;
1877  if (m_variable_list_value_objects.GetSize() > 0)
1878  return true;
1879  if (!m_disassembly.GetString().empty())
1880  return true;
1881  return false;
1882 }
1883 
1884 bool StackFrame::GetStatus(Stream &strm, bool show_frame_info, bool show_source,
1885  bool show_unique, const char *frame_marker) {
1886  if (show_frame_info) {
1887  strm.Indent();
1888  DumpUsingSettingsFormat(&strm, show_unique, frame_marker);
1889  }
1890 
1891  if (show_source) {
1892  ExecutionContext exe_ctx(shared_from_this());
1893  bool have_source = false, have_debuginfo = false;
1894  Debugger::StopDisassemblyType disasm_display =
1896  Target *target = exe_ctx.GetTargetPtr();
1897  if (target) {
1898  Debugger &debugger = target->GetDebugger();
1899  const uint32_t source_lines_before =
1900  debugger.GetStopSourceLineCount(true);
1901  const uint32_t source_lines_after =
1902  debugger.GetStopSourceLineCount(false);
1903  disasm_display = debugger.GetStopDisassemblyDisplay();
1904 
1905  GetSymbolContext(eSymbolContextCompUnit | eSymbolContextLineEntry);
1906  if (m_sc.comp_unit && m_sc.line_entry.IsValid()) {
1907  have_debuginfo = true;
1908  if (source_lines_before > 0 || source_lines_after > 0) {
1909  size_t num_lines =
1911  m_sc.line_entry.file, m_sc.line_entry.line,
1912  m_sc.line_entry.column, source_lines_before,
1913  source_lines_after, "->", &strm);
1914  if (num_lines != 0)
1915  have_source = true;
1916  // TODO: Give here a one time warning if source file is missing.
1917  }
1918  }
1919  switch (disasm_display) {
1921  break;
1922 
1924  if (have_debuginfo)
1925  break;
1926  LLVM_FALLTHROUGH;
1927 
1929  if (have_source)
1930  break;
1931  LLVM_FALLTHROUGH;
1932 
1934  if (target) {
1935  const uint32_t disasm_lines = debugger.GetDisassemblyLineCount();
1936  if (disasm_lines > 0) {
1937  const ArchSpec &target_arch = target->GetArchitecture();
1938  AddressRange pc_range;
1939  pc_range.GetBaseAddress() = GetFrameCodeAddress();
1940  pc_range.SetByteSize(disasm_lines *
1941  target_arch.GetMaximumOpcodeByteSize());
1942  const char *plugin_name = nullptr;
1943  const char *flavor = nullptr;
1944  const bool mixed_source_and_assembly = false;
1946  target->GetDebugger(), target_arch, plugin_name, flavor,
1947  exe_ctx, pc_range, disasm_lines, mixed_source_and_assembly, 0,
1949  }
1950  }
1951  break;
1952  }
1953  }
1954  }
1955  return true;
1956 }
1957 
1958 RecognizedStackFrameSP StackFrame::GetRecognizedFrame() {
1959  if (!m_recognized_frame_sp) {
1960  m_recognized_frame_sp =
1962  }
1963  return m_recognized_frame_sp;
1964 }
bool SetOpcodeLoadAddress(lldb::addr_t load_addr, Target *target, AddressClass addr_class=AddressClass::eInvalid, bool allow_section_end=false)
Definition: Address.cpp:360
A class to manage flag bits.
Definition: Debugger.h:82
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:61
lldb::ValueObjectSP GetValueObjectAtIndex(size_t idx)
lldb::TargetSP target_sp
The Target for a given query.
bool IsSectionOffset() const
Check if an address is section offset.
Definition: Address.h:330
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
lldb::addr_t GetByteSize() const
Get accessor for the byte size of this range.
Definition: AddressRange.h:232
static lldb::RecognizedStackFrameSP RecognizeFrame(lldb::StackFrameSP frame)
#define RESOLVED_GLOBAL_VARIABLES
Definition: StackFrame.cpp:48
const ArchSpec & GetArchitecture() const
Definition: Target.h:941
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:224
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
bool IsInScope(StackFrame *frame)
Definition: Variable.cpp:276
const FormatEntity::Entry * GetFrameFormat() const
Definition: Debugger.cpp:382
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:33
uint32_t GetAddressByteSize() const
Returns the size in bytes of an address of the current architecture.
Definition: ArchSpec.cpp:742
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:292
"lldb/Expression/DWARFExpression.h" Encapsulates a DWARF location expression and interprets it...
bool IsValid() const
Check if a line entry object is valid.
Definition: LineEntry.cpp:47
void SetContext(const lldb::TargetSP &target_sp, bool get_process)
enum lldb_private::Instruction::Operand::Type m_type
lldb::addr_t GetPC() const
Definition: StackID.h:33
const FormatEntity::Entry * GetFrameFormatUnique() const
Definition: Debugger.cpp:387
An architecture specification class.
Definition: ArchSpec.h:32
lldb::ThreadSP CalculateThread() override
static bool Disassemble(Debugger &debugger, const ArchSpec &arch, const char *plugin_name, const char *flavor, const ExecutionContext &exe_ctx, const AddressRange &range, uint32_t num_instructions, bool mixed_source_and_assembly, uint32_t num_mixed_context_lines, uint32_t options, Stream &strm)
A class that describes a function.
Definition: Function.h:323
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:272
lldb::LanguageType GetLanguage()
CompileUnit * comp_unit
The CompileUnit for a given query.
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
uint32_t GetDisassemblyLineCount() const
Definition: Debugger.cpp:513
const char * GetData() const
Definition: StreamString.h:43
A class that describes a single lexical block.
Definition: Block.h:41
bool SetLoadAddress(lldb::addr_t load_addr, Target *target, bool allow_section_end=false)
Set the address to represent load_addr.
Definition: Address.cpp:998
void Reset(ValueType flags)
Set accessor for all flags.
Definition: Flags.h:63
VariableList * GetVariableList(bool get_file_globals)
Retrieve the list of variables that are in scope at this StackFrame&#39;s pc.
Definition: StackFrame.cpp:414
bool IsArtificial() const
Query whether this frame is artificial (e.g a synthesized result of inferring missing tail call frame...
bool SetOffset(lldb::addr_t offset)
Set accessor for the offset.
Definition: Address.h:419
lldb::LanguageType GuessLanguage()
An artificial stack frame (e.g.
uint64_t GetAsUInt64(uint64_t fail_value=UINT64_MAX, bool *success_ptr=nullptr) const
Symbol * symbol
The Symbol for a given query.
uint32_t GetFrameIndex() const
Query this frame to find what frame it is in this Thread&#39;s StackFrameList.
Definition: StackFrame.cpp:166
void SetValueObjectAtIndex(size_t idx, const lldb::ValueObjectSP &valobj_sp)
StopDisassemblyType GetStopDisassemblyDisplay() const
Definition: Debugger.cpp:506
A class that describes a compilation unit.
Definition: CompileUnit.h:35
lldb::ValueObjectSP GuessValueForRegisterAndOffset(ConstString reg, int64_t offset)
Attempt to reconstruct the ValueObject for the address contained in a given register plus an offset...
#define RESOLVED_FRAME_CODE_ADDR
Definition: StackFrame.cpp:44
std::vector< Operand > m_children
Definition: Disassembler.h:209
void UpdatePreviousFrameFromCurrentFrame(StackFrame &curr_frame)
lldb::ValueObjectSP GetValueForVariableExpressionPath(llvm::StringRef var_expr, lldb::DynamicValueType use_dynamic, uint32_t options, lldb::VariableSP &var_sp, Status &error)
Create a ValueObject for a variable name / pathname, possibly including simple dereference/child sele...
Definition: StackFrame.cpp:486
#define RESOLVED_VARIABLES
Definition: StackFrame.cpp:47
SymbolContextScope * GetSymbolContextScope() const
Definition: StackID.h:37
const SymbolContext & GetSymbolContext(lldb::SymbolContextItem resolve_scope)
Provide a SymbolContext for this StackFrame&#39;s current pc value.
Definition: StackFrame.cpp:267
Function * function
The Function for a given query.
bool LocationIsValidForFrame(StackFrame *frame)
Definition: Variable.cpp:220
lldb::addr_t GetOffset() const
Get the section relative offset value.
Definition: Address.h:317
void Dump(Stream *strm, bool show_frame_index, bool show_fullpaths)
Print a description for this frame using a default format.
static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope, llvm::StringRef name, const Address &address, lldb::TypeSP &type_sp)
lldb::RegisterContextSP GetRegisterContext()
Get the RegisterContext for this frame, if possible.
#define UINT32_MAX
Definition: lldb-defines.h:31
lldb::VariableSP GetVariableAtIndex(size_t idx) const
lldb::ProcessSP CalculateProcess() override
std::function< bool(const Instruction::Operand &)> MatchUnaryOp(std::function< bool(const Instruction::Operand &)> base, std::function< bool(const Instruction::Operand &)> child)
Definition: Disassembler.h:266
SourceManager & GetSourceManager()
Definition: Target.cpp:2482
Target * GetTargetPtr() const
Returns a pointer to the target object.
#define LLDB_INVALID_ADDRESS
Invalid value definitions.
Definition: lldb-defines.h:85
uint64_t user_id_t
Definition: lldb-types.h:84
LanguageType
Programming language type.
std::function< bool(const Instruction::Operand &)> FetchRegOp(ConstString &reg)
Definition: Disassembler.h:272
void ApplyFileMappings(lldb::TargetSP target_sp)
Apply file mappings from target.source-map to the LineEntry&#39;s file.
Definition: LineEntry.cpp:254
bool IsInlined()
Query whether this frame is a concrete frame on the call stack, or if it is an inlined frame derived ...
void Clear(bool clear_target)
Clear the object&#39;s state.
size_t GetLength() const
Get the length in bytes of string value.
uint32_t AppendVariables(bool can_create, bool get_parent_variables, bool stop_if_block_is_inlined_function, const std::function< bool(Variable *)> &filter, VariableList *variable_list)
Appends the variables from this block, and optionally from all parent blocks, to variable_list.
Definition: Block.cpp:432
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:127
std::function< bool(const Instruction::Operand &)> MatchBinaryOp(std::function< bool(const Instruction::Operand &)> base, std::function< bool(const Instruction::Operand &)> left, std::function< bool(const Instruction::Operand &)> right)
Definition: Disassembler.h:261
std::function< bool(const Instruction::Operand &)> MatchOpType(Instruction::Operand::Type type)
Definition: Disassembler.h:279
static Operand BuildImmediate(lldb::addr_t imm, bool neg)
bool IsHistorical() const
Query whether this frame is part of a historical backtrace.
lldb::VariableSP FindVariable(ConstString name, bool include_static_members=true)
void DumpUsingSettingsFormat(Stream *strm, bool show_unique=false, const char *frame_marker=nullptr)
Print a description for this frame using the frame-format formatter settings.
Block & GetBlock(bool can_create)
Get accessor for the block list.
Definition: Function.cpp:280
static lldb::DisassemblerSP DisassembleRange(const ArchSpec &arch, const char *plugin_name, const char *flavor, const ExecutionContext &exe_ctx, const AddressRange &disasm_range, bool prefer_file_cache)
void Clear()
Clear the object state.
Definition: Status.cpp:167
uint32_t GetStopSourceLineCount(bool before) const
Definition: Debugger.cpp:499
ConstString GetName() const
Definition: Function.cpp:598
virtual CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type)=0
Block * GetContainingInlinedBlock()
Get the inlined block that contains this block.
Definition: Block.cpp:198
uint32_t GetIndexOfInstructionAtAddress(const Address &addr)
lldb::ValueObjectSP GuessValueForAddress(lldb::addr_t addr)
Attempt to econstruct the ValueObject for a given raw address touched by the current instruction...
void CalculateExecutionContext(ExecutionContext &exe_ctx) override
Reconstruct the object&#39;s execution context into sc.
llvm::StringRef GetString() const
lldb::VariableListSP GetInScopeVariableList(bool get_file_globals, bool must_have_valid_location=false)
Retrieve the list of variables that are in scope at this StackFrame&#39;s pc.
Definition: StackFrame.cpp:453
size_t DisplaySourceLinesWithLineNumbers(const FileSpec &file, uint32_t line, uint32_t column, uint32_t context_before, uint32_t context_after, const char *current_line_cstr, Stream *s, const SymbolContextList *bp_locs=nullptr)
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
Definition: Status.cpp:241
#define RESOLVED_FRAME_ID_SYMBOL_SCOPE
Definition: StackFrame.cpp:45
virtual bool ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value)=0
Block * GetFrameBlock()
Get the current lexical scope block for this StackFrame, if possible.
Definition: StackFrame.cpp:242
#define GOT_FRAME_BASE
Definition: StackFrame.cpp:46
bool GetFunctionMethodInfo(lldb::LanguageType &language, bool &is_instance_method, ConstString &language_object_name)
If this symbol context represents a function that is a method, return true and provide information ab...
static Operand BuildDereference(const Operand &ref)
const RegisterInfo * GetRegisterInfoByName(llvm::StringRef reg_name, uint32_t start_idx=0)
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:106
void SetSymbolContextScope(SymbolContextScope *symbol_scope)
Definition: StackFrame.cpp:175
bool Success() const
Test for success condition.
Definition: Status.cpp:287
ValueType Get() const
Get accessor for all flags.
Definition: Flags.h:51
std::function< bool(const Instruction::Operand &)> FetchImmOp(int64_t &imm)
Definition: Disassembler.h:276
lldb::VariableListSP GetVariableList(bool can_create)
Get the variable list for a compile unit.
void SetRawAddress(lldb::addr_t addr)
Definition: Address.h:425
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:343
A section + offset based address class.
Definition: Address.h:80
ValueType Set(ValueType mask)
Set one or more flags by logical OR&#39;ing mask with the current flags.
Definition: Flags.h:84
lldb::StackFrameSP CalculateStackFrame() override
CompilerType GetPointerType() const
bool GetStatus(Stream &strm, bool show_frame_info, bool show_source, bool show_unique=false, const char *frame_marker=nullptr)
Print a description of this stack frame and/or the source context/assembly for this stack frame...
const Mangled & GetMangled() const
Definition: Function.h:447
InstructionList & GetInstructionList()
static bool Format(const Entry &entry, Stream &s, const SymbolContext *sc, const ExecutionContext *exe_ctx, const Address *addr, ValueObject *valobj, bool function_changed, bool initial_function)
DWARFExpression * GetFrameBaseExpression(Status *error_ptr)
Get the DWARFExpression corresponding to the Canonical Frame Address.
CompilerType GetForwardCompilerType()
Definition: Type.cpp:610
CompilerType GetCompilerType()
Definition: Function.cpp:469
std::function< bool(const Instruction::Operand &)> MatchRegOp(const RegisterInfo &info)
Definition: Disassembler.h:270
lldb::InstructionSP GetInstructionAtIndex(size_t idx) const
bool Evaluate(ExecutionContextScope *exe_scope, lldb::addr_t loclist_base_load_addr, const Value *initial_value_ptr, const Value *object_address_ptr, Value &result, Status *error_ptr) const
Wrapper for the static evaluate function that accepts an ExecutionContextScope instead of an Executio...
uint64_t addr_t
Definition: lldb-types.h:83
static Operand BuildSum(const Operand &lhs, const Operand &rhs)
uint32_t FindIndexForVariable(Variable *variable)
static Operand BuildRegister(ConstString &r)
A uniqued constant string class.
Definition: ConstString.h:38
lldb::ModuleSP GetModule() const
Get accessor for the module for this address.
Definition: Address.cpp:264
Unknown or invalid language value.
bool Fail() const
Test for error condition.
Definition: Status.cpp:181
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:247
void UpdateCurrentFrameFromPreviousFrame(StackFrame &prev_frame)
A historical stack frame – possibly without CFA or registers or local variables. ...
Non-standardized C, such as K&R.
lldb::ModuleSP module_sp
The Module for a given query.
LineEntry line_entry
The LineEntry for a given query.
Definition: SBAddress.h:15
CompilerType GetFunctionReturnType() const
void SetSymbolContextScope(SymbolContextScope *symbol_scope)
Definition: StackID.h:39
size_t Indent(const char *s=nullptr)
Indent the current line in the stream.
Definition: Stream.cpp:131
const char * Disassemble()
Return the disassembly for the instructions of this StackFrame&#39;s function as a single C string...
Definition: StackFrame.cpp:223
lldb::ValueObjectSP FindVariable(ConstString name)
Attempt to reconstruct the ValueObject for a variable with a given name from within the current Stack...
lldb::TargetSP CalculateTarget() override
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:220
void SetErrorStringWithFormatv(const char *format, Args &&... args)
Definition: Status.h:185
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Set the current error string to a formatted error string.
Definition: Status.cpp:255
DWARFExpression & GetFrameBaseExpression()
Get accessor for the frame base location.
Definition: Function.h:433
bool IsFunctionType(bool *is_variadic_ptr=nullptr) const
bool HasDebugInformation()
Determine whether this StackFrame has debug information available or not.
Function * CalculateSymbolContextFunction() override
Definition: Block.cpp:144
bool IsClear(ValueType bit) const
Test a single flag bit to see if it is clear (zero).
Definition: Flags.h:122
const AddressRange & GetAddressRange()
Definition: Function.h:371
lldb::ThreadSP GetThread() const
Definition: StackFrame.h:125
uint32_t GetMaximumOpcodeByteSize() const
Definition: ArchSpec.cpp:970
Scalar & ResolveValue(ExecutionContext *exe_ctx)
Definition: Value.cpp:585
lldb::ValueObjectSP TrackGlobalVariable(const lldb::VariableSP &variable_sp, lldb::DynamicValueType use_dynamic)
Add an arbitrary Variable object (e.g.
ExecutionContextScope * GetBestExecutionContextScope() const
bool ChangePC(lldb::addr_t pc)
Change the pc value for a given thread.
Definition: StackFrame.cpp:209
Block * block
The Block for a given query.
lldb::ValueObjectSP GetValueObjectForFrameVariable(const lldb::VariableSP &variable_sp, lldb::DynamicValueType use_dynamic)
Create a ValueObject for a given Variable in this StackFrame.
lldb::LanguageType GetLanguage()
Query this frame to determine what the default language should be when parsing expressions given the ...
A section + offset based address range class.
Definition: AddressRange.h:32
bool IsLocationList() const
Return true if a location list was provided.
"lldb/Symbol/SymbolContextScope.h" Inherit from this if your object is part of a symbol context and c...
static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope, const lldb::VariableSP &var_sp)
lldb::RecognizedStackFrameSP GetRecognizedFrame()
This base class provides an interface to stack frames.
Definition: StackFrame.h:40
Debugger & GetDebugger()
Definition: Target.h:974
const Address & GetFrameCodeAddress()
Get an Address for the current pc value in this StackFrame.
Definition: StackFrame.cpp:181
bool GetFrameBaseValue(Scalar &value, Status *error_ptr)
Return the Canonical Frame Address (DWARF term) for this frame.
An error handling class.
Definition: Status.h:44
void SetByteSize(lldb::addr_t byte_size)
Set accessor for the byte size of this range.
Definition: AddressRange.h:248
uint32_t AppendBlockVariables(bool can_create, bool get_child_block_variables, bool stop_if_child_block_is_inlined_function, const std::function< bool(Variable *)> &filter, VariableList *variable_list)
Get the variable list for this block and optionally all child blocks if get_child_variables is true...
Definition: Block.cpp:401
Mangled & GetMangled()
Definition: Symbol.h:120