LLDB  mainline
Address.cpp
Go to the documentation of this file.
1 //===-- Address.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 
9 #include "lldb/Core/Address.h"
11 #include "lldb/Core/Module.h"
12 #include "lldb/Core/ModuleList.h"
13 #include "lldb/Core/Section.h"
14 #include "lldb/Symbol/Block.h"
16 #include "lldb/Symbol/LineEntry.h"
17 #include "lldb/Symbol/ObjectFile.h"
18 #include "lldb/Symbol/Symbol.h"
21 #include "lldb/Symbol/Symtab.h"
22 #include "lldb/Symbol/Type.h"
23 #include "lldb/Symbol/Variable.h"
27 #include "lldb/Target/Process.h"
29 #include "lldb/Target/Target.h"
32 #include "lldb/Utility/Endian.h"
33 #include "lldb/Utility/FileSpec.h"
34 #include "lldb/Utility/Status.h"
35 #include "lldb/Utility/Stream.h"
37 
38 #include "llvm/ADT/StringRef.h"
39 #include "llvm/ADT/Triple.h"
40 #include "llvm/Support/Compiler.h"
41 
42 #include <cstdint>
43 #include <memory>
44 #include <vector>
45 
46 #include <assert.h>
47 #include <inttypes.h>
48 #include <string.h>
49 
50 namespace lldb_private {
51 class CompileUnit;
52 }
53 namespace lldb_private {
54 class Function;
55 }
56 
57 using namespace lldb;
58 using namespace lldb_private;
59 
60 static size_t ReadBytes(ExecutionContextScope *exe_scope,
61  const Address &address, void *dst, size_t dst_len) {
62  if (exe_scope == nullptr)
63  return 0;
64 
65  TargetSP target_sp(exe_scope->CalculateTarget());
66  if (target_sp) {
67  Status error;
68  bool prefer_file_cache = false;
69  return target_sp->ReadMemory(address, prefer_file_cache, dst, dst_len,
70  error);
71  }
72  return 0;
73 }
74 
76  const Address &address,
77  ByteOrder &byte_order,
78  uint32_t &addr_size) {
79  byte_order = eByteOrderInvalid;
80  addr_size = 0;
81  if (exe_scope == nullptr)
82  return false;
83 
84  TargetSP target_sp(exe_scope->CalculateTarget());
85  if (target_sp) {
86  byte_order = target_sp->GetArchitecture().GetByteOrder();
87  addr_size = target_sp->GetArchitecture().GetAddressByteSize();
88  }
89 
90  if (byte_order == eByteOrderInvalid || addr_size == 0) {
91  ModuleSP module_sp(address.GetModule());
92  if (module_sp) {
93  byte_order = module_sp->GetArchitecture().GetByteOrder();
94  addr_size = module_sp->GetArchitecture().GetAddressByteSize();
95  }
96  }
97  return byte_order != eByteOrderInvalid && addr_size != 0;
98 }
99 
100 static uint64_t ReadUIntMax64(ExecutionContextScope *exe_scope,
101  const Address &address, uint32_t byte_size,
102  bool &success) {
103  uint64_t uval64 = 0;
104  if (exe_scope == nullptr || byte_size > sizeof(uint64_t)) {
105  success = false;
106  return 0;
107  }
108  uint64_t buf = 0;
109 
110  success = ReadBytes(exe_scope, address, &buf, byte_size) == byte_size;
111  if (success) {
112  ByteOrder byte_order = eByteOrderInvalid;
113  uint32_t addr_size = 0;
114  if (GetByteOrderAndAddressSize(exe_scope, address, byte_order, addr_size)) {
115  DataExtractor data(&buf, sizeof(buf), byte_order, addr_size);
116  lldb::offset_t offset = 0;
117  uval64 = data.GetU64(&offset);
118  } else
119  success = false;
120  }
121  return uval64;
122 }
123 
124 static bool ReadAddress(ExecutionContextScope *exe_scope,
125  const Address &address, uint32_t pointer_size,
126  Address &deref_so_addr) {
127  if (exe_scope == nullptr)
128  return false;
129 
130  bool success = false;
131  addr_t deref_addr = ReadUIntMax64(exe_scope, address, pointer_size, success);
132  if (success) {
133  ExecutionContext exe_ctx;
134  exe_scope->CalculateExecutionContext(exe_ctx);
135  // If we have any sections that are loaded, try and resolve using the
136  // section load list
137  Target *target = exe_ctx.GetTargetPtr();
138  if (target && !target->GetSectionLoadList().IsEmpty()) {
139  if (target->GetSectionLoadList().ResolveLoadAddress(deref_addr,
140  deref_so_addr))
141  return true;
142  } else {
143  // If we were not running, yet able to read an integer, we must have a
144  // module
145  ModuleSP module_sp(address.GetModule());
146 
147  assert(module_sp);
148  if (module_sp->ResolveFileAddress(deref_addr, deref_so_addr))
149  return true;
150  }
151 
152  // We couldn't make "deref_addr" into a section offset value, but we were
153  // able to read the address, so we return a section offset address with no
154  // section and "deref_addr" as the offset (address).
155  deref_so_addr.SetRawAddress(deref_addr);
156  return true;
157  }
158  return false;
159 }
160 
161 static bool DumpUInt(ExecutionContextScope *exe_scope, const Address &address,
162  uint32_t byte_size, Stream *strm) {
163  if (exe_scope == nullptr || byte_size == 0)
164  return 0;
165  std::vector<uint8_t> buf(byte_size, 0);
166 
167  if (ReadBytes(exe_scope, address, &buf[0], buf.size()) == buf.size()) {
168  ByteOrder byte_order = eByteOrderInvalid;
169  uint32_t addr_size = 0;
170  if (GetByteOrderAndAddressSize(exe_scope, address, byte_order, addr_size)) {
171  DataExtractor data(&buf.front(), buf.size(), byte_order, addr_size);
172 
173  DumpDataExtractor(data, strm,
174  0, // Start offset in "data"
175  eFormatHex, // Print as characters
176  buf.size(), // Size of item
177  1, // Items count
178  UINT32_MAX, // num per line
179  LLDB_INVALID_ADDRESS, // base address
180  0, // bitfield bit size
181  0); // bitfield bit offset
182 
183  return true;
184  }
185  }
186  return false;
187 }
188 
190  const Address &address, Stream *strm) {
191  if (exe_scope == nullptr)
192  return 0;
193  const size_t k_buf_len = 256;
194  char buf[k_buf_len + 1];
195  buf[k_buf_len] = '\0'; // NULL terminate
196 
197  // Byte order and address size don't matter for C string dumping..
198  DataExtractor data(buf, sizeof(buf), endian::InlHostByteOrder(), 4);
199  size_t total_len = 0;
200  size_t bytes_read;
201  Address curr_address(address);
202  strm->PutChar('"');
203  while ((bytes_read = ReadBytes(exe_scope, curr_address, buf, k_buf_len)) >
204  0) {
205  size_t len = strlen(buf);
206  if (len == 0)
207  break;
208  if (len > bytes_read)
209  len = bytes_read;
210 
211  DumpDataExtractor(data, strm,
212  0, // Start offset in "data"
213  eFormatChar, // Print as characters
214  1, // Size of item (1 byte for a char!)
215  len, // How many bytes to print?
216  UINT32_MAX, // num per line
217  LLDB_INVALID_ADDRESS, // base address
218  0, // bitfield bit size
219 
220  0); // bitfield bit offset
221 
222  total_len += bytes_read;
223 
224  if (len < k_buf_len)
225  break;
226  curr_address.SetOffset(curr_address.GetOffset() + bytes_read);
227  }
228  strm->PutChar('"');
229  return total_len;
230 }
231 
232 Address::Address(lldb::addr_t abs_addr) : m_section_wp(), m_offset(abs_addr) {}
233 
234 Address::Address(addr_t address, const SectionList *section_list)
236  ResolveAddressUsingFileSections(address, section_list);
237 }
238 
239 const Address &Address::operator=(const Address &rhs) {
240  if (this != &rhs) {
242  m_offset = rhs.m_offset;
243  }
244  return *this;
245 }
246 
248  const SectionList *section_list) {
249  if (section_list) {
250  SectionSP section_sp(
251  section_list->FindSectionContainingFileAddress(file_addr));
252  m_section_wp = section_sp;
253  if (section_sp) {
254  assert(section_sp->ContainsFileAddress(file_addr));
255  m_offset = file_addr - section_sp->GetFileAddress();
256  return true; // Successfully transformed addr into a section offset
257  // address
258  }
259  }
260  m_offset = file_addr;
261  return false; // Failed to resolve this address to a section offset value
262 }
263 
264 ModuleSP Address::GetModule() const {
265  lldb::ModuleSP module_sp;
266  SectionSP section_sp(GetSection());
267  if (section_sp)
268  module_sp = section_sp->GetModule();
269  return module_sp;
270 }
271 
273  SectionSP section_sp(GetSection());
274  if (section_sp) {
275  addr_t sect_file_addr = section_sp->GetFileAddress();
276  if (sect_file_addr == LLDB_INVALID_ADDRESS) {
277  // Section isn't resolved, we can't return a valid file address
278  return LLDB_INVALID_ADDRESS;
279  }
280  // We have a valid file range, so we can return the file based address by
281  // adding the file base address to our offset
282  return sect_file_addr + m_offset;
283  } else if (SectionWasDeletedPrivate()) {
284  // Used to have a valid section but it got deleted so the offset doesn't
285  // mean anything without the section
286  return LLDB_INVALID_ADDRESS;
287  }
288  // No section, we just return the offset since it is the value in this case
289  return m_offset;
290 }
291 
293  SectionSP section_sp(GetSection());
294  if (section_sp) {
295  if (target) {
296  addr_t sect_load_addr = section_sp->GetLoadBaseAddress(target);
297 
298  if (sect_load_addr != LLDB_INVALID_ADDRESS) {
299  // We have a valid file range, so we can return the file based address
300  // by adding the file base address to our offset
301  return sect_load_addr + m_offset;
302  }
303  }
304  } else if (SectionWasDeletedPrivate()) {
305  // Used to have a valid section but it got deleted so the offset doesn't
306  // mean anything without the section
307  return LLDB_INVALID_ADDRESS;
308  } else {
309  // We don't have a section so the offset is the load address
310  return m_offset;
311  }
312  // The section isn't resolved or an invalid target was passed in so we can't
313  // return a valid load address.
314  return LLDB_INVALID_ADDRESS;
315 }
316 
317 addr_t Address::GetCallableLoadAddress(Target *target, bool is_indirect) const {
318  addr_t code_addr = LLDB_INVALID_ADDRESS;
319 
320  if (is_indirect && target) {
321  ProcessSP processSP = target->GetProcessSP();
322  Status error;
323  if (processSP) {
324  code_addr = processSP->ResolveIndirectFunction(this, error);
325  if (!error.Success())
326  code_addr = LLDB_INVALID_ADDRESS;
327  }
328  } else {
329  code_addr = GetLoadAddress(target);
330  }
331 
332  if (code_addr == LLDB_INVALID_ADDRESS)
333  return code_addr;
334 
335  if (target)
336  return target->GetCallableLoadAddress(code_addr, GetAddressClass());
337  return code_addr;
338 }
339 
341  if (SetLoadAddress(load_addr, target)) {
342  if (target)
344  return true;
345  }
346  return false;
347 }
348 
350  AddressClass addr_class) const {
351  addr_t code_addr = GetLoadAddress(target);
352  if (code_addr != LLDB_INVALID_ADDRESS) {
353  if (addr_class == AddressClass::eInvalid)
354  addr_class = GetAddressClass();
355  code_addr = target->GetOpcodeLoadAddress(code_addr, addr_class);
356  }
357  return code_addr;
358 }
359 
361  AddressClass addr_class,
362  bool allow_section_end) {
363  if (SetLoadAddress(load_addr, target, allow_section_end)) {
364  if (target) {
365  if (addr_class == AddressClass::eInvalid)
366  addr_class = GetAddressClass();
367  m_offset = target->GetOpcodeLoadAddress(m_offset, addr_class);
368  }
369  return true;
370  }
371  return false;
372 }
373 
375  DumpStyle fallback_style, uint32_t addr_size) const {
376  // If the section was nullptr, only load address is going to work unless we
377  // are trying to deref a pointer
378  SectionSP section_sp(GetSection());
379  if (!section_sp && style != DumpStyleResolvedPointerDescription)
380  style = DumpStyleLoadAddress;
381 
382  ExecutionContext exe_ctx(exe_scope);
383  Target *target = exe_ctx.GetTargetPtr();
384  // If addr_byte_size is UINT32_MAX, then determine the correct address byte
385  // size for the process or default to the size of addr_t
386  if (addr_size == UINT32_MAX) {
387  if (target)
388  addr_size = target->GetArchitecture().GetAddressByteSize();
389  else
390  addr_size = sizeof(addr_t);
391  }
392 
393  Address so_addr;
394  switch (style) {
395  case DumpStyleInvalid:
396  return false;
397 
399  if (section_sp) {
400  section_sp->DumpName(s);
401  s->Printf(" + %" PRIu64, m_offset);
402  } else {
403  s->Address(m_offset, addr_size);
404  }
405  break;
406 
408  s->Printf("(Section *)%p + ", static_cast<void *>(section_sp.get()));
409  s->Address(m_offset, addr_size);
410  break;
411 
413  if (section_sp) {
414  ModuleSP module_sp = section_sp->GetModule();
415  if (module_sp)
416  s->Printf("%s[", module_sp->GetFileSpec().GetFilename().AsCString(
417  "<Unknown>"));
418  else
419  s->Printf("%s[", "<Unknown>");
420  }
421  LLVM_FALLTHROUGH;
422  case DumpStyleFileAddress: {
423  addr_t file_addr = GetFileAddress();
424  if (file_addr == LLDB_INVALID_ADDRESS) {
425  if (fallback_style != DumpStyleInvalid)
426  return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
427  return false;
428  }
429  s->Address(file_addr, addr_size);
430  if (style == DumpStyleModuleWithFileAddress && section_sp)
431  s->PutChar(']');
432  } break;
433 
434  case DumpStyleLoadAddress: {
435  addr_t load_addr = GetLoadAddress(target);
436 
437  /*
438  * MIPS:
439  * Display address in compressed form for MIPS16 or microMIPS
440  * if the address belongs to AddressClass::eCodeAlternateISA.
441  */
442  if (target) {
443  const llvm::Triple::ArchType llvm_arch =
444  target->GetArchitecture().GetMachine();
445  if (llvm_arch == llvm::Triple::mips ||
446  llvm_arch == llvm::Triple::mipsel ||
447  llvm_arch == llvm::Triple::mips64 ||
448  llvm_arch == llvm::Triple::mips64el)
449  load_addr = GetCallableLoadAddress(target);
450  }
451 
452  if (load_addr == LLDB_INVALID_ADDRESS) {
453  if (fallback_style != DumpStyleInvalid)
454  return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
455  return false;
456  }
457  s->Address(load_addr, addr_size);
458  } break;
459 
464  if (IsSectionOffset()) {
465  uint32_t pointer_size = 4;
466  ModuleSP module_sp(GetModule());
467  if (target)
468  pointer_size = target->GetArchitecture().GetAddressByteSize();
469  else if (module_sp)
470  pointer_size = module_sp->GetArchitecture().GetAddressByteSize();
471 
472  bool showed_info = false;
473  if (section_sp) {
474  SectionType sect_type = section_sp->GetType();
475  switch (sect_type) {
476  case eSectionTypeData:
477  if (module_sp) {
478  SymbolVendor *sym_vendor = module_sp->GetSymbolVendor();
479  if (sym_vendor) {
480  Symtab *symtab = sym_vendor->GetSymtab();
481  if (symtab) {
482  const addr_t file_Addr = GetFileAddress();
483  Symbol *symbol =
484  symtab->FindSymbolContainingFileAddress(file_Addr);
485  if (symbol) {
486  const char *symbol_name = symbol->GetName().AsCString();
487  if (symbol_name) {
488  s->PutCString(symbol_name);
489  addr_t delta =
490  file_Addr - symbol->GetAddressRef().GetFileAddress();
491  if (delta)
492  s->Printf(" + %" PRIu64, delta);
493  showed_info = true;
494  }
495  }
496  }
497  }
498  }
499  break;
500 
502  // Read the C string from memory and display it
503  showed_info = true;
504  ReadCStringFromMemory(exe_scope, *this, s);
505  break;
506 
508  if (ReadAddress(exe_scope, *this, pointer_size, so_addr)) {
509 #if VERBOSE_OUTPUT
510  s->PutCString("(char *)");
511  so_addr.Dump(s, exe_scope, DumpStyleLoadAddress,
513  s->PutCString(": ");
514 #endif
515  showed_info = true;
516  ReadCStringFromMemory(exe_scope, so_addr, s);
517  }
518  break;
519 
521  if (ReadAddress(exe_scope, *this, pointer_size, so_addr)) {
522  if (target && so_addr.IsSectionOffset()) {
523  SymbolContext func_sc;
525  so_addr, eSymbolContextEverything, func_sc);
526  if (func_sc.function != nullptr || func_sc.symbol != nullptr) {
527  showed_info = true;
528 #if VERBOSE_OUTPUT
529  s->PutCString("(objc_msgref *) -> { (func*)");
530  so_addr.Dump(s, exe_scope, DumpStyleLoadAddress,
532 #else
533  s->PutCString("{ ");
534 #endif
535  Address cstr_addr(*this);
536  cstr_addr.SetOffset(cstr_addr.GetOffset() + pointer_size);
537  func_sc.DumpStopContext(s, exe_scope, so_addr, true, true,
538  false, true, true);
539  if (ReadAddress(exe_scope, cstr_addr, pointer_size, so_addr)) {
540 #if VERBOSE_OUTPUT
541  s->PutCString("), (char *)");
542  so_addr.Dump(s, exe_scope, DumpStyleLoadAddress,
544  s->PutCString(" (");
545 #else
546  s->PutCString(", ");
547 #endif
548  ReadCStringFromMemory(exe_scope, so_addr, s);
549  }
550 #if VERBOSE_OUTPUT
551  s->PutCString(") }");
552 #else
553  s->PutCString(" }");
554 #endif
555  }
556  }
557  }
558  break;
559 
561  Address cfstring_data_addr(*this);
562  cfstring_data_addr.SetOffset(cfstring_data_addr.GetOffset() +
563  (2 * pointer_size));
564  if (ReadAddress(exe_scope, cfstring_data_addr, pointer_size,
565  so_addr)) {
566 #if VERBOSE_OUTPUT
567  s->PutCString("(CFString *) ");
568  cfstring_data_addr.Dump(s, exe_scope, DumpStyleLoadAddress,
570  s->PutCString(" -> @");
571 #else
572  s->PutChar('@');
573 #endif
574  if (so_addr.Dump(s, exe_scope, DumpStyleResolvedDescription))
575  showed_info = true;
576  }
577  } break;
578 
579  case eSectionTypeData4:
580  // Read the 4 byte data and display it
581  showed_info = true;
582  s->PutCString("(uint32_t) ");
583  DumpUInt(exe_scope, *this, 4, s);
584  break;
585 
586  case eSectionTypeData8:
587  // Read the 8 byte data and display it
588  showed_info = true;
589  s->PutCString("(uint64_t) ");
590  DumpUInt(exe_scope, *this, 8, s);
591  break;
592 
593  case eSectionTypeData16:
594  // Read the 16 byte data and display it
595  showed_info = true;
596  s->PutCString("(uint128_t) ");
597  DumpUInt(exe_scope, *this, 16, s);
598  break;
599 
601  // Read the pointer data and display it
602  if (ReadAddress(exe_scope, *this, pointer_size, so_addr)) {
603  s->PutCString("(void *)");
604  so_addr.Dump(s, exe_scope, DumpStyleLoadAddress,
606 
607  showed_info = true;
608  if (so_addr.IsSectionOffset()) {
609  SymbolContext pointer_sc;
610  if (target) {
612  so_addr, eSymbolContextEverything, pointer_sc);
613  if (pointer_sc.function != nullptr ||
614  pointer_sc.symbol != nullptr) {
615  s->PutCString(": ");
616  pointer_sc.DumpStopContext(s, exe_scope, so_addr, true, false,
617  false, true, true);
618  }
619  }
620  }
621  }
622  break;
623 
624  default:
625  break;
626  }
627  }
628 
629  if (!showed_info) {
630  if (module_sp) {
631  SymbolContext sc;
632  module_sp->ResolveSymbolContextForAddress(
633  *this, eSymbolContextEverything, sc);
634  if (sc.function || sc.symbol) {
635  bool show_stop_context = true;
636  const bool show_module = (style == DumpStyleResolvedDescription);
637  const bool show_fullpaths = false;
638  const bool show_inlined_frames = true;
639  const bool show_function_arguments =
641  const bool show_function_name = (style != DumpStyleNoFunctionName);
642  if (sc.function == nullptr && sc.symbol != nullptr) {
643  // If we have just a symbol make sure it is in the right section
644  if (sc.symbol->ValueIsAddress()) {
645  if (sc.symbol->GetAddressRef().GetSection() != GetSection()) {
646  // don't show the module if the symbol is a trampoline symbol
647  show_stop_context = false;
648  }
649  }
650  }
651  if (show_stop_context) {
652  // We have a function or a symbol from the same sections as this
653  // address.
654  sc.DumpStopContext(s, exe_scope, *this, show_fullpaths,
655  show_module, show_inlined_frames,
656  show_function_arguments, show_function_name);
657  } else {
658  // We found a symbol but it was in a different section so it
659  // isn't the symbol we should be showing, just show the section
660  // name + offset
661  Dump(s, exe_scope, DumpStyleSectionNameOffset);
662  }
663  }
664  }
665  }
666  } else {
667  if (fallback_style != DumpStyleInvalid)
668  return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
669  return false;
670  }
671  break;
672 
674  if (IsSectionOffset()) {
675  ModuleSP module_sp(GetModule());
676  if (module_sp) {
677  SymbolContext sc;
678  module_sp->ResolveSymbolContextForAddress(
679  *this, eSymbolContextEverything | eSymbolContextVariable, sc);
680  if (sc.symbol) {
681  // If we have just a symbol make sure it is in the same section as
682  // our address. If it isn't, then we might have just found the last
683  // symbol that came before the address that we are looking up that
684  // has nothing to do with our address lookup.
685  if (sc.symbol->ValueIsAddress() &&
687  sc.symbol = nullptr;
688  }
689  sc.GetDescription(s, eDescriptionLevelBrief, target);
690 
691  if (sc.block) {
692  bool can_create = true;
693  bool get_parent_variables = true;
694  bool stop_if_block_is_inlined_function = false;
695  VariableList variable_list;
696  sc.block->AppendVariables(can_create, get_parent_variables,
697  stop_if_block_is_inlined_function,
698  [](Variable *) { return true; },
699  &variable_list);
700 
701  const size_t num_variables = variable_list.GetSize();
702  for (size_t var_idx = 0; var_idx < num_variables; ++var_idx) {
703  Variable *var = variable_list.GetVariableAtIndex(var_idx).get();
704  if (var && var->LocationIsValidForAddress(*this)) {
705  s->Indent();
706  s->Printf(" Variable: id = {0x%8.8" PRIx64 "}, name = \"%s\"",
707  var->GetID(), var->GetName().GetCString());
708  Type *type = var->GetType();
709  if (type)
710  s->Printf(", type = \"%s\"", type->GetName().GetCString());
711  else
712  s->PutCString(", type = <unknown>");
713  s->PutCString(", location = ");
714  var->DumpLocationForAddress(s, *this);
715  s->PutCString(", decl = ");
716  var->GetDeclaration().DumpStopContext(s, false);
717  s->EOL();
718  }
719  }
720  }
721  }
722  } else {
723  if (fallback_style != DumpStyleInvalid)
724  return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
725  return false;
726  }
727  break;
728 
730  Process *process = exe_ctx.GetProcessPtr();
731  if (process) {
732  addr_t load_addr = GetLoadAddress(target);
733  if (load_addr != LLDB_INVALID_ADDRESS) {
734  Status memory_error;
735  addr_t dereferenced_load_addr =
736  process->ReadPointerFromMemory(load_addr, memory_error);
737  if (dereferenced_load_addr != LLDB_INVALID_ADDRESS) {
738  Address dereferenced_addr;
739  if (dereferenced_addr.SetLoadAddress(dereferenced_load_addr,
740  target)) {
741  StreamString strm;
742  if (dereferenced_addr.Dump(&strm, exe_scope,
744  DumpStyleInvalid, addr_size)) {
745  s->Address(dereferenced_load_addr, addr_size, " -> ", " ");
746  s->Write(strm.GetString().data(), strm.GetSize());
747  return true;
748  }
749  }
750  }
751  }
752  }
753  if (fallback_style != DumpStyleInvalid)
754  return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
755  return false;
756  } break;
757  }
758 
759  return true;
760 }
761 
763  if (GetSection())
764  return false;
765  return SectionWasDeletedPrivate();
766 }
767 
769  lldb::SectionWP empty_section_wp;
770 
771  // If either call to "std::weak_ptr::owner_before(...) value returns true,
772  // this indicates that m_section_wp once contained (possibly still does) a
773  // reference to a valid shared pointer. This helps us know if we had a valid
774  // reference to a section which is now invalid because the module it was in
775  // was unloaded/deleted, or if the address doesn't have a valid reference to
776  // a section.
777  return empty_section_wp.owner_before(m_section_wp) ||
778  m_section_wp.owner_before(empty_section_wp);
779 }
780 
781 uint32_t
783  SymbolContextItem resolve_scope) const {
784  sc->Clear(false);
785  // Absolute addresses don't have enough information to reconstruct even their
786  // target.
787 
788  SectionSP section_sp(GetSection());
789  if (section_sp) {
790  ModuleSP module_sp(section_sp->GetModule());
791  if (module_sp) {
792  sc->module_sp = module_sp;
793  if (sc->module_sp)
794  return sc->module_sp->ResolveSymbolContextForAddress(
795  *this, resolve_scope, *sc);
796  }
797  }
798  return 0;
799 }
800 
802  SectionSP section_sp(GetSection());
803  if (section_sp)
804  return section_sp->GetModule();
805  return ModuleSP();
806 }
807 
809  SectionSP section_sp(GetSection());
810  if (section_sp) {
811  SymbolContext sc;
812  sc.module_sp = section_sp->GetModule();
813  if (sc.module_sp) {
814  sc.module_sp->ResolveSymbolContextForAddress(*this,
815  eSymbolContextCompUnit, sc);
816  return sc.comp_unit;
817  }
818  }
819  return nullptr;
820 }
821 
823  SectionSP section_sp(GetSection());
824  if (section_sp) {
825  SymbolContext sc;
826  sc.module_sp = section_sp->GetModule();
827  if (sc.module_sp) {
828  sc.module_sp->ResolveSymbolContextForAddress(*this,
829  eSymbolContextFunction, sc);
830  return sc.function;
831  }
832  }
833  return nullptr;
834 }
835 
837  SectionSP section_sp(GetSection());
838  if (section_sp) {
839  SymbolContext sc;
840  sc.module_sp = section_sp->GetModule();
841  if (sc.module_sp) {
842  sc.module_sp->ResolveSymbolContextForAddress(*this, eSymbolContextBlock,
843  sc);
844  return sc.block;
845  }
846  }
847  return nullptr;
848 }
849 
851  SectionSP section_sp(GetSection());
852  if (section_sp) {
853  SymbolContext sc;
854  sc.module_sp = section_sp->GetModule();
855  if (sc.module_sp) {
856  sc.module_sp->ResolveSymbolContextForAddress(*this, eSymbolContextSymbol,
857  sc);
858  return sc.symbol;
859  }
860  }
861  return nullptr;
862 }
863 
865  SectionSP section_sp(GetSection());
866  if (section_sp) {
867  SymbolContext sc;
868  sc.module_sp = section_sp->GetModule();
869  if (sc.module_sp) {
870  sc.module_sp->ResolveSymbolContextForAddress(*this,
871  eSymbolContextLineEntry, sc);
872  if (sc.line_entry.IsValid()) {
873  line_entry = sc.line_entry;
874  return true;
875  }
876  }
877  }
878  line_entry.Clear();
879  return false;
880 }
881 
882 int Address::CompareFileAddress(const Address &a, const Address &b) {
883  addr_t a_file_addr = a.GetFileAddress();
884  addr_t b_file_addr = b.GetFileAddress();
885  if (a_file_addr < b_file_addr)
886  return -1;
887  if (a_file_addr > b_file_addr)
888  return +1;
889  return 0;
890 }
891 
893  Target *target) {
894  assert(target != nullptr);
895  addr_t a_load_addr = a.GetLoadAddress(target);
896  addr_t b_load_addr = b.GetLoadAddress(target);
897  if (a_load_addr < b_load_addr)
898  return -1;
899  if (a_load_addr > b_load_addr)
900  return +1;
901  return 0;
902 }
903 
905  ModuleSP a_module_sp(a.GetModule());
906  ModuleSP b_module_sp(b.GetModule());
907  Module *a_module = a_module_sp.get();
908  Module *b_module = b_module_sp.get();
909  if (a_module < b_module)
910  return -1;
911  if (a_module > b_module)
912  return +1;
913  // Modules are the same, just compare the file address since they should be
914  // unique
915  addr_t a_file_addr = a.GetFileAddress();
916  addr_t b_file_addr = b.GetFileAddress();
917  if (a_file_addr < b_file_addr)
918  return -1;
919  if (a_file_addr > b_file_addr)
920  return +1;
921  return 0;
922 }
923 
924 size_t Address::MemorySize() const {
925  // Noting special for the memory size of a single Address object, it is just
926  // the size of itself.
927  return sizeof(Address);
928 }
929 
930 // NOTE: Be careful using this operator. It can correctly compare two
931 // addresses from the same Module correctly. It can't compare two addresses
932 // from different modules in any meaningful way, but it will compare the module
933 // pointers.
934 //
935 // To sum things up:
936 // - works great for addresses within the same module - it works for addresses
937 // across multiple modules, but don't expect the
938 // address results to make much sense
939 //
940 // This basically lets Address objects be used in ordered collection classes.
941 
942 bool lldb_private::operator<(const Address &lhs, const Address &rhs) {
943  ModuleSP lhs_module_sp(lhs.GetModule());
944  ModuleSP rhs_module_sp(rhs.GetModule());
945  Module *lhs_module = lhs_module_sp.get();
946  Module *rhs_module = rhs_module_sp.get();
947  if (lhs_module == rhs_module) {
948  // Addresses are in the same module, just compare the file addresses
949  return lhs.GetFileAddress() < rhs.GetFileAddress();
950  } else {
951  // The addresses are from different modules, just use the module pointer
952  // value to get consistent ordering
953  return lhs_module < rhs_module;
954  }
955 }
956 
957 bool lldb_private::operator>(const Address &lhs, const Address &rhs) {
958  ModuleSP lhs_module_sp(lhs.GetModule());
959  ModuleSP rhs_module_sp(rhs.GetModule());
960  Module *lhs_module = lhs_module_sp.get();
961  Module *rhs_module = rhs_module_sp.get();
962  if (lhs_module == rhs_module) {
963  // Addresses are in the same module, just compare the file addresses
964  return lhs.GetFileAddress() > rhs.GetFileAddress();
965  } else {
966  // The addresses are from different modules, just use the module pointer
967  // value to get consistent ordering
968  return lhs_module > rhs_module;
969  }
970 }
971 
972 // The operator == checks for exact equality only (same section, same offset)
973 bool lldb_private::operator==(const Address &a, const Address &rhs) {
974  return a.GetOffset() == rhs.GetOffset() && a.GetSection() == rhs.GetSection();
975 }
976 
977 // The operator != checks for exact inequality only (differing section, or
978 // different offset)
979 bool lldb_private::operator!=(const Address &a, const Address &rhs) {
980  return a.GetOffset() != rhs.GetOffset() || a.GetSection() != rhs.GetSection();
981 }
982 
984  ModuleSP module_sp(GetModule());
985  if (module_sp) {
986  ObjectFile *obj_file = module_sp->GetObjectFile();
987  if (obj_file) {
988  // Give the symbol vendor a chance to add to the unified section list
989  // and to symtab from symbol file
990  if (SymbolVendor *vendor = module_sp->GetSymbolVendor())
991  vendor->GetSymtab();
992  return obj_file->GetAddressClass(GetFileAddress());
993  }
994  }
995  return AddressClass::eUnknown;
996 }
997 
999  bool allow_section_end) {
1000  if (target && target->GetSectionLoadList().ResolveLoadAddress(
1001  load_addr, *this, allow_section_end))
1002  return true;
1003  m_section_wp.reset();
1004  m_offset = load_addr;
1005  return false;
1006 }
bool SetOpcodeLoadAddress(lldb::addr_t load_addr, Target *target, AddressClass addr_class=AddressClass::eInvalid, bool allow_section_end=false)
Definition: Address.cpp:360
Address & GetAddressRef()
Definition: Symbol.h:56
void Address(uint64_t addr, uint32_t addr_size, const char *prefix=nullptr, const char *suffix=nullptr)
Output an address value to this stream.
Definition: Stream.cpp:79
lldb::addr_t GetCallableLoadAddress(Target *target, bool is_indirect=false) const
Get the load address as a callable code load address.
Definition: Address.cpp:317
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:61
A line table entry class.
Definition: LineEntry.h:20
bool IsSectionOffset() const
Check if an address is section offset.
Definition: Address.h:330
An data extractor class.
Definition: DataExtractor.h:47
static bool ReadAddress(ExecutionContextScope *exe_scope, const Address &address, uint32_t pointer_size, Address &deref_so_addr)
Definition: Address.cpp:124
static uint64_t ReadUIntMax64(ExecutionContextScope *exe_scope, const Address &address, uint32_t byte_size, bool &success)
Definition: Address.cpp:100
Function * CalculateSymbolContextFunction() const
Definition: Address.cpp:822
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
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
uint32_t CalculateSymbolContext(SymbolContext *sc, lldb::SymbolContextItem resolve_scope=lldb::eSymbolContextEverything) const
Reconstruct a symbol context from an address.
Definition: Address.cpp:782
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
bool SetCallableLoadAddress(lldb::addr_t load_addr, Target *target)
Definition: Address.cpp:340
virtual void CalculateExecutionContext(ExecutionContext &exe_ctx)=0
Reconstruct the object&#39;s execution context into sc.
CompileUnit * CalculateSymbolContextCompileUnit() const
Definition: Address.cpp:808
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
void Clear()
Clear the object&#39;s state.
Definition: LineEntry.cpp:34
bool IsValid() const
Check if a line entry object is valid.
Definition: LineEntry.cpp:47
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.
bool Dump(Stream *s, ExecutionContextScope *exe_scope, DumpStyle style, DumpStyle fallback_style=DumpStyleInvalid, uint32_t addr_byte_size=UINT32_MAX) const
Dump a description of this object to a Stream.
Definition: Address.cpp:374
virtual AddressClass GetAddressClass(lldb::addr_t file_addr)
Get the address type given a file address in an object file.
Definition: ObjectFile.cpp:314
static int CompareModulePointerAndOffset(const Address &lhs, const Address &rhs)
Definition: Address.cpp:904
lldb::user_id_t GetID() const
Get accessor for the user ID.
Definition: UserID.h:49
static bool DumpUInt(ExecutionContextScope *exe_scope, const Address &address, uint32_t byte_size, Stream *strm)
Definition: Address.cpp:161
A class that describes a function.
Definition: Function.h:323
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:272
const Declaration & GetDeclaration() const
Definition: Variable.h:45
A plug-in interface definition class for object file parsers.
Definition: ObjectFile.h:58
CompileUnit * comp_unit
The CompileUnit for a given query.
static int CompareLoadAddress(const Address &lhs, const Address &rhs, Target *target)
Definition: Address.cpp:892
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
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
size_t Write(const void *src, size_t src_len)
Output character bytes to the stream.
Definition: Stream.h:100
lldb::addr_t GetCallableLoadAddress(lldb::addr_t load_addr, AddressClass addr_class=AddressClass::eInvalid) const
Get load_addr as a callable code load address for this target.
Definition: Target.cpp:2462
lldb::SectionSP FindSectionContainingFileAddress(lldb::addr_t addr, uint32_t depth=UINT32_MAX) const
Definition: Section.cpp:564
bool SectionWasDeleted() const
Definition: Address.cpp:762
lldb::ModuleSP CalculateSymbolContextModule() const
Definition: Address.cpp:801
Display as the section pointer + offset (debug output).
Definition: Address.h:90
bool SetOffset(lldb::addr_t offset)
Set accessor for the offset.
Definition: Address.h:419
DumpStyle
Dump styles allow the Address::Dump(Stream *,DumpStyle) const function to display Address contents in...
Definition: Address.h:84
Symbol * symbol
The Symbol for a given query.
lldb::SectionWP m_section_wp
The section for the address, can be NULL.
Definition: Address.h:483
A class that describes a compilation unit.
Definition: CompileUnit.h:35
virtual lldb::TargetSP CalculateTarget()=0
Function * function
The Function for a given query.
static int CompareFileAddress(const Address &lhs, const Address &rhs)
Compare two Address objects.
Definition: Address.cpp:882
lldb::addr_t GetOffset() const
Get the section relative offset value.
Definition: Address.h:317
bool operator==(const Address &lhs, const Address &rhs)
Definition: Address.cpp:973
lldb::addr_t m_offset
Offset into section if m_section_wp is valid...
Definition: Address.h:484
ConstString GetName() const
Definition: Variable.cpp:64
#define UINT32_MAX
Definition: lldb-defines.h:31
lldb::VariableSP GetVariableAtIndex(size_t idx) const
ConstString GetName()
Definition: Type.cpp:275
AddressClass GetAddressClass() const
Definition: Address.cpp:983
Target * GetTargetPtr() const
Returns a pointer to the target object.
#define LLDB_INVALID_ADDRESS
Invalid value definitions.
Definition: lldb-defines.h:85
const lldb::ProcessSP & GetProcessSP() const
Definition: Target.cpp:206
Address()
Default constructor.
Definition: Address.h:130
uint64_t offset_t
Definition: lldb-types.h:87
bool DumpStopContext(Stream *s, bool show_fullpaths) const
Definition: Declaration.cpp:42
void Clear(bool clear_target)
Clear the object&#39;s state.
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
SectionLoadList & GetSectionLoadList()
Definition: Target.h:1012
const Address & operator=(const Address &rhs)
Assignment operator.
Definition: Address.cpp:239
A class that describes an executable image and its associated object and symbol files.
Definition: Module.h:109
static size_t ReadCStringFromMemory(ExecutionContextScope *exe_scope, const Address &address, Stream *strm)
Definition: Address.cpp:189
bool LocationIsValidForAddress(const Address &address)
Definition: Variable.cpp:248
llvm::StringRef GetString() const
bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr, bool allow_section_end=false) const
lldb::addr_t GetOpcodeLoadAddress(Target *target, AddressClass addr_class=AddressClass::eInvalid) const
Get the load address as an opcode load address.
Definition: Address.cpp:349
bool DumpLocationForAddress(Stream *s, const Address &address)
Definition: Variable.cpp:450
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
bool ValueIsAddress() const
Definition: Symbol.cpp:114
lldb::addr_t GetOpcodeLoadAddress(lldb::addr_t load_addr, AddressClass addr_class=AddressClass::eInvalid) const
Get load_addr as an opcode for this target.
Definition: Target.cpp:2469
A plug-in interface definition class for debugging a process.
Definition: Process.h:353
Process * GetProcessPtr() const
Returns a pointer to the process object.
Display as the section name + offset.
Definition: Address.h:86
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:106
bool Success() const
Test for success condition.
Definition: Status.cpp:287
Symbol * FindSymbolContainingFileAddress(lldb::addr_t file_addr)
Definition: Symtab.cpp:994
Detailed symbol context information for an address for all symbol context members.
Definition: Address.h:118
void SetRawAddress(lldb::addr_t addr)
Definition: Address.h:425
A section + offset based address class.
Definition: Address.h:80
uint32_t ResolveSymbolContextForAddress(const Address &so_addr, lldb::SymbolContextItem resolve_scope, SymbolContext &sc) const
Resolve the symbol context for the given address. (const Address
Definition: ModuleList.cpp:662
bool operator!=(const Address &lhs, const Address &rhs)
Definition: Address.cpp:979
lldb::offset_t DumpDataExtractor(const DataExtractor &DE, Stream *s, lldb::offset_t offset, lldb::Format item_format, size_t item_byte_size, size_t item_count, size_t num_per_line, uint64_t base_addr, uint32_t item_bit_size, uint32_t item_bit_offset, ExecutionContextScope *exe_scope=nullptr)
Dumps item_count objects into the stream s.
Dereference a pointer at the current address and then lookup the.
Definition: Address.h:121
bool CalculateSymbolContextLineEntry(LineEntry &line_entry) const
Definition: Address.cpp:864
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:899
size_t MemorySize() const
Get the memory cost of this object.
Definition: Address.cpp:924
lldb::addr_t ReadPointerFromMemory(lldb::addr_t vm_addr, Status &error)
Definition: Process.cpp:2172
Block * CalculateSymbolContextBlock() const
Definition: Address.cpp:836
size_t PutChar(char ch)
Definition: Stream.cpp:103
bool operator>(const Address &lhs, const Address &rhs)
Definition: Address.cpp:957
Display the details about what an address resolves to.
Definition: Address.h:108
uint64_t addr_t
Definition: lldb-types.h:83
static bool GetByteOrderAndAddressSize(ExecutionContextScope *exe_scope, const Address &address, ByteOrder &byte_order, uint32_t &addr_size)
Definition: Address.cpp:75
Display as the load address (if resolved).
Definition: Address.h:104
void GetDescription(Stream *s, lldb::DescriptionLevel level, Target *target) const
lldb::ModuleSP GetModule() const
Get accessor for the module for this address.
Definition: Address.cpp:264
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:247
lldb::ModuleSP module_sp
The Module for a given query.
LineEntry line_entry
The LineEntry for a given query.
Definition: SBAddress.h:15
bool SectionWasDeletedPrivate() const
Definition: Address.cpp:768
ConstString GetName() const
Definition: Symbol.cpp:494
size_t Indent(const char *s=nullptr)
Indent the current line in the stream.
Definition: Stream.cpp:131
Display as the file address with the module name prepended (if any).
Definition: Address.h:99
Elide the function name; display an offset into the current function.
Definition: Address.h:115
bool ResolveAddressUsingFileSections(lldb::addr_t addr, const SectionList *sections)
Resolve a file virtual address using a section list.
Definition: Address.cpp:247
lldb::ByteOrder InlHostByteOrder()
Definition: Endian.h:25
static size_t ReadBytes(ExecutionContextScope *exe_scope, const Address &address, void *dst, size_t dst_len)
Definition: Address.cpp:60
Symbol * CalculateSymbolContextSymbol() const
Definition: Address.cpp:850
lldb::SectionSP GetSection() const
Get const accessor for the section.
Definition: Address.h:410
virtual Symtab * GetSymtab()=0
Gets the symbol table for the currently selected architecture (and object for archives).
bool operator<(const Address &lhs, const Address &rhs)
Definition: Address.cpp:942
Block * block
The Block for a given query.
llvm::Triple::ArchType GetMachine() const
Returns a machine family for the current architecture.
Definition: ArchSpec.cpp:726
virtual Symtab * GetSymtab()
uint64_t GetU64(lldb::offset_t *offset_ptr) const
Extract a uint64_t value from *offset_ptr.
An error handling class.
Definition: Status.h:44
Display as the file address (if any).
Definition: Address.h:95