LLDB  mainline
Section.cpp
Go to the documentation of this file.
1 //===-- Section.cpp -------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "lldb/Core/Section.h"
10 #include "lldb/Core/Address.h"
11 #include "lldb/Core/Module.h"
12 #include "lldb/Symbol/ObjectFile.h"
14 #include "lldb/Target/Target.h"
15 #include "lldb/Utility/FileSpec.h"
16 #include "lldb/Utility/VMRange.h"
17 
18 #include <cinttypes>
19 #include <limits>
20 #include <utility>
21 
22 namespace lldb_private {
23 class DataExtractor;
24 }
25 using namespace lldb;
26 using namespace lldb_private;
27 
28 const char *Section::GetTypeAsCString() const {
29  switch (m_type) {
31  return "invalid";
32  case eSectionTypeCode:
33  return "code";
35  return "container";
36  case eSectionTypeData:
37  return "data";
39  return "data-cstr";
41  return "data-cstr-ptr";
43  return "data-symbol-addr";
44  case eSectionTypeData4:
45  return "data-4-byte";
46  case eSectionTypeData8:
47  return "data-8-byte";
48  case eSectionTypeData16:
49  return "data-16-byte";
51  return "data-ptrs";
52  case eSectionTypeDebug:
53  return "debug";
55  return "zero-fill";
57  return "objc-message-refs";
59  return "objc-cfstrings";
61  return "dwarf-abbrev";
63  return "dwarf-abbrev-dwo";
65  return "dwarf-addr";
67  return "dwarf-aranges";
69  return "dwarf-cu-index";
71  return "dwarf-tu-index";
73  return "dwarf-frame";
75  return "dwarf-info";
77  return "dwarf-info-dwo";
79  return "dwarf-line";
81  return "dwarf-line-str";
83  return "dwarf-loc";
85  return "dwarf-loc-dwo";
87  return "dwarf-loclists";
89  return "dwarf-loclists-dwo";
91  return "dwarf-macinfo";
93  return "dwarf-macro";
95  return "dwarf-pubnames";
97  return "dwarf-pubtypes";
99  return "dwarf-ranges";
101  return "dwarf-rnglists";
103  return "dwarf-rnglists-dwo";
105  return "dwarf-str";
107  return "dwarf-str-dwo";
109  return "dwarf-str-offsets";
111  return "dwarf-str-offsets-dwo";
113  return "dwarf-types";
115  return "dwarf-types-dwo";
117  return "dwarf-names";
119  return "elf-symbol-table";
121  return "elf-dynamic-symbols";
123  return "elf-relocation-entries";
125  return "elf-dynamic-link-info";
127  return "apple-names";
129  return "apple-types";
131  return "apple-namespaces";
133  return "apple-objc";
134  case eSectionTypeEHFrame:
135  return "eh-frame";
137  return "ARM.exidx";
139  return "ARM.extab";
141  return "compact-unwind";
143  return "go-symtab";
145  return "absolute";
147  return "dwarf-gnu-debugaltlink";
148  case eSectionTypeOther:
149  return "regular";
150  }
151  return "unknown";
152 }
153 
154 Section::Section(const ModuleSP &module_sp, ObjectFile *obj_file,
155  user_id_t sect_id, ConstString name,
156  SectionType sect_type, addr_t file_addr, addr_t byte_size,
157  lldb::offset_t file_offset, lldb::offset_t file_size,
158  uint32_t log2align, uint32_t flags,
159  uint32_t target_byte_size /*=1*/)
160  : ModuleChild(module_sp), UserID(sect_id), Flags(flags),
161  m_obj_file(obj_file), m_type(sect_type), m_parent_wp(), m_name(name),
162  m_file_addr(file_addr), m_byte_size(byte_size),
163  m_file_offset(file_offset), m_file_size(file_size),
164  m_log2align(log2align), m_children(), m_fake(false), m_encrypted(false),
165  m_thread_specific(false), m_readable(false), m_writable(false),
166  m_executable(false), m_relocated(false), m_target_byte_size(target_byte_size) {
167 }
168 
169 Section::Section(const lldb::SectionSP &parent_section_sp,
170  const ModuleSP &module_sp, ObjectFile *obj_file,
171  user_id_t sect_id, ConstString name,
172  SectionType sect_type, addr_t file_addr, addr_t byte_size,
173  lldb::offset_t file_offset, lldb::offset_t file_size,
174  uint32_t log2align, uint32_t flags,
175  uint32_t target_byte_size /*=1*/)
176  : ModuleChild(module_sp), UserID(sect_id), Flags(flags),
177  m_obj_file(obj_file), m_type(sect_type), m_parent_wp(), m_name(name),
178  m_file_addr(file_addr), m_byte_size(byte_size),
179  m_file_offset(file_offset), m_file_size(file_size),
180  m_log2align(log2align), m_children(), m_fake(false), m_encrypted(false),
181  m_thread_specific(false), m_readable(false), m_writable(false),
182  m_executable(false), m_relocated(false), m_target_byte_size(target_byte_size) {
183  if (parent_section_sp)
184  m_parent_wp = parent_section_sp;
185 }
186 
187 Section::~Section() = default;
188 
190  SectionSP parent_sp(GetParent());
191  if (parent_sp) {
192  // This section has a parent which means m_file_addr is an offset into the
193  // parent section, so the file address for this section is the file address
194  // of the parent plus the offset
195  return parent_sp->GetFileAddress() + m_file_addr;
196  }
197  // This section has no parent, so m_file_addr is the file base address
198  return m_file_addr;
199 }
200 
202  SectionSP parent_sp(GetParent());
203  if (parent_sp) {
204  if (m_file_addr >= file_addr)
205  return parent_sp->SetFileAddress(m_file_addr - file_addr);
206  return false;
207  } else {
208  // This section has no parent, so m_file_addr is the file base address
209  m_file_addr = file_addr;
210  return true;
211  }
212 }
213 
215  // This section has a parent which means m_file_addr is an offset.
216  SectionSP parent_sp(GetParent());
217  if (parent_sp)
218  return m_file_addr;
219 
220  // This section has no parent, so there is no offset to be had
221  return 0;
222 }
223 
225  addr_t load_base_addr = LLDB_INVALID_ADDRESS;
226  SectionSP parent_sp(GetParent());
227  if (parent_sp) {
228  load_base_addr = parent_sp->GetLoadBaseAddress(target);
229  if (load_base_addr != LLDB_INVALID_ADDRESS)
230  load_base_addr += GetOffset();
231  }
232  if (load_base_addr == LLDB_INVALID_ADDRESS) {
233  load_base_addr = target->GetSectionLoadList().GetSectionLoadAddress(
234  const_cast<Section *>(this)->shared_from_this());
235  }
236  return load_base_addr;
237 }
238 
240  bool allow_section_end) const {
241  const size_t num_children = m_children.GetSize();
242  for (size_t i = 0; i < num_children; i++) {
243  Section *child_section = m_children.GetSectionAtIndex(i).get();
244 
245  addr_t child_offset = child_section->GetOffset();
246  if (child_offset <= offset &&
247  offset - child_offset <
248  child_section->GetByteSize() + (allow_section_end ? 1 : 0))
249  return child_section->ResolveContainedAddress(offset - child_offset,
250  so_addr, allow_section_end);
251  }
252  so_addr.SetOffset(offset);
253  so_addr.SetSection(const_cast<Section *>(this)->shared_from_this());
254 
255  // Ensure that there are no orphaned (i.e., moduleless) sections.
256  assert(GetModule().get());
257  return true;
258 }
259 
261  const addr_t file_addr = GetFileAddress();
262  if (file_addr != LLDB_INVALID_ADDRESS && !IsThreadSpecific()) {
263  if (file_addr <= vm_addr) {
264  const addr_t offset = (vm_addr - file_addr) * m_target_byte_size;
265  return offset < GetByteSize();
266  }
267  }
268  return false;
269 }
270 
271 void Section::Dump(llvm::raw_ostream &s, unsigned indent, Target *target,
272  uint32_t depth) const {
273  s.indent(indent);
274  s << llvm::format("0x%8.8" PRIx64 " %-16s ", GetID(), GetTypeAsCString());
275  bool resolved = true;
277 
278  if (GetByteSize() == 0)
279  s.indent(39);
280  else {
281  if (target)
282  addr = GetLoadBaseAddress(target);
283 
284  if (addr == LLDB_INVALID_ADDRESS) {
285  if (target)
286  resolved = false;
287  addr = GetFileAddress();
288  }
289 
290  VMRange range(addr, addr + m_byte_size);
291  range.Dump(s, 0);
292  }
293 
294  s << llvm::format("%c %c%c%c 0x%8.8" PRIx64 " 0x%8.8" PRIx64 " 0x%8.8x ",
295  resolved ? ' ' : '*', m_readable ? 'r' : '-',
296  m_writable ? 'w' : '-', m_executable ? 'x' : '-',
298 
299  DumpName(s);
300 
301  s << "\n";
302 
303  if (depth > 0)
304  m_children.Dump(s, indent, target, false, depth - 1);
305 }
306 
307 void Section::DumpName(llvm::raw_ostream &s) const {
308  SectionSP parent_sp(GetParent());
309  if (parent_sp) {
310  parent_sp->DumpName(s);
311  s << '.';
312  } else {
313  // The top most section prints the module basename
314  const char *name = nullptr;
315  ModuleSP module_sp(GetModule());
316 
317  if (m_obj_file) {
318  const FileSpec &file_spec = m_obj_file->GetFileSpec();
319  name = file_spec.GetFilename().AsCString();
320  }
321  if ((!name || !name[0]) && module_sp)
322  name = module_sp->GetFileSpec().GetFilename().AsCString();
323  if (name && name[0])
324  s << name << '.';
325  }
326  s << m_name;
327 }
328 
329 bool Section::IsDescendant(const Section *section) {
330  if (this == section)
331  return true;
332  SectionSP parent_sp(GetParent());
333  if (parent_sp)
334  return parent_sp->IsDescendant(section);
335  return false;
336 }
337 
338 bool Section::Slide(addr_t slide_amount, bool slide_children) {
340  if (slide_amount == 0)
341  return true;
342 
343  m_file_addr += slide_amount;
344 
345  if (slide_children)
346  m_children.Slide(slide_amount, slide_children);
347 
348  return true;
349  }
350  return false;
351 }
352 
353 /// Get the permissions as OR'ed bits from lldb::Permissions
355  uint32_t permissions = 0;
356  if (m_readable)
357  permissions |= ePermissionsReadable;
358  if (m_writable)
359  permissions |= ePermissionsWritable;
360  if (m_executable)
361  permissions |= ePermissionsExecutable;
362  return permissions;
363 }
364 
365 /// Set the permissions using bits OR'ed from lldb::Permissions
367  m_readable = (permissions & ePermissionsReadable) != 0;
368  m_writable = (permissions & ePermissionsWritable) != 0;
369  m_executable = (permissions & ePermissionsExecutable) != 0;
370 }
371 
373  lldb::offset_t offset) {
374  if (m_obj_file)
375  return m_obj_file->ReadSectionData(this, offset, dst, dst_len);
376  return 0;
377 }
378 
380  if (m_obj_file)
381  return m_obj_file->ReadSectionData(this, section_data);
382  return 0;
383 }
384 
386  switch (m_type) {
387  case eSectionTypeInvalid:
388  case eSectionTypeCode:
390  case eSectionTypeData:
394  case eSectionTypeData4:
395  case eSectionTypeData8:
396  case eSectionTypeData16:
405  case eSectionTypeEHFrame:
411  case eSectionTypeOther:
412  // Used for "__dof_cache" in mach-o or ".debug" for COFF which isn't debug
413  // information that we parse at all. This was causing system files with no
414  // debug info to show debug info byte sizes in the "statistics dump" output
415  // for each module. New "eSectionType" enums should be created for dedicated
416  // debug info that has a predefined format if we wish for these sections to
417  // show up as debug info.
418  case eSectionTypeDebug:
419  return false;
420 
455  return true;
456  }
457  return false;
458 }
459 
460 
461 #pragma mark SectionList
462 
464  if (this != &rhs)
465  m_sections = rhs.m_sections;
466  return *this;
467 }
468 
469 size_t SectionList::AddSection(const lldb::SectionSP &section_sp) {
470  if (section_sp) {
471  size_t section_index = m_sections.size();
472  m_sections.push_back(section_sp);
473  return section_index;
474  }
475 
476  return std::numeric_limits<size_t>::max();
477 }
478 
479 // Warning, this can be slow as it's removing items from a std::vector.
480 bool SectionList::DeleteSection(size_t idx) {
481  if (idx < m_sections.size()) {
482  m_sections.erase(m_sections.begin() + idx);
483  return true;
484  }
485  return false;
486 }
487 
489  iterator sect_iter;
490  iterator begin = m_sections.begin();
491  iterator end = m_sections.end();
492  for (sect_iter = begin; sect_iter != end; ++sect_iter) {
493  if (sect_iter->get() == sect) {
494  // The secton was already in this section list
495  return std::distance(begin, sect_iter);
496  }
497  }
498  return UINT32_MAX;
499 }
500 
501 size_t SectionList::AddUniqueSection(const lldb::SectionSP &sect_sp) {
502  size_t sect_idx = FindSectionIndex(sect_sp.get());
503  if (sect_idx == UINT32_MAX) {
504  sect_idx = AddSection(sect_sp);
505  }
506  return sect_idx;
507 }
508 
510  const lldb::SectionSP &sect_sp,
511  uint32_t depth) {
512  iterator sect_iter, end = m_sections.end();
513  for (sect_iter = m_sections.begin(); sect_iter != end; ++sect_iter) {
514  if ((*sect_iter)->GetID() == sect_id) {
515  *sect_iter = sect_sp;
516  return true;
517  } else if (depth > 0) {
518  if ((*sect_iter)
519  ->GetChildren()
520  .ReplaceSection(sect_id, sect_sp, depth - 1))
521  return true;
522  }
523  }
524  return false;
525 }
526 
528  size_t count = m_sections.size();
529  if (depth > 0) {
530  const_iterator sect_iter, end = m_sections.end();
531  for (sect_iter = m_sections.begin(); sect_iter != end; ++sect_iter) {
532  count += (*sect_iter)->GetChildren().GetNumSections(depth - 1);
533  }
534  }
535  return count;
536 }
537 
538 SectionSP SectionList::GetSectionAtIndex(size_t idx) const {
539  SectionSP sect_sp;
540  if (idx < m_sections.size())
541  sect_sp = m_sections[idx];
542  return sect_sp;
543 }
544 
545 SectionSP
547  SectionSP sect_sp;
548  // Check if we have a valid section string
549  if (section_dstr && !m_sections.empty()) {
550  const_iterator sect_iter;
551  const_iterator end = m_sections.end();
552  for (sect_iter = m_sections.begin();
553  sect_iter != end && sect_sp.get() == nullptr; ++sect_iter) {
554  Section *child_section = sect_iter->get();
555  if (child_section) {
556  if (child_section->GetName() == section_dstr) {
557  sect_sp = *sect_iter;
558  } else {
559  sect_sp =
560  child_section->GetChildren().FindSectionByName(section_dstr);
561  }
562  }
563  }
564  }
565  return sect_sp;
566 }
567 
568 SectionSP SectionList::FindSectionByID(user_id_t sect_id) const {
569  SectionSP sect_sp;
570  if (sect_id) {
571  const_iterator sect_iter;
572  const_iterator end = m_sections.end();
573  for (sect_iter = m_sections.begin();
574  sect_iter != end && sect_sp.get() == nullptr; ++sect_iter) {
575  if ((*sect_iter)->GetID() == sect_id) {
576  sect_sp = *sect_iter;
577  break;
578  } else {
579  sect_sp = (*sect_iter)->GetChildren().FindSectionByID(sect_id);
580  }
581  }
582  }
583  return sect_sp;
584 }
585 
587  bool check_children,
588  size_t start_idx) const {
589  SectionSP sect_sp;
590  size_t num_sections = m_sections.size();
591  for (size_t idx = start_idx; idx < num_sections; ++idx) {
592  if (m_sections[idx]->GetType() == sect_type) {
593  sect_sp = m_sections[idx];
594  break;
595  } else if (check_children) {
596  sect_sp = m_sections[idx]->GetChildren().FindSectionByType(
597  sect_type, check_children, 0);
598  if (sect_sp)
599  break;
600  }
601  }
602  return sect_sp;
603 }
604 
606  uint32_t depth) const {
607  SectionSP sect_sp;
608  const_iterator sect_iter;
609  const_iterator end = m_sections.end();
610  for (sect_iter = m_sections.begin();
611  sect_iter != end && sect_sp.get() == nullptr; ++sect_iter) {
612  Section *sect = sect_iter->get();
613  if (sect->ContainsFileAddress(vm_addr)) {
614  // The file address is in this section. We need to make sure one of our
615  // child sections doesn't contain this address as well as obeying the
616  // depth limit that was passed in.
617  if (depth > 0)
619  vm_addr, depth - 1);
620 
621  if (sect_sp.get() == nullptr && !sect->IsFake())
622  sect_sp = *sect_iter;
623  }
624  }
625  return sect_sp;
626 }
627 
629  return FindSectionByID(sect_id).get() != nullptr;
630 }
631 
632 void SectionList::Dump(llvm::raw_ostream &s, unsigned indent, Target *target,
633  bool show_header, uint32_t depth) const {
634  bool target_has_loaded_sections =
635  target && !target->GetSectionLoadList().IsEmpty();
636  if (show_header && !m_sections.empty()) {
637  s.indent(indent);
638  s << llvm::formatv(
639  "SectID Type {0} Address "
640  " Perm File Off. File Size Flags "
641  " Section Name\n",
642  target_has_loaded_sections ? "Load" : "File");
643  s.indent(indent);
644  s << "---------- ---------------- "
645  "--------------------------------------- ---- ---------- "
646  "---------- "
647  "---------- ----------------------------\n";
648  }
649 
650  for (const auto &section_sp : m_sections)
651  section_sp->Dump(s, indent, target_has_loaded_sections ? target : nullptr,
652  depth);
653 }
654 
655 size_t SectionList::Slide(addr_t slide_amount, bool slide_children) {
656  size_t count = 0;
657  const_iterator pos, end = m_sections.end();
658  for (pos = m_sections.begin(); pos != end; ++pos) {
659  if ((*pos)->Slide(slide_amount, slide_children))
660  ++count;
661  }
662  return count;
663 }
664 
666  uint64_t debug_info_size = 0;
667  for (const auto &section : m_sections) {
668  const SectionList &sub_sections = section->GetChildren();
669  if (sub_sections.GetSize() > 0)
670  debug_info_size += sub_sections.GetDebugInfoSize();
671  else if (section->ContainsOnlyDebugInfo())
672  debug_info_size += section->GetFileSize();
673  }
674  return debug_info_size;
675 }
lldb_private::SectionList::ReplaceSection
bool ReplaceSection(lldb::user_id_t sect_id, const lldb::SectionSP &section_sp, uint32_t depth=UINT32_MAX)
Definition: Section.cpp:509
lldb::eSectionTypeDWARFDebugLoc
@ eSectionTypeDWARFDebugLoc
Definition: lldb-enumerations.h:676
lldb_private::SectionList::FindSectionContainingFileAddress
lldb::SectionSP FindSectionContainingFileAddress(lldb::addr_t addr, uint32_t depth=UINT32_MAX) const
Definition: Section.cpp:605
lldb::eSectionTypeData8
@ eSectionTypeData8
Definition: lldb-enumerations.h:661
lldb::eSectionTypeDWARFDebugRngListsDwo
@ eSectionTypeDWARFDebugRngListsDwo
Definition: lldb-enumerations.h:712
lldb_private::SectionList::FindSectionByName
lldb::SectionSP FindSectionByName(ConstString section_dstr) const
Definition: Section.cpp:546
lldb::eSectionTypeDWARFAppleNamespaces
@ eSectionTypeDWARFAppleNamespaces
Definition: lldb-enumerations.h:686
lldb::eSectionTypeDWARFAppleObjC
@ eSectionTypeDWARFAppleObjC
Definition: lldb-enumerations.h:687
lldb::eSectionTypeDebug
@ eSectionTypeDebug
Definition: lldb-enumerations.h:664
lldb_private::SectionList::begin
const_iterator begin() const
Definition: Section.h:40
lldb_private::ObjectFile::GetFileSpec
virtual FileSpec & GetFileSpec()
Get accessor to the object file specification.
Definition: ObjectFile.h:292
lldb_private::ModuleChild
Definition: ModuleChild.h:19
lldb_private::SectionList::Dump
void Dump(llvm::raw_ostream &s, unsigned indent, Target *target, bool show_header, uint32_t depth) const
Definition: Section.cpp:632
lldb_private::Section::m_name
ConstString m_name
Definition: Section.h:257
lldb::eSectionTypeData16
@ eSectionTypeData16
Definition: lldb-enumerations.h:662
lldb::eSectionTypeDataCStringPointers
@ eSectionTypeDataCStringPointers
Pointers to C string data.
Definition: lldb-enumerations.h:658
lldb::eSectionTypeDataPointers
@ eSectionTypeDataPointers
Definition: lldb-enumerations.h:663
lldb_private::Section::m_executable
bool m_executable
Definition: Section.h:278
lldb::eSectionTypeDWARFDebugAranges
@ eSectionTypeDWARFDebugAranges
Definition: lldb-enumerations.h:671
lldb_private::UserID
Definition: UserID.h:31
lldb_private::SectionList::GetSize
size_t GetSize() const
Definition: Section.h:74
lldb::eSectionTypeELFSymbolTable
@ eSectionTypeELFSymbolTable
Elf SHT_SYMTAB section.
Definition: lldb-enumerations.h:688
lldb::eSectionTypeDWARFDebugStrOffsetsDwo
@ eSectionTypeDWARFDebugStrOffsetsDwo
Definition: lldb-enumerations.h:710
lldb::eSectionTypeDWARFDebugRanges
@ eSectionTypeDWARFDebugRanges
Definition: lldb-enumerations.h:681
lldb::eSectionTypeDWARFDebugMacro
@ eSectionTypeDWARFDebugMacro
Definition: lldb-enumerations.h:678
lldb::eSectionTypeDWARFDebugInfoDwo
@ eSectionTypeDWARFDebugInfoDwo
Definition: lldb-enumerations.h:708
lldb::eSectionTypeDWARFDebugFrame
@ eSectionTypeDWARFDebugFrame
Definition: lldb-enumerations.h:673
Module.h
lldb_private::SectionList::ContainsSection
bool ContainsSection(lldb::user_id_t sect_id) const
Definition: Section.cpp:628
lldb::eSectionTypeDWARFDebugLine
@ eSectionTypeDWARFDebugLine
Definition: lldb-enumerations.h:675
lldb::eSectionTypeDWARFDebugAbbrevDwo
@ eSectionTypeDWARFDebugAbbrevDwo
Definition: lldb-enumerations.h:707
lldb_private::Flags
Definition: Flags.h:22
lldb_private::SectionList::Slide
size_t Slide(lldb::addr_t slide_amount, bool slide_children)
Definition: Section.cpp:655
lldb_private::ObjectFile::ReadSectionData
virtual size_t ReadSectionData(Section *section, lldb::offset_t section_offset, void *dst, size_t dst_len)
Definition: ObjectFile.cpp:474
lldb::eSectionTypeDWARFDebugAddr
@ eSectionTypeDWARFDebugAddr
Definition: lldb-enumerations.h:670
SectionLoadList.h
lldb_private::ConstString::AsCString
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:193
lldb_private::Section::Dump
void Dump(llvm::raw_ostream &s, unsigned indent, Target *target, uint32_t depth) const
Definition: Section.cpp:271
lldb_private::SectionList
Definition: Section.h:34
lldb_private::Section::m_file_offset
lldb::offset_t m_file_offset
Definition: Section.h:263
lldb::offset_t
uint64_t offset_t
Definition: lldb-types.h:87
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::Section::IsDescendant
bool IsDescendant(const Section *section)
Definition: Section.cpp:329
lldb_private::Section::DumpName
void DumpName(llvm::raw_ostream &s) const
Definition: Section.cpp:307
lldb::eSectionTypeDWARFDebugStrOffsets
@ eSectionTypeDWARFDebugStrOffsets
Definition: lldb-enumerations.h:683
lldb_private::SectionList::GetNumSections
size_t GetNumSections(uint32_t depth) const
Definition: Section.cpp:527
lldb_private::Target
Definition: Target.h:473
Section.h
lldb_private::Section::GetParent
lldb::SectionSP GetParent() const
Definition: Section.h:184
lldb_private::Section::m_file_size
lldb::offset_t m_file_size
Definition: Section.h:264
lldb_private::Section::m_file_addr
lldb::addr_t m_file_addr
Definition: Section.h:258
lldb_private::Section::ContainsOnlyDebugInfo
bool ContainsOnlyDebugInfo() const
Returns true if this section contains debug information.
Definition: Section.cpp:385
lldb_private::Section::GetTypeAsCString
const char * GetTypeAsCString() const
Definition: Section.cpp:28
Target.h
lldb_private::SectionList::AddSection
size_t AddSection(const lldb::SectionSP &section_sp)
Definition: Section.cpp:469
lldb_private::SectionList::end
const_iterator end() const
Definition: Section.h:41
lldb_private::Section::GetFileAddress
lldb::addr_t GetFileAddress() const
Definition: Section.cpp:189
lldb::eSectionTypeELFRelocationEntries
@ eSectionTypeELFRelocationEntries
Elf SHT_REL or SHT_REL section.
Definition: lldb-enumerations.h:690
lldb::eSectionTypeDWARFDebugLocDwo
@ eSectionTypeDWARFDebugLocDwo
Definition: lldb-enumerations.h:713
lldb_private::FileSpec
Definition: FileSpec.h:56
lldb_private::Section::m_obj_file
ObjectFile * m_obj_file
Definition: Section.h:253
lldb::eSectionTypeDataObjCMessageRefs
@ eSectionTypeDataObjCMessageRefs
Pointer to function pointer + selector.
Definition: lldb-enumerations.h:666
lldb_private::SectionLoadList::GetSectionLoadAddress
lldb::addr_t GetSectionLoadAddress(const lldb::SectionSP &section_sp) const
Definition: SectionLoadList.cpp:50
lldb::eSectionTypeDWARFDebugLocListsDwo
@ eSectionTypeDWARFDebugLocListsDwo
Definition: lldb-enumerations.h:714
lldb_private::SectionList::operator=
SectionList & operator=(const SectionList &rhs)
Definition: Section.cpp:463
lldb_private::Section::SetFileAddress
bool SetFileAddress(lldb::addr_t file_addr)
Definition: Section.cpp:201
lldb::eSectionTypeDWARFDebugAbbrev
@ eSectionTypeDWARFDebugAbbrev
Definition: lldb-enumerations.h:669
lldb::eSectionTypeCompactUnwind
@ eSectionTypeCompactUnwind
compact unwind section in Mach-O, __TEXT,__unwind_info
Definition: lldb-enumerations.h:695
lldb_private::VMRange::Dump
void Dump(llvm::raw_ostream &s, lldb::addr_t base_addr=0, uint32_t addr_width=8) const
Definition: VMRange.cpp:36
lldb_private::DataExtractor
Definition: DataExtractor.h:48
lldb_private::Section::Section
Section(const lldb::ModuleSP &module_sp, ObjectFile *obj_file, lldb::user_id_t sect_id, ConstString name, lldb::SectionType sect_type, lldb::addr_t file_vm_addr, lldb::addr_t vm_size, lldb::offset_t file_offset, lldb::offset_t file_size, uint32_t log2align, uint32_t flags, uint32_t target_byte_size=1)
lldb::eSectionTypeDataSymbolAddress
@ eSectionTypeDataSymbolAddress
Address of a symbol in the symbol table.
Definition: lldb-enumerations.h:659
lldb::eSectionTypeDataObjCCFStrings
@ eSectionTypeDataObjCCFStrings
Objective-C const CFString/NSString objects.
Definition: lldb-enumerations.h:667
lldb::eSectionTypeDWARFDebugStr
@ eSectionTypeDWARFDebugStr
Definition: lldb-enumerations.h:682
lldb_private::Address::SetSection
void SetSection(const lldb::SectionSP &section_sp)
Set accessor for the section.
Definition: Address.h:463
lldb_private::Section::GetChildren
SectionList & GetChildren()
Definition: Section.h:132
lldb_private::Section::Slide
bool Slide(lldb::addr_t slide_amount, bool slide_children)
Definition: Section.cpp:338
lldb_private::SectionList::GetDebugInfoSize
uint64_t GetDebugInfoSize() const
Get the debug information size from all sections that contain debug information.
Definition: Section.cpp:665
lldb_private::Section::IsThreadSpecific
bool IsThreadSpecific() const
Definition: Section.h:186
lldb_private::SectionList::FindSectionIndex
size_t FindSectionIndex(const Section *sect)
Definition: Section.cpp:488
lldb_private::Section::m_writable
bool m_writable
Definition: Section.h:277
lldb_private::Section::IsFake
bool IsFake() const
Definition: Section.h:166
lldb_private::ConstString
Definition: ConstString.h:40
lldb_private::Section::GetName
ConstString GetName() const
Definition: Section.h:176
lldb::eSectionTypeDWARFDebugInfo
@ eSectionTypeDWARFDebugInfo
Definition: lldb-enumerations.h:674
lldb_private::Section::m_type
lldb::SectionType m_type
Definition: Section.h:255
lldb_private::Section::GetOffset
lldb::addr_t GetOffset() const
Definition: Section.cpp:214
lldb::eSectionTypeDWARFDebugTypes
@ eSectionTypeDWARFDebugTypes
DWARF .debug_types section.
Definition: lldb-enumerations.h:701
lldb_private::SectionList::GetSectionAtIndex
lldb::SectionSP GetSectionAtIndex(size_t idx) const
Definition: Section.cpp:538
lldb::eSectionTypeZeroFill
@ eSectionTypeZeroFill
Definition: lldb-enumerations.h:665
lldb::eSectionTypeDWARFAppleTypes
@ eSectionTypeDWARFAppleTypes
Definition: lldb-enumerations.h:685
lldb::eSectionTypeDWARFAppleNames
@ eSectionTypeDWARFAppleNames
Definition: lldb-enumerations.h:684
lldb::eSectionTypeDWARFGNUDebugAltLink
@ eSectionTypeDWARFGNUDebugAltLink
Definition: lldb-enumerations.h:700
lldb::eSectionTypeELFDynamicSymbols
@ eSectionTypeELFDynamicSymbols
Elf SHT_DYNSYM section.
Definition: lldb-enumerations.h:689
lldb_private::Section::GetLoadBaseAddress
lldb::addr_t GetLoadBaseAddress(Target *target) const
Definition: Section.cpp:224
lldb_private::Section::SetPermissions
void SetPermissions(uint32_t permissions)
Set the permissions using bits OR'ed from lldb::Permissions.
Definition: Section.cpp:366
lldb::eSectionTypeAbsoluteAddress
@ eSectionTypeAbsoluteAddress
Dummy section for symbols with absolute address.
Definition: lldb-enumerations.h:698
Address.h
lldb::eSectionTypeDWARFDebugCuIndex
@ eSectionTypeDWARFDebugCuIndex
Definition: lldb-enumerations.h:672
lldb_private::SectionList::DeleteSection
bool DeleteSection(size_t idx)
Definition: Section.cpp:480
lldb_private::Section::m_byte_size
lldb::addr_t m_byte_size
Definition: Section.h:261
lldb_private::Section::m_parent_wp
lldb::SectionWP m_parent_wp
Definition: Section.h:256
lldb::eSectionTypeData
@ eSectionTypeData
Definition: lldb-enumerations.h:656
ObjectFile.h
lldb_private::UserID::GetID
lldb::user_id_t GetID() const
Get accessor for the user ID.
Definition: UserID.h:47
lldb_private::Section
Definition: Section.h:102
lldb::eSectionTypeDWARFDebugTuIndex
@ eSectionTypeDWARFDebugTuIndex
Definition: lldb-enumerations.h:715
lldb::eSectionTypeData4
@ eSectionTypeData4
Definition: lldb-enumerations.h:660
lldb::eSectionTypeOther
@ eSectionTypeOther
Definition: lldb-enumerations.h:703
lldb::eSectionTypeCode
@ eSectionTypeCode
Definition: lldb-enumerations.h:654
lldb_private::SectionLoadList::IsEmpty
bool IsEmpty() const
Definition: SectionLoadList.cpp:38
lldb_private::SectionList::FindSectionByType
lldb::SectionSP FindSectionByType(lldb::SectionType sect_type, bool check_children, size_t start_idx=0) const
Definition: Section.cpp:586
lldb_private::Section::GetByteSize
lldb::addr_t GetByteSize() const
Definition: Section.h:162
lldb::eSectionTypeContainer
@ eSectionTypeContainer
The section contains child sections.
Definition: lldb-enumerations.h:655
lldb::eSectionTypeEHFrame
@ eSectionTypeEHFrame
Definition: lldb-enumerations.h:692
lldb::eSectionTypeELFDynamicLinkInfo
@ eSectionTypeELFDynamicLinkInfo
Elf SHT_DYNAMIC section.
Definition: lldb-enumerations.h:691
uint32_t
lldb_private::Section::m_children
SectionList m_children
Definition: Section.h:268
lldb::SectionType
SectionType
Definition: lldb-enumerations.h:652
lldb_private::Flags::Get
ValueType Get() const
Get accessor for all flags.
Definition: Flags.h:40
lldb::eSectionTypeDWARFDebugStrDwo
@ eSectionTypeDWARFDebugStrDwo
Definition: lldb-enumerations.h:709
lldb_private::Address
Definition: Address.h:59
lldb_private::Section::m_target_byte_size
uint32_t m_target_byte_size
Definition: Section.h:280
lldb::eSectionTypeDWARFDebugPubTypes
@ eSectionTypeDWARFDebugPubTypes
Definition: lldb-enumerations.h:680
lldb::eSectionTypeDWARFDebugNames
@ eSectionTypeDWARFDebugNames
DWARF v5 .debug_names.
Definition: lldb-enumerations.h:702
lldb_private::SectionList::const_iterator
collection::const_iterator const_iterator
Definition: Section.h:38
lldb_private::Section::~Section
~Section()
VMRange.h
lldb::eSectionTypeARMextab
@ eSectionTypeARMextab
Definition: lldb-enumerations.h:694
lldb::eSectionTypeDWARFDebugPubNames
@ eSectionTypeDWARFDebugPubNames
Definition: lldb-enumerations.h:679
lldb::eSectionTypeInvalid
@ eSectionTypeInvalid
Definition: lldb-enumerations.h:653
lldb::eSectionTypeDataCString
@ eSectionTypeDataCString
Inlined C string data.
Definition: lldb-enumerations.h:657
UINT32_MAX
#define UINT32_MAX
Definition: lldb-defines.h:19
lldb_private::ModuleChild::GetModule
lldb::ModuleSP GetModule() const
Get const accessor for the module pointer.
Definition: ModuleChild.cpp:24
lldb_private::SectionList::m_sections
collection m_sections
Definition: Section.h:99
lldb::eSectionTypeDWARFDebugLineStr
@ eSectionTypeDWARFDebugLineStr
DWARF v5 .debug_line_str.
Definition: lldb-enumerations.h:704
lldb_private::Address::SetOffset
bool SetOffset(lldb::addr_t offset)
Set accessor for the offset.
Definition: Address.h:438
lldb_private::Target::GetSectionLoadList
SectionLoadList & GetSectionLoadList()
Definition: Target.h:1097
LLDB_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:74
lldb::user_id_t
uint64_t user_id_t
Definition: lldb-types.h:84
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::Section::ResolveContainedAddress
bool ResolveContainedAddress(lldb::addr_t offset, Address &so_addr, bool allow_section_end=false) const
Definition: Section.cpp:239
FileSpec.h
lldb::eSectionTypeDWARFDebugMacInfo
@ eSectionTypeDWARFDebugMacInfo
Definition: lldb-enumerations.h:677
lldb_private::SectionList::AddUniqueSection
size_t AddUniqueSection(const lldb::SectionSP &section_sp)
Definition: Section.cpp:501
lldb::eSectionTypeARMexidx
@ eSectionTypeARMexidx
Definition: lldb-enumerations.h:693
lldb_private::Section::ContainsFileAddress
bool ContainsFileAddress(lldb::addr_t vm_addr) const
Definition: Section.cpp:260
lldb::eSectionTypeDWARFDebugTypesDwo
@ eSectionTypeDWARFDebugTypesDwo
Definition: lldb-enumerations.h:711
lldb_private::SectionList::iterator
collection::iterator iterator
Definition: Section.h:37
lldb
Definition: SBAddress.h:15
lldb_private::FileSpec::GetFilename
ConstString & GetFilename()
Filename string get accessor.
Definition: FileSpec.cpp:340
lldb::eSectionTypeDWARFDebugLocLists
@ eSectionTypeDWARFDebugLocLists
DWARF v5 .debug_loclists.
Definition: lldb-enumerations.h:706
lldb::eSectionTypeGoSymtab
@ eSectionTypeGoSymtab
Definition: lldb-enumerations.h:697
lldb_private::Section::m_readable
bool m_readable
Definition: Section.h:276
lldb_private::ObjectFile
Definition: ObjectFile.h:60
lldb_private::Section::GetSectionData
lldb::offset_t GetSectionData(void *dst, lldb::offset_t dst_len, lldb::offset_t offset=0)
Read the section data from the object file that the section resides in.
Definition: Section.cpp:372
lldb_private::SectionList::FindSectionByID
lldb::SectionSP FindSectionByID(lldb::user_id_t sect_id) const
Definition: Section.cpp:568
lldb_private::Section::GetPermissions
uint32_t GetPermissions() const
Get the permissions as OR'ed bits from lldb::Permissions.
Definition: Section.cpp:354
lldb_private::VMRange
Definition: VMRange.h:23
lldb::eSectionTypeDWARFDebugRngLists
@ eSectionTypeDWARFDebugRngLists
DWARF v5 .debug_rnglists.
Definition: lldb-enumerations.h:705