1 //===-- Section.h -----------------------------------------------*- 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 #ifndef LLDB_CORE_SECTION_H 10 #define LLDB_CORE_SECTION_H 11 12 #include "lldb/Core/ModuleChild.h" 13 #include "lldb/Utility/ConstString.h" 14 #include "lldb/Utility/Flags.h" 15 #include "lldb/Utility/UserID.h" 16 #include "lldb/lldb-defines.h" 17 #include "lldb/lldb-enumerations.h" 18 #include "lldb/lldb-forward.h" 19 #include "lldb/lldb-types.h" 20 21 #include <memory> 22 #include <vector> 23 24 #include <stddef.h> 25 #include <stdint.h> 26 27 namespace lldb_private { 28 class Address; 29 class DataExtractor; 30 class ObjectFile; 31 class Section; 32 class Target; 33 34 class SectionList { 35 public: 36 typedef std::vector<lldb::SectionSP> collection; 37 typedef collection::iterator iterator; 38 typedef collection::const_iterator const_iterator; 39 begin()40 const_iterator begin() const { return m_sections.begin(); } end()41 const_iterator end() const { return m_sections.end(); } begin()42 const_iterator begin() { return m_sections.begin(); } end()43 const_iterator end() { return m_sections.end(); } 44 45 /// Create an empty list. 46 SectionList() = default; 47 48 SectionList &operator=(const SectionList &rhs); 49 50 size_t AddSection(const lldb::SectionSP §ion_sp); 51 52 size_t AddUniqueSection(const lldb::SectionSP §ion_sp); 53 54 size_t FindSectionIndex(const Section *sect); 55 56 bool ContainsSection(lldb::user_id_t sect_id) const; 57 58 void Dump(llvm::raw_ostream &s, unsigned indent, Target *target, 59 bool show_header, uint32_t depth) const; 60 61 lldb::SectionSP FindSectionByName(ConstString section_dstr) const; 62 63 lldb::SectionSP FindSectionByID(lldb::user_id_t sect_id) const; 64 65 lldb::SectionSP FindSectionByType(lldb::SectionType sect_type, 66 bool check_children, 67 size_t start_idx = 0) const; 68 69 lldb::SectionSP 70 FindSectionContainingFileAddress(lldb::addr_t addr, 71 uint32_t depth = UINT32_MAX) const; 72 73 // Get the number of sections in this list only GetSize()74 size_t GetSize() const { return m_sections.size(); } 75 76 // Get the number of sections in this list, and any contained child sections 77 size_t GetNumSections(uint32_t depth) const; 78 79 bool ReplaceSection(lldb::user_id_t sect_id, 80 const lldb::SectionSP §ion_sp, 81 uint32_t depth = UINT32_MAX); 82 83 // Warning, this can be slow as it's removing items from a std::vector. 84 bool DeleteSection(size_t idx); 85 86 lldb::SectionSP GetSectionAtIndex(size_t idx) const; 87 88 size_t Slide(lldb::addr_t slide_amount, bool slide_children); 89 Clear()90 void Clear() { m_sections.clear(); } 91 92 protected: 93 collection m_sections; 94 }; 95 96 class Section : public std::enable_shared_from_this<Section>, 97 public ModuleChild, 98 public UserID, 99 public Flags { 100 public: 101 // Create a root section (one that has no parent) 102 Section(const lldb::ModuleSP &module_sp, ObjectFile *obj_file, 103 lldb::user_id_t sect_id, ConstString name, 104 lldb::SectionType sect_type, lldb::addr_t file_vm_addr, 105 lldb::addr_t vm_size, lldb::offset_t file_offset, 106 lldb::offset_t file_size, uint32_t log2align, uint32_t flags, 107 uint32_t target_byte_size = 1); 108 109 // Create a section that is a child of parent_section_sp 110 Section(const lldb::SectionSP &parent_section_sp, // NULL for top level 111 // sections, non-NULL for 112 // child sections 113 const lldb::ModuleSP &module_sp, ObjectFile *obj_file, 114 lldb::user_id_t sect_id, ConstString name, 115 lldb::SectionType sect_type, lldb::addr_t file_vm_addr, 116 lldb::addr_t vm_size, lldb::offset_t file_offset, 117 lldb::offset_t file_size, uint32_t log2align, uint32_t flags, 118 uint32_t target_byte_size = 1); 119 120 ~Section(); 121 122 static int Compare(const Section &a, const Section &b); 123 124 bool ContainsFileAddress(lldb::addr_t vm_addr) const; 125 GetChildren()126 SectionList &GetChildren() { return m_children; } 127 GetChildren()128 const SectionList &GetChildren() const { return m_children; } 129 130 void Dump(llvm::raw_ostream &s, unsigned indent, Target *target, 131 uint32_t depth) const; 132 133 void DumpName(llvm::raw_ostream &s) const; 134 135 lldb::addr_t GetLoadBaseAddress(Target *target) const; 136 137 bool ResolveContainedAddress(lldb::addr_t offset, Address &so_addr, 138 bool allow_section_end = false) const; 139 GetFileOffset()140 lldb::offset_t GetFileOffset() const { return m_file_offset; } 141 SetFileOffset(lldb::offset_t file_offset)142 void SetFileOffset(lldb::offset_t file_offset) { 143 m_file_offset = file_offset; 144 } 145 GetFileSize()146 lldb::offset_t GetFileSize() const { return m_file_size; } 147 SetFileSize(lldb::offset_t file_size)148 void SetFileSize(lldb::offset_t file_size) { m_file_size = file_size; } 149 150 lldb::addr_t GetFileAddress() const; 151 152 bool SetFileAddress(lldb::addr_t file_addr); 153 154 lldb::addr_t GetOffset() const; 155 GetByteSize()156 lldb::addr_t GetByteSize() const { return m_byte_size; } 157 SetByteSize(lldb::addr_t byte_size)158 void SetByteSize(lldb::addr_t byte_size) { m_byte_size = byte_size; } 159 IsFake()160 bool IsFake() const { return m_fake; } 161 SetIsFake(bool fake)162 void SetIsFake(bool fake) { m_fake = fake; } 163 IsEncrypted()164 bool IsEncrypted() const { return m_encrypted; } 165 SetIsEncrypted(bool b)166 void SetIsEncrypted(bool b) { m_encrypted = b; } 167 168 bool IsDescendant(const Section *section); 169 GetName()170 ConstString GetName() const { return m_name; } 171 172 bool Slide(lldb::addr_t slide_amount, bool slide_children); 173 GetType()174 lldb::SectionType GetType() const { return m_type; } 175 176 const char *GetTypeAsCString() const; 177 GetParent()178 lldb::SectionSP GetParent() const { return m_parent_wp.lock(); } 179 IsThreadSpecific()180 bool IsThreadSpecific() const { return m_thread_specific; } 181 SetIsThreadSpecific(bool b)182 void SetIsThreadSpecific(bool b) { m_thread_specific = b; } 183 184 /// Get the permissions as OR'ed bits from lldb::Permissions 185 uint32_t GetPermissions() const; 186 187 /// Set the permissions using bits OR'ed from lldb::Permissions 188 void SetPermissions(uint32_t permissions); 189 GetObjectFile()190 ObjectFile *GetObjectFile() { return m_obj_file; } GetObjectFile()191 const ObjectFile *GetObjectFile() const { return m_obj_file; } 192 193 /// Read the section data from the object file that the section 194 /// resides in. 195 /// 196 /// \param[in] dst 197 /// Where to place the data 198 /// 199 /// \param[in] dst_len 200 /// How many bytes of section data to read 201 /// 202 /// \param[in] offset 203 /// The offset in bytes within this section's data at which to 204 /// start copying data from. 205 /// 206 /// \return 207 /// The number of bytes read from the section, or zero if the 208 /// section has no data or \a offset is not a valid offset 209 /// in this section. 210 lldb::offset_t GetSectionData(void *dst, lldb::offset_t dst_len, 211 lldb::offset_t offset = 0); 212 213 /// Get the shared reference to the section data from the object 214 /// file that the section resides in. No copies of the data will be 215 /// make unless the object file has been read from memory. If the 216 /// object file is on disk, it will shared the mmap data for the 217 /// entire object file. 218 /// 219 /// \param[in] data 220 /// Where to place the data, address byte size, and byte order 221 /// 222 /// \return 223 /// The number of bytes read from the section, or zero if the 224 /// section has no data or \a offset is not a valid offset 225 /// in this section. 226 lldb::offset_t GetSectionData(DataExtractor &data); 227 GetLog2Align()228 uint32_t GetLog2Align() { return m_log2align; } 229 SetLog2Align(uint32_t align)230 void SetLog2Align(uint32_t align) { m_log2align = align; } 231 232 // Get the number of host bytes required to hold a target byte GetTargetByteSize()233 uint32_t GetTargetByteSize() const { return m_target_byte_size; } 234 IsRelocated()235 bool IsRelocated() const { return m_relocated; } 236 SetIsRelocated(bool b)237 void SetIsRelocated(bool b) { m_relocated = b; } 238 239 protected: 240 ObjectFile *m_obj_file; // The object file that data for this section should 241 // be read from 242 lldb::SectionType m_type; // The type of this section 243 lldb::SectionWP m_parent_wp; // Weak pointer to parent section 244 ConstString m_name; // Name of this section 245 lldb::addr_t m_file_addr; // The absolute file virtual address range of this 246 // section if m_parent == NULL, 247 // offset from parent file virtual address if m_parent != NULL 248 lldb::addr_t m_byte_size; // Size in bytes that this section will occupy in 249 // memory at runtime 250 lldb::offset_t m_file_offset; // Object file offset (if any) 251 lldb::offset_t m_file_size; // Object file size (can be smaller than 252 // m_byte_size for zero filled sections...) 253 uint32_t m_log2align; // log_2(align) of the section (i.e. section has to be 254 // aligned to 2^m_log2align) 255 SectionList m_children; // Child sections 256 bool m_fake : 1, // If true, then this section only can contain the address if 257 // one of its 258 // children contains an address. This allows for gaps between the 259 // children that are contained in the address range for this section, but 260 // do not produce hits unless the children contain the address. 261 m_encrypted : 1, // Set to true if the contents are encrypted 262 m_thread_specific : 1, // This section is thread specific 263 m_readable : 1, // If this section has read permissions 264 m_writable : 1, // If this section has write permissions 265 m_executable : 1, // If this section has executable permissions 266 m_relocated : 1; // If this section has had relocations applied 267 uint32_t m_target_byte_size; // Some architectures have non-8-bit byte size. 268 // This is specified as 269 // as a multiple number of a host bytes 270 private: 271 Section(const Section &) = delete; 272 const Section &operator=(const Section &) = delete; 273 }; 274 275 } // namespace lldb_private 276 277 #endif // LLDB_CORE_SECTION_H 278