1 //===-- ObjectFileELF.h --------------------------------------- -*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #ifndef liblldb_ObjectFileELF_h_
11 #define liblldb_ObjectFileELF_h_
12 
13 // C Includes
14 #include <stdint.h>
15 
16 // C++ Includes
17 #include <vector>
18 
19 #include "lldb/Symbol/ObjectFile.h"
20 #include "lldb/Utility/ArchSpec.h"
21 #include "lldb/Utility/FileSpec.h"
22 #include "lldb/Utility/UUID.h"
23 #include "lldb/lldb-private.h"
24 
25 #include "ELFHeader.h"
26 
27 struct ELFNote {
28   elf::elf_word n_namesz;
29   elf::elf_word n_descsz;
30   elf::elf_word n_type;
31 
32   std::string n_name;
33 
34   ELFNote() : n_namesz(0), n_descsz(0), n_type(0) {}
35 
36   /// Parse an ELFNote entry from the given DataExtractor starting at position
37   /// \p offset.
38   ///
39   /// @param[in] data
40   ///    The DataExtractor to read from.
41   ///
42   /// @param[in,out] offset
43   ///    Pointer to an offset in the data.  On return the offset will be
44   ///    advanced by the number of bytes read.
45   ///
46   /// @return
47   ///    True if the ELFRel entry was successfully read and false otherwise.
48   bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset);
49 
50   size_t GetByteSize() const {
51     return 12 + llvm::alignTo(n_namesz, 4) + llvm::alignTo(n_descsz, 4);
52   }
53 };
54 
55 //------------------------------------------------------------------------------
56 /// @class ObjectFileELF
57 /// Generic ELF object file reader.
58 ///
59 /// This class provides a generic ELF (32/64 bit) reader plugin implementing
60 /// the ObjectFile protocol.
61 class ObjectFileELF : public lldb_private::ObjectFile {
62 public:
63   ~ObjectFileELF() override;
64 
65   //------------------------------------------------------------------
66   // Static Functions
67   //------------------------------------------------------------------
68   static void Initialize();
69 
70   static void Terminate();
71 
72   static lldb_private::ConstString GetPluginNameStatic();
73 
74   static const char *GetPluginDescriptionStatic();
75 
76   static lldb_private::ObjectFile *
77   CreateInstance(const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
78                  lldb::offset_t data_offset, const lldb_private::FileSpec *file,
79                  lldb::offset_t file_offset, lldb::offset_t length);
80 
81   static lldb_private::ObjectFile *CreateMemoryInstance(
82       const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
83       const lldb::ProcessSP &process_sp, lldb::addr_t header_addr);
84 
85   static size_t GetModuleSpecifications(const lldb_private::FileSpec &file,
86                                         lldb::DataBufferSP &data_sp,
87                                         lldb::offset_t data_offset,
88                                         lldb::offset_t file_offset,
89                                         lldb::offset_t length,
90                                         lldb_private::ModuleSpecList &specs);
91 
92   static bool MagicBytesMatch(lldb::DataBufferSP &data_sp, lldb::addr_t offset,
93                               lldb::addr_t length);
94 
95   //------------------------------------------------------------------
96   // PluginInterface protocol
97   //------------------------------------------------------------------
98   lldb_private::ConstString GetPluginName() override;
99 
100   uint32_t GetPluginVersion() override;
101 
102   //------------------------------------------------------------------
103   // ObjectFile Protocol.
104   //------------------------------------------------------------------
105   bool ParseHeader() override;
106 
107   bool SetLoadAddress(lldb_private::Target &target, lldb::addr_t value,
108                       bool value_is_offset) override;
109 
110   lldb::ByteOrder GetByteOrder() const override;
111 
112   bool IsExecutable() const override;
113 
114   uint32_t GetAddressByteSize() const override;
115 
116   lldb_private::AddressClass GetAddressClass(lldb::addr_t file_addr) override;
117 
118   lldb_private::Symtab *GetSymtab() override;
119 
120   bool IsStripped() override;
121 
122   void CreateSections(lldb_private::SectionList &unified_section_list) override;
123 
124   void Dump(lldb_private::Stream *s) override;
125 
126   bool GetArchitecture(lldb_private::ArchSpec &arch) override;
127 
128   bool GetUUID(lldb_private::UUID *uuid) override;
129 
130   lldb_private::FileSpecList GetDebugSymbolFilePaths() override;
131 
132   uint32_t GetDependentModules(lldb_private::FileSpecList &files) override;
133 
134   lldb_private::Address
135   GetImageInfoAddress(lldb_private::Target *target) override;
136 
137   lldb_private::Address GetEntryPointAddress() override;
138 
139   ObjectFile::Type CalculateType() override;
140 
141   ObjectFile::Strata CalculateStrata() override;
142 
143   size_t ReadSectionData(lldb_private::Section *section,
144                          lldb::offset_t section_offset, void *dst,
145                          size_t dst_len) override;
146 
147   size_t ReadSectionData(lldb_private::Section *section,
148                          lldb_private::DataExtractor &section_data) override;
149 
150   // Returns number of program headers found in the ELF file.
151   size_t GetProgramHeaderCount();
152 
153   // Returns the program header with the given index.
154   const elf::ELFProgramHeader *GetProgramHeaderByIndex(lldb::user_id_t id);
155 
156   // Returns segment data for the given index.
157   lldb_private::DataExtractor GetSegmentDataByIndex(lldb::user_id_t id);
158 
159   llvm::StringRef
160   StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const override;
161 
162   void RelocateSection(lldb_private::Section *section) override;
163 
164 protected:
165 
166   std::vector<LoadableData>
167   GetLoadableData(lldb_private::Target &target) override;
168 
169 private:
170   ObjectFileELF(const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
171                 lldb::offset_t data_offset, const lldb_private::FileSpec *file,
172                 lldb::offset_t offset, lldb::offset_t length);
173 
174   ObjectFileELF(const lldb::ModuleSP &module_sp,
175                 lldb::DataBufferSP &header_data_sp,
176                 const lldb::ProcessSP &process_sp, lldb::addr_t header_addr);
177 
178   typedef std::vector<elf::ELFProgramHeader> ProgramHeaderColl;
179   typedef ProgramHeaderColl::iterator ProgramHeaderCollIter;
180   typedef ProgramHeaderColl::const_iterator ProgramHeaderCollConstIter;
181 
182   struct ELFSectionHeaderInfo : public elf::ELFSectionHeader {
183     lldb_private::ConstString section_name;
184   };
185 
186   typedef std::vector<ELFSectionHeaderInfo> SectionHeaderColl;
187   typedef SectionHeaderColl::iterator SectionHeaderCollIter;
188   typedef SectionHeaderColl::const_iterator SectionHeaderCollConstIter;
189 
190   typedef std::vector<elf::ELFDynamic> DynamicSymbolColl;
191   typedef DynamicSymbolColl::iterator DynamicSymbolCollIter;
192   typedef DynamicSymbolColl::const_iterator DynamicSymbolCollConstIter;
193 
194   typedef std::map<lldb::addr_t, lldb_private::AddressClass>
195       FileAddressToAddressClassMap;
196 
197   /// Version of this reader common to all plugins based on this class.
198   static const uint32_t m_plugin_version = 1;
199   static const uint32_t g_core_uuid_magic;
200 
201   /// ELF file header.
202   elf::ELFHeader m_header;
203 
204   /// ELF build ID.
205   lldb_private::UUID m_uuid;
206 
207   /// ELF .gnu_debuglink file and crc data if available.
208   std::string m_gnu_debuglink_file;
209   uint32_t m_gnu_debuglink_crc;
210 
211   /// Collection of program headers.
212   ProgramHeaderColl m_program_headers;
213 
214   /// Collection of section headers.
215   SectionHeaderColl m_section_headers;
216 
217   /// Collection of symbols from the dynamic table.
218   DynamicSymbolColl m_dynamic_symbols;
219 
220   /// List of file specifications corresponding to the modules (shared
221   /// libraries) on which this object file depends.
222   mutable std::unique_ptr<lldb_private::FileSpecList> m_filespec_ap;
223 
224   /// Cached value of the entry point for this module.
225   lldb_private::Address m_entry_point_address;
226 
227   /// The architecture detected from parsing elf file contents.
228   lldb_private::ArchSpec m_arch_spec;
229 
230   /// The address class for each symbol in the elf file
231   FileAddressToAddressClassMap m_address_class_map;
232 
233   /// Returns a 1 based index of the given section header.
234   size_t SectionIndex(const SectionHeaderCollIter &I);
235 
236   /// Returns a 1 based index of the given section header.
237   size_t SectionIndex(const SectionHeaderCollConstIter &I) const;
238 
239   // Parses the ELF program headers.
240   static size_t GetProgramHeaderInfo(ProgramHeaderColl &program_headers,
241                                      lldb_private::DataExtractor &object_data,
242                                      const elf::ELFHeader &header);
243 
244   // Finds PT_NOTE segments and calculates their crc sum.
245   static uint32_t
246   CalculateELFNotesSegmentsCRC32(const ProgramHeaderColl &program_headers,
247                                  lldb_private::DataExtractor &data);
248 
249   /// Parses all section headers present in this object file and populates
250   /// m_program_headers.  This method will compute the header list only once.
251   /// Returns the number of headers parsed.
252   size_t ParseProgramHeaders();
253 
254   /// Parses all section headers present in this object file and populates
255   /// m_section_headers.  This method will compute the header list only once.
256   /// Returns the number of headers parsed.
257   size_t ParseSectionHeaders();
258 
259   static void ParseARMAttributes(lldb_private::DataExtractor &data,
260                                  uint64_t length,
261                                  lldb_private::ArchSpec &arch_spec);
262 
263   /// Parses the elf section headers and returns the uuid, debug link name,
264   /// crc, archspec.
265   static size_t GetSectionHeaderInfo(SectionHeaderColl &section_headers,
266                                      lldb_private::DataExtractor &object_data,
267                                      const elf::ELFHeader &header,
268                                      lldb_private::UUID &uuid,
269                                      std::string &gnu_debuglink_file,
270                                      uint32_t &gnu_debuglink_crc,
271                                      lldb_private::ArchSpec &arch_spec);
272 
273   /// Scans the dynamic section and locates all dependent modules (shared
274   /// libraries) populating m_filespec_ap.  This method will compute the
275   /// dependent module list only once.  Returns the number of dependent
276   /// modules parsed.
277   size_t ParseDependentModules();
278 
279   /// Parses the dynamic symbol table and populates m_dynamic_symbols.  The
280   /// vector retains the order as found in the object file.  Returns the
281   /// number of dynamic symbols parsed.
282   size_t ParseDynamicSymbols();
283 
284   /// Populates m_symtab_ap will all non-dynamic linker symbols.  This method
285   /// will parse the symbols only once.  Returns the number of symbols parsed.
286   unsigned ParseSymbolTable(lldb_private::Symtab *symbol_table,
287                             lldb::user_id_t start_id,
288                             lldb_private::Section *symtab);
289 
290   /// Helper routine for ParseSymbolTable().
291   unsigned ParseSymbols(lldb_private::Symtab *symbol_table,
292                         lldb::user_id_t start_id,
293                         lldb_private::SectionList *section_list,
294                         const size_t num_symbols,
295                         const lldb_private::DataExtractor &symtab_data,
296                         const lldb_private::DataExtractor &strtab_data);
297 
298   /// Scans the relocation entries and adds a set of artificial symbols to the
299   /// given symbol table for each PLT slot.  Returns the number of symbols
300   /// added.
301   unsigned ParseTrampolineSymbols(lldb_private::Symtab *symbol_table,
302                                   lldb::user_id_t start_id,
303                                   const ELFSectionHeaderInfo *rela_hdr,
304                                   lldb::user_id_t section_id);
305 
306   void ParseUnwindSymbols(lldb_private::Symtab *symbol_table,
307                           lldb_private::DWARFCallFrameInfo *eh_frame);
308 
309   /// Relocates debug sections
310   unsigned RelocateDebugSections(const elf::ELFSectionHeader *rel_hdr,
311                                  lldb::user_id_t rel_id,
312                                  lldb_private::Symtab *thetab);
313 
314   unsigned ApplyRelocations(lldb_private::Symtab *symtab,
315                             const elf::ELFHeader *hdr,
316                             const elf::ELFSectionHeader *rel_hdr,
317                             const elf::ELFSectionHeader *symtab_hdr,
318                             const elf::ELFSectionHeader *debug_hdr,
319                             lldb_private::DataExtractor &rel_data,
320                             lldb_private::DataExtractor &symtab_data,
321                             lldb_private::DataExtractor &debug_data,
322                             lldb_private::Section *rel_section);
323 
324   /// Loads the section name string table into m_shstr_data.  Returns the
325   /// number of bytes constituting the table.
326   size_t GetSectionHeaderStringTable();
327 
328   /// Utility method for looking up a section given its name.  Returns the
329   /// index of the corresponding section or zero if no section with the given
330   /// name can be found (note that section indices are always 1 based, and so
331   /// section index 0 is never valid).
332   lldb::user_id_t GetSectionIndexByName(const char *name);
333 
334   // Returns the ID of the first section that has the given type.
335   lldb::user_id_t GetSectionIndexByType(unsigned type);
336 
337   /// Returns the section header with the given id or NULL.
338   const ELFSectionHeaderInfo *GetSectionHeaderByIndex(lldb::user_id_t id);
339 
340   /// @name  ELF header dump routines
341   //@{
342   static void DumpELFHeader(lldb_private::Stream *s,
343                             const elf::ELFHeader &header);
344 
345   static void DumpELFHeader_e_ident_EI_DATA(lldb_private::Stream *s,
346                                             unsigned char ei_data);
347 
348   static void DumpELFHeader_e_type(lldb_private::Stream *s,
349                                    elf::elf_half e_type);
350   //@}
351 
352   /// @name ELF program header dump routines
353   //@{
354   void DumpELFProgramHeaders(lldb_private::Stream *s);
355 
356   static void DumpELFProgramHeader(lldb_private::Stream *s,
357                                    const elf::ELFProgramHeader &ph);
358 
359   static void DumpELFProgramHeader_p_type(lldb_private::Stream *s,
360                                           elf::elf_word p_type);
361 
362   static void DumpELFProgramHeader_p_flags(lldb_private::Stream *s,
363                                            elf::elf_word p_flags);
364   //@}
365 
366   /// @name ELF section header dump routines
367   //@{
368   void DumpELFSectionHeaders(lldb_private::Stream *s);
369 
370   static void DumpELFSectionHeader(lldb_private::Stream *s,
371                                    const ELFSectionHeaderInfo &sh);
372 
373   static void DumpELFSectionHeader_sh_type(lldb_private::Stream *s,
374                                            elf::elf_word sh_type);
375 
376   static void DumpELFSectionHeader_sh_flags(lldb_private::Stream *s,
377                                             elf::elf_xword sh_flags);
378   //@}
379 
380   /// ELF dependent module dump routine.
381   void DumpDependentModules(lldb_private::Stream *s);
382 
383   const elf::ELFDynamic *FindDynamicSymbol(unsigned tag);
384 
385   unsigned PLTRelocationType();
386 
387   static lldb_private::Status
388   RefineModuleDetailsFromNote(lldb_private::DataExtractor &data,
389                               lldb_private::ArchSpec &arch_spec,
390                               lldb_private::UUID &uuid);
391 
392   bool AnySegmentHasPhysicalAddress();
393 };
394 
395 #endif // liblldb_ObjectFileELF_h_
396